Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the MIT License. See License.txt in the project root for
license information.
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 */

package com.microsoft.azure.management.appservice;

import com.microsoft.azure.management.apigeneration.Beta;
import com.microsoft.azure.management.apigeneration.Beta.SinceVersion;
import com.microsoft.azure.management.apigeneration.Fluent;
import com.microsoft.azure.management.apigeneration.Method;
import com.microsoft.azure.management.appservice.implementation.AppServiceManager;
import com.microsoft.azure.management.appservice.implementation.SiteInner;
import com.microsoft.azure.management.graphrbac.BuiltInRole;
import com.microsoft.azure.management.msi.Identity;
import com.microsoft.azure.management.resources.fluentcore.arm.models.GroupableResource;
import com.microsoft.azure.management.resources.fluentcore.arm.models.HasName;
import com.microsoft.azure.management.resources.fluentcore.model.Appliable;
import com.microsoft.azure.management.resources.fluentcore.model.Creatable;
import org.joda.time.DateTime;
import rx.Completable;
import rx.Observable;

import java.io.File;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Set;

An immutable client-side representation of an Azure Web App or deployment slot.
/**
 * An immutable client-side representation of an Azure Web App or deployment slot.
 */
@Fluent(ContainerName = "/Microsoft.Azure.Management.AppService.Fluent")
@Beta
public interface WebAppBase extends
        HasName,
        GroupableResource<AppServiceManager, SiteInner> {

    
Returns:
state of the web app/**
     * @return state of the web app
     */
    String state();

    
Returns:
hostnames associated with web app/**
     * @return hostnames associated with web app
     */
    Set<String> hostNames();

    
Returns:
name of repository site/**
     * @return name of repository site
     */
    String repositorySiteName();

    
Returns:
state indicating whether web app has exceeded its quota usage/**
     * @return state indicating whether web app has exceeded its quota usage
     */
    UsageState usageState();

    
Returns:
true if the site is enabled; otherwise, false/**
     * @return true if the site is enabled; otherwise, false
     */
    boolean enabled();

    
Returns:
host names for the web app that are enabled/**
     * @return host names for the web app that are enabled
     */
    Set<String> enabledHostNames();

    
Returns:
management information availability state for the web app/**
     * @return management information availability state for the web app
     */
    SiteAvailabilityState availabilityState();

    
Returns:
list of SSL states used to manage the SSL bindings for site's hostnames/**
     * @return list of SSL states used to manage the SSL bindings for site's hostnames
     */
    Map<String, HostNameSslState> hostNameSslStates();

    
Returns:
The resource ID of the app service plan/**
     * @return The resource ID of the app service plan
     */
    String appServicePlanId();

    
Returns:
Last time web app was modified in UTC/**
     * @return Last time web app was modified in UTC
     */
    DateTime lastModifiedTime();

    
Returns:
list of Azure Traffic manager host names associated with web
app/**
     * @return list of Azure Traffic manager host names associated with web
     * app
     */
    Set<String> trafficManagerHostNames();

    
Returns:
whether to stop SCM (KUDU) site when the web app is
stopped. Default is false./**
     * @return whether to stop SCM (KUDU) site when the web app is
     * stopped. Default is false.
     */
    boolean scmSiteAlsoStopped();

    
Returns:
which slot this app will swap into/**
     * @return which slot this app will swap into
     */
    String targetSwapSlot();

    
Returns:
if the client affinity is enabled when load balancing http
request for multiple instances of the web app/**
     * @return if the client affinity is enabled when load balancing http
     * request for multiple instances of the web app
     */
    boolean clientAffinityEnabled();

    
Returns:
if the client certificate is enabled for the web app/**
     * @return if the client certificate is enabled for the web app
     */
    boolean clientCertEnabled();

    
Returns:
if the public hostnames are disabled the web app.
If set to true the app is only accessible via API
Management process./**
     * @return if the public hostnames are disabled the web app.
     * If set to true the app is only accessible via API
     * Management process.
     */
    boolean hostNamesDisabled();

    
Returns:
list of IP addresses that this web app uses for
outbound connections. Those can be used when configuring firewall
rules for databases accessed by this web app./**
     * @return list of IP addresses that this web app uses for
     * outbound connections. Those can be used when configuring firewall
     * rules for databases accessed by this web app.
     */
    Set<String> outboundIPAddresses();

    
Returns:
size of a function container/**
     * @return size of a function container
     */
    int containerSize();

    
Returns:
information about whether the web app is cloned from another/**
     * @return information about whether the web app is cloned from another
     */
    CloningInfo cloningInfo();

    
Returns:
site is a default container/**
     * @return site is a default container
     */
    boolean isDefaultContainer();

    
Returns:
default hostname of the web app/**
     * @return default hostname of the web app
     */
    String defaultHostName();

    
Returns:
the default documents/**
     * @return the default documents
     */
    List<String> defaultDocuments();

    
Returns:
the .NET Framework version/**
     * @return the .NET Framework version
     */
    NetFrameworkVersion netFrameworkVersion();

    
Returns:
the version of PHP/**
     * @return the version of PHP
     */
    PhpVersion phpVersion();

    
Returns:
the version of Python/**
     * @return the version of Python
     */
    PythonVersion pythonVersion();

    
Returns:
the version of Node.JS/**
     * @return the version of Node.JS
     */
    String nodeVersion();

    
Returns:
if the remote eebugging is enabled/**
     * @return if the remote eebugging is enabled
     */
    boolean remoteDebuggingEnabled();

    
Returns:
the remote debugging version/**
     * @return the remote debugging version
     */
    RemoteVisualStudioVersion remoteDebuggingVersion();

    
Returns:
if web socket is enabled/**
     * @return if web socket is enabled
     */
    boolean webSocketsEnabled();

    
Returns:
if the web app is always on/**
     * @return if the web app is always on
     */
    boolean alwaysOn();

    
Returns:
Java version/**
     * @return Java version
     */
    JavaVersion javaVersion();

    
Returns:
Java container/**
     * @return Java container
     */
    String javaContainer();

    
Returns:
Java container version/**
     * @return Java container version
     */
    String javaContainerVersion();

    
Returns:
managed pipeline mode/**
     * @return managed pipeline mode
     */
    ManagedPipelineMode managedPipelineMode();

    
Returns:
the auto swap slot name/**
     * @return the auto swap slot name
     */
    String autoSwapSlotName();

    
Returns:
true if the web app is configured to accept only HTTPS requests. HTTP requests will be redirected./**
     * @return true if the web app is configured to accept only HTTPS requests. HTTP requests will be redirected.
     */
    boolean httpsOnly();

    
Returns:
the state of FTP / FTPS service/**
     * @return the state of FTP / FTPS service
     */
    FtpsState ftpsState();

    
Returns:
the virtual applications and their virtual directories in this web app/**
     * @return the virtual applications and their virtual directories in this web app
     */
    List<VirtualApplication> virtualApplications();

    
Returns:
whether to allow clients to connect over http2.0/**
     * @return whether to allow clients to connect over http2.0
     */
    boolean http20Enabled();

    
Returns:
the minimum version of TLS required for SSL requests./**
     * @return the minimum version of TLS required for SSL requests.
     */
    SupportedTlsVersions minTlsVersion();

    
Returns:
whether local MySQL is enabled/**
     * @return whether local MySQL is enabled
     */
    boolean localMySqlEnabled();

    
Returns:
the SCM configuration for the web app/**
     * @return the SCM configuration for the web app
     */
    ScmType scmType();

    
Returns:
the root directory for the web app/**
     * @return the root directory for the web app
     */
    String documentRoot();

    
Returns:
the System Assigned (Local) Managed Service Identity specific Active Directory tenant ID assigned
to the web app./**
     * @return the System Assigned (Local) Managed Service Identity specific Active Directory tenant ID assigned
     * to the web app.
     */
    String systemAssignedManagedServiceIdentityTenantId();

    
Returns:
the System Assigned (Local) Managed Service Identity specific Active Directory service principal ID
assigned to the web app./**
     * @return the System Assigned (Local) Managed Service Identity specific Active Directory service principal ID
     * assigned to the web app.
     */
    String systemAssignedManagedServiceIdentityPrincipalId();

    
Returns:
The ids of the user assigned identities/**
     * @return The ids of the user assigned identities
     */
    Set<String> userAssignedManagedServiceIdentityIds();

    
Returns:
the app settings defined on the web app/**
     * @return the app settings defined on the web app
     */
    Map<String, AppSetting> getAppSettings();

    
Returns:
the app settings defined on the web app/**
     * @return the app settings defined on the web app
     */
    Observable<Map<String, AppSetting>> getAppSettingsAsync();

    
Returns:
the connection strings defined on the web app/**
     * @return the connection strings defined on the web app
     */
    Map<String, ConnectionString> getConnectionStrings();

    
Returns:
the connection strings defined on the web app/**
     * @return the connection strings defined on the web app
     */
    Observable<Map<String, ConnectionString>> getConnectionStringsAsync();

    
Returns:
the authentication configuration defined on the web app/**
     * @return the authentication configuration defined on the web app
     */
    WebAppAuthentication getAuthenticationConfig();

    
Returns:
the authentication configuration defined on the web app/**
     * @return the authentication configuration defined on the web app
     */
    Observable<WebAppAuthentication> getAuthenticationConfigAsync();

    
Returns:
the operating system the web app is running on/**
     * @return the operating system the web app is running on
     */
    OperatingSystem operatingSystem();

    
Returns:
the architecture of the platform, either 32 bit (x86) or 64 bit (x64)./**
     * @return the architecture of the platform, either 32 bit (x86) or 64 bit (x64).
     */
    PlatformArchitecture platformArchitecture();

    
Returns:
the Linux app framework and version if this is a Linux web app./**
     * @return the Linux app framework and version if this is a Linux web app.
     */
    String linuxFxVersion();

    
Returns:
the diagnostic logs configuration/**
     * @return the diagnostic logs configuration
     */
    @Beta(SinceVersion.V1_18_0)
    WebAppDiagnosticLogs diagnosticLogsConfig();

    
Returns:
the mapping from host names and the host name bindings/**
     * @return the mapping from host names and the host name bindings
     */
    @Method
    Map<String, HostNameBinding> getHostNameBindings();

    
Returns:
the mapping from host names and the host name bindings/**
     * @return the mapping from host names and the host name bindings
     */
    @Method
    Observable<Map<String, HostNameBinding>> getHostNameBindingsAsync();

    
Returns:
the URL and credentials for publishing through FTP or Git/**
     * @return the URL and credentials for publishing through FTP or Git
     */
    @Method
    PublishingProfile getPublishingProfile();

    
Returns:
the URL and credentials for publishing through FTP or Git/**
     * @return the URL and credentials for publishing through FTP or Git
     */
    @Method
    Observable<PublishingProfile> getPublishingProfileAsync();

    
Returns:
the source control information for the web app/**
     * @return the source control information for the web app
     */
    @Method
    WebAppSourceControl getSourceControl();

    
Returns:
the source control information for the web app/**
     * @return the source control information for the web app
     */
    @Method
    Observable<WebAppSourceControl> getSourceControlAsync();

    
First step specifying the parameters to make a web deployment (MS Deploy) to the web app.
Returns:
a stage to create web deployment/**
     * First step specifying the parameters to make a web deployment (MS Deploy) to the web app.
     * @return a stage to create web deployment
     */
    @Method
    WebDeployment.DefinitionStages.WithPackageUri deploy();

    
Returns:
the last lines of docker logs for a Linux web app/**
     * @return the last lines of docker logs for a Linux web app
     */
    @Beta(SinceVersion.V1_5_0)
    @Method
    byte[] getContainerLogs();

    
Returns:
the last lines of docker logs for a Linux web app/**
     * @return the last lines of docker logs for a Linux web app
     */
    @Beta(SinceVersion.V1_5_0)
    @Method
    Observable<byte[]> getContainerLogsAsync();

    
Returns:
the zipped archive of docker logs for a Linux web app/**
     * @return the zipped archive of docker logs for a Linux web app
     */
    @Beta(SinceVersion.V1_5_0)
    @Method
    byte[] getContainerLogsZip();

    
Returns:
the zipped archive of docker logs for a Linux web app/**
     * @return the zipped archive of docker logs for a Linux web app
     */
    @Beta(SinceVersion.V1_5_0)
    @Method
    Observable<byte[]> getContainerLogsZipAsync();

    
Returns:
a open stream to the application logs/**
     * @return a open stream to the application logs
     */
    @Beta(SinceVersion.V1_6_0)
    @Method
    InputStream streamApplicationLogs();

    
Returns:
a open stream to the HTTP logs/**
     * @return a open stream to the HTTP logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    InputStream streamHttpLogs();

    
Returns:
a open stream to the trace logs/**
     * @return a open stream to the trace logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    InputStream streamTraceLogs();

    
Returns:
a open stream to the deployment logs/**
     * @return a open stream to the deployment logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    InputStream streamDeploymentLogs();

    
Returns:
a open stream to all logs/**
     * @return a open stream to all logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    InputStream streamAllLogs();

    
Returns:
an Observable streaming application logs/**
     * @return an Observable streaming application logs
     */
    @Beta(SinceVersion.V1_6_0)
    @Method
    Observable<String> streamApplicationLogsAsync();

    
Returns:
an Observable streaming HTTP logs/**
     * @return an Observable streaming HTTP logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    Observable<String> streamHttpLogsAsync();

    
Returns:
an Observable streaming trace logs/**
     * @return an Observable streaming trace logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    Observable<String> streamTraceLogsAsync();

    
Returns:
an Observable streaming deployment logs/**
     * @return an Observable streaming deployment logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    Observable<String> streamDeploymentLogsAsync();

    
Returns:
an Observable streaming all logs/**
     * @return an Observable streaming all logs
     */
    @Beta(SinceVersion.V1_18_0)
    @Method
    Observable<String> streamAllLogsAsync();

    
Verifies the ownership of the domain for a certificate order by verifying a hostname
of the domain is bound to this web app.
Params:
certificateOrderName – the name of the certificate order
domainVerificationToken – the domain verification token for the certificate order/**
     * Verifies the ownership of the domain for a certificate order by verifying a hostname
     * of the domain is bound to this web app.
     * @param certificateOrderName the name of the certificate order
     * @param domainVerificationToken the domain verification token for the certificate order
     */
    void verifyDomainOwnership(String certificateOrderName, String domainVerificationToken);

    
Verifies the ownership of the domain for a certificate order by verifying a hostname
of the domain is bound to this web app.
Params:
certificateOrderName – the name of the certificate order
domainVerificationToken – the domain verification token for the certificate order
Returns:
a representation of the deferred computation of this call/**
     * Verifies the ownership of the domain for a certificate order by verifying a hostname
     * of the domain is bound to this web app.
     * @param certificateOrderName the name of the certificate order
     * @param domainVerificationToken the domain verification token for the certificate order
     * @return a representation of the deferred computation of this call
     */
    Completable verifyDomainOwnershipAsync(String certificateOrderName, String domainVerificationToken);

    
Starts the web app or deployment slot.
/**
     * Starts the web app or deployment slot.
     */
    @Method
    void start();

    
Starts the web app or deployment slot.
Returns:
a representation of the deferred computation of this call/**
     * Starts the web app or deployment slot.
     * @return a representation of the deferred computation of this call
     */
    @Method
    Completable startAsync();

    
Stops the web app or deployment slot.
/**
     * Stops the web app or deployment slot.
     */
    @Method
    void stop();

    
Stops the web app or deployment slot.
Returns:
a representation of the deferred computation of this call/**
     * Stops the web app or deployment slot.
     * @return a representation of the deferred computation of this call
     */
    @Method
    Completable stopAsync();

    
Restarts the web app or deployment slot.
/**
     * Restarts the web app or deployment slot.
     */
    @Method
    void restart();

    
Restarts the web app or deployment slot.
Returns:
a representation of the deferred computation of this call/**
     * Restarts the web app or deployment slot.
     * @return a representation of the deferred computation of this call
     */
    @Method
    Completable restartAsync();

    
Swaps the app running in the current web app / slot with the app
running in the specified slot.
Params:
slotName – the target slot to swap with. Use 'production' for
                the production slot./**
     * Swaps the app running in the current web app / slot with the app
     * running in the specified slot.
     * @param slotName the target slot to swap with. Use 'production' for
     *                 the production slot.
     */
    void swap(String slotName);

    
Swaps the app running in the current web app / slot with the app
running in the specified slot.
Params:
slotName – the target slot to swap with. Use 'production' for
                the production slot.
Returns:
a representation of the deferred computation of this call/**
     * Swaps the app running in the current web app / slot with the app
     * running in the specified slot.
     * @param slotName the target slot to swap with. Use 'production' for
     *                 the production slot.
     * @return a representation of the deferred computation of this call
     */
    Completable swapAsync(String slotName);

    
Apply the slot (or sticky) configurations from the specified slot
to the current one. This is useful for "Swap with Preview".
Params:
slotName – the target slot to apply configurations from/**
     * Apply the slot (or sticky) configurations from the specified slot
     * to the current one. This is useful for "Swap with Preview".
     * @param slotName the target slot to apply configurations from
     */
    void applySlotConfigurations(String slotName);

    
Apply the slot (or sticky) configurations from the specified slot
to the current one. This is useful for "Swap with Preview".
Params:
slotName – the target slot to apply configurations from
Returns:
a representation of the deferred computation of this call/**
     * Apply the slot (or sticky) configurations from the specified slot
     * to the current one. This is useful for "Swap with Preview".
     * @param slotName the target slot to apply configurations from
     * @return a representation of the deferred computation of this call
     */
    Completable applySlotConfigurationsAsync(String slotName);

    
Reset the slot to its original configurations.
/**
     * Reset the slot to its original configurations.
     */
    @Method
    void resetSlotConfigurations();

    
Reset the slot to its original configurations.
Returns:
a representation of the deferred computation of this call/**
     * Reset the slot to its original configurations.
     * @return a representation of the deferred computation of this call
     */
    @Method
    Completable resetSlotConfigurationsAsync();

    
Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
Params:
zipFile – the ZIP file to upload/**
     * Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
     * @param zipFile the ZIP file to upload
     */
    @Beta(SinceVersion.V1_14_0)
    void zipDeploy(File zipFile);

    
Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
Params:
zipFile – the ZIP file to upload
Returns:
a completable of the operation/**
     * Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
     * @param zipFile the ZIP file to upload
     * @return a completable of the operation
     */
    @Beta(SinceVersion.V1_14_0)
    Completable zipDeployAsync(File zipFile);

    
Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
Params:
zipFile – the ZIP file to upload/**
     * Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
     * @param zipFile the ZIP file to upload
     */
    @Beta(SinceVersion.V1_14_0)
    void zipDeploy(InputStream zipFile);

    
Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
Params:
zipFile – the ZIP file to upload
Returns:
a completable of the operation/**
     * Deploys a ZIP file onto the Azure specialized Java SE image on this web app.
     * @param zipFile the ZIP file to upload
     * @return a completable of the operation
     */
    @Beta(SinceVersion.V1_14_0)
    Completable zipDeployAsync(InputStream zipFile);

    
Gets the App Settings on site from Kudu client. It might lag after App Setting update to the site.
Returns:
the App Settings on site from Kudu client/**
     * Gets the App Settings on site from Kudu client. It might lag after App Setting update to the site.
     * @return the App Settings on site from Kudu client
     */
    @Beta(SinceVersion.V1_37_0)
    Map<String, String> getSiteAppSettings();

    
Gets the App Settings on site from Kudu client. It might lag after App Setting update to the site.
Returns:
the App Settings on site from Kudu client/**
     * Gets the App Settings on site from Kudu client. It might lag after App Setting update to the site.
     * @return the App Settings on site from Kudu client
     */
    @Beta(SinceVersion.V1_37_0)
    Observable<Map<String, String>> getSiteAppSettingsAsync();

    /**************************************************************
     * Fluent interfaces to provision a Web App or deployment slot.
     **************************************************************/

    
The entirety of the web app base definition.
Type parameters:
<FluentT> – the type of the resource/**
     * The entirety of the web app base definition.
     *
     * @param <FluentT> the type of the resource
     */
    interface Definition<FluentT> extends
            DefinitionStages.WithWebContainer<FluentT>,
            DefinitionStages.WithCreate<FluentT>,
            DefinitionStages.WithSystemAssignedIdentityBasedAccessOrCreate<FluentT>,
            DefinitionStages.WithUserAssignedManagedServiceIdentityBasedAccessOrCreate<FluentT> {
    }

    
Grouping of all the site definition stages.
/**
     * Grouping of all the site definition stages.
     */
    interface DefinitionStages {
        
A web app definition stage allowing host name binding to be specified.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing host name binding to be specified.
         * @param <FluentT> the type of the resource
         */
        interface WithHostNameBinding<FluentT> {
            
Starts the definition of a new host name binding.
Returns:
the first stage of a hostname binding definition/**
             * Starts the definition of a new host name binding.
             * @return the first stage of a hostname binding definition
             */
            @Method
            HostNameBinding.DefinitionStages.Blank<WithCreate<FluentT>> defineHostnameBinding();

            
Defines a list of host names of an Azure managed domain. The DNS record type is
defaulted to be CNAME except for the root level domain ("@").
Params:
domain – the Azure managed domain
hostnames – the list of sub-domains
Returns:
the next stage of the definition/**
             * Defines a list of host names of an Azure managed domain. The DNS record type is
             * defaulted to be CNAME except for the root level domain ("@").
             * @param domain the Azure managed domain
             * @param hostnames the list of sub-domains
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withManagedHostnameBindings(AppServiceDomain domain, String... hostnames);

            
Defines a list of host names of an externally purchased domain. The hostnames
must be configured before hand to point to the web app.
Params:
domain – the external domain name
hostnames – the list of sub-domains
Returns:
the next stage of the definition/**
             * Defines a list of host names of an externally purchased domain. The hostnames
             * must be configured before hand to point to the web app.
             * @param domain the external domain name
             * @param hostnames the list of sub-domains
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withThirdPartyHostnameBinding(String domain, String... hostnames);
        }

        
A web app definition stage allowing SSL binding to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing SSL binding to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithHostNameSslBinding<FluentT> {
            
Starts a definition of an SSL binding.
Returns:
the first stage of an SSL binding definition/**
             * Starts a definition of an SSL binding.
             * @return the first stage of an SSL binding definition
             */
            @Method
            HostNameSslBinding.DefinitionStages.Blank<WithCreate<FluentT>> defineSslBinding();
        }

        
A web app definition stage allowing disabling the web app upon creation.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing disabling the web app upon creation.
         * @param <FluentT> the type of the resource
         */
        interface WithSiteEnabled<FluentT> {
            
Disables the web app upon creation.
Returns:
the next stage of the definition/**
             * Disables the web app upon creation.
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withAppDisabledOnCreation();
        }

        
A web app definition stage allowing setting if SCM site is also stopped when the web app is stopped.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing setting if SCM site is also stopped when the web app is stopped.
         * @param <FluentT> the type of the resource
         */
        interface WithScmSiteAlsoStopped<FluentT> {
            
Specifies if SCM site is also stopped when the web app is stopped.
Params:
scmSiteAlsoStopped – true if SCM site is also stopped
Returns:
the next stage of the definition/**
             * Specifies if SCM site is also stopped when the web app is stopped.
             * @param scmSiteAlsoStopped true if SCM site is also stopped
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withScmSiteAlsoStopped(boolean scmSiteAlsoStopped);
        }

        
A web app definition stage allowing setting if client affinity is enabled.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing setting if client affinity is enabled.
         * @param <FluentT> the type of the resource
         */
        interface WithClientAffinityEnabled<FluentT> {
            
Specifies if client affinity is enabled.
Params:
enabled – true if client affinity is enabled
Returns:
the next stage of the definition/**
             * Specifies if client affinity is enabled.
             * @param enabled true if client affinity is enabled
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withClientAffinityEnabled(boolean enabled);
        }

        
A web app definition stage allowing setting if client cert is enabled.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing setting if client cert is enabled.
         * @param <FluentT> the type of the resource
         */
        interface WithClientCertEnabled<FluentT> {
            
Specifies if client cert is enabled.
Params:
enabled – true if client cert is enabled
Returns:
the next stage of the definition/**
             * Specifies if client cert is enabled.
             * @param enabled true if client cert is enabled
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withClientCertEnabled(boolean enabled);
        }

        
A web app definition stage allowing Java web container to be set. This is required
after specifying Java version.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing Java web container to be set. This is required
         * after specifying Java version.
         * @param <FluentT> the type of the resource
         */
        interface WithWebContainer<FluentT> {
            
Specifies the Java web container.
Params:
webContainer – the Java web container
Returns:
the next stage of the definition/**
             * Specifies the Java web container.
             * @param webContainer the Java web container
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withWebContainer(WebContainer webContainer);
        }

        
A web app definition stage allowing other configurations to be set. These configurations
can be cloned when creating or swapping with a deployment slot.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing other configurations to be set. These configurations
         * can be cloned when creating or swapping with a deployment slot.
         * @param <FluentT> the type of the resource
         */
        interface WithSiteConfigs<FluentT> {
            
Specifies the .NET Framework version.
Params:
version – the .NET Framework version
Returns:
the next stage of the definition/**
             * Specifies the .NET Framework version.
             * @param version the .NET Framework version
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withNetFrameworkVersion(NetFrameworkVersion version);

            
Specifies the PHP version.
Params:
version – the PHP version
Returns:
the next stage of the definition/**
             * Specifies the PHP version.
             * @param version the PHP version
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withPhpVersion(PhpVersion version);

            
Turn off PHP support.
Returns:
the next stage of the definition/**
             * Turn off PHP support.
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withoutPhp();

            
Specifies the Java version.
Params:
version – the Java version
Returns:
the next stage of the definition/**
             * Specifies the Java version.
             * @param version the Java version
             * @return the next stage of the definition
             */
            WithWebContainer<FluentT> withJavaVersion(JavaVersion version);

            
Specifies the Python version.
Params:
version – the Python version
Returns:
the next stage of the definition/**
             * Specifies the Python version.
             * @param version the Python version
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withPythonVersion(PythonVersion version);

            
Specifies the platform architecture to use.
Params:
platform – the platform architecture
Returns:
the next stage of the definition/**
             * Specifies the platform architecture to use.
             * @param platform the platform architecture
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withPlatformArchitecture(PlatformArchitecture platform);

            
Specifies if web sockets are enabled.
Params:
enabled – true if web sockets are enabled
Returns:
the next stage of the definition/**
             * Specifies if web sockets are enabled.
             * @param enabled true if web sockets are enabled
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withWebSocketsEnabled(boolean enabled);

            
Specifies if the VM powering the web app is always powered on.
Params:
alwaysOn – true if the web app is always powered on
Returns:
the next stage of the definition/**
             * Specifies if the VM powering the web app is always powered on.
             * @param alwaysOn true if the web app is always powered on
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withWebAppAlwaysOn(boolean alwaysOn);

            
Specifies the managed pipeline mode.
Params:
managedPipelineMode – managed pipeline mode
Returns:
the next stage of the definition/**
             * Specifies the managed pipeline mode.
             * @param managedPipelineMode managed pipeline mode
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withManagedPipelineMode(ManagedPipelineMode managedPipelineMode);

            
Specifies the slot name to auto-swap when a deployment is completed in this web app / deployment slot.
Params:
slotName – the name of the slot, or 'production', to auto-swap
Returns:
the next stage of the definition/**
             * Specifies the slot name to auto-swap when a deployment is completed in this web app / deployment slot.
             * @param slotName the name of the slot, or 'production', to auto-swap
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withAutoSwapSlotName(String slotName);

            
Specifies the Visual Studio version for remote debugging.
Params:
remoteVisualStudioVersion – the Visual Studio version for remote debugging
Returns:
the next stage of the definition/**
             * Specifies the Visual Studio version for remote debugging.
             * @param remoteVisualStudioVersion the Visual Studio version for remote debugging
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withRemoteDebuggingEnabled(RemoteVisualStudioVersion remoteVisualStudioVersion);

            
Disables remote debugging.
Returns:
the next stage of the definition/**
             * Disables remote debugging.
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withRemoteDebuggingDisabled();

            
Adds a default document.
Params:
document – default document
Returns:
the next stage of the definition/**
             * Adds a default document.
             * @param document default document
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withDefaultDocument(String document);

            
Adds a list of default documents.
Params:
documents – list of default documents
Returns:
the next stage of the definition/**
             * Adds a list of default documents.
             * @param documents list of default documents
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withDefaultDocuments(List<String> documents);

            
Removes a default document.
Params:
document – default document to remove
Returns:
the next stage of the definition/**
             * Removes a default document.
             * @param document default document to remove
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withoutDefaultDocument(String document);

            
Sets whether the web app only accepts HTTPS traffic.
Params:
httpsOnly – true if the web app only accepts HTTPS traffic
Returns:
the next stage of web app definition/**
             * Sets whether the web app only accepts HTTPS traffic.
             * @param httpsOnly true if the web app only accepts HTTPS traffic
             * @return the next stage of web app definition
             */
            WithCreate<FluentT> withHttpsOnly(boolean httpsOnly);

            
Sets whether the web app accepts HTTP 2.0 traffic.
Params:
http20Enabled – true if the web app accepts HTTP 2.0 traffic
Returns:
the next stage of web app definition/**
             * Sets whether the web app accepts HTTP 2.0 traffic.
             * @param http20Enabled true if the web app accepts HTTP 2.0 traffic
             * @return the next stage of web app definition
             */
            WithCreate<FluentT> withHttp20Enabled(boolean http20Enabled);

            
Sets whether the web app supports certain type of FTP(S).
Params:
ftpsState – the FTP(S) configuration
Returns:
the next stage of web app definition/**
             * Sets whether the web app supports certain type of FTP(S).
             * @param ftpsState the FTP(S) configuration
             * @return the next stage of web app definition
             */
            WithCreate<FluentT> withFtpsState(FtpsState ftpsState);

            
Sets the virtual applications in the web app.
Params:
virtualApplications – the list of virtual applications in the web app
Returns:
the next stage of web app definition/**
             * Sets the virtual applications in the web app.
             * @param virtualApplications the list of virtual applications in the web app
             * @return the next stage of web app definition
             */
            WithCreate<FluentT> withVirtualApplications(List<VirtualApplication> virtualApplications);

            
Sets the minimum version of TLS required for SSL requests.
Params:
minTlsVersion – the minimum version of TLS required for SSL requests.
Returns:
the next stage of web app definition/**
             * Sets the minimum version of TLS required for SSL requests.
             * @param minTlsVersion the minimum version of TLS required for SSL requests.
             * @return the next stage of web app definition
             */
            WithCreate<FluentT> withMinTlsVersion(SupportedTlsVersions minTlsVersion);
        }

        
A web app definition stage allowing app settings to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing app settings to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithAppSettings<FluentT> {
            
Adds an app setting to the web app.
Params:
key – the key for the app setting
value – the value for the app setting
Returns:
the next stage of the definition/**
             * Adds an app setting to the web app.
             * @param key the key for the app setting
             * @param value the value for the app setting
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withAppSetting(String key, String value);

            
Specifies the app settings for the web app as a Map. 
Params:
settings – a Map of app settings
Returns:
the next stage of the definition/**
             * Specifies the app settings for the web app as a {@link Map}.
             * @param settings a {@link Map} of app settings
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withAppSettings(Map<String, String> settings);

            
Adds an app setting to the web app. This app setting will be swapped
as well after a deployment slot swap.
Params:
key – the key for the app setting
value – the value for the app setting
Returns:
the next stage of the definition/**
             * Adds an app setting to the web app. This app setting will be swapped
             * as well after a deployment slot swap.
             * @param key the key for the app setting
             * @param value the value for the app setting
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withStickyAppSetting(String key, String value);

            
Specifies the app settings for the web app as a Map. These app settings will be swapped as well after a deployment slot swap. 
Params:
settings – a Map of app settings
Returns:
the next stage of the definition/**
             * Specifies the app settings for the web app as a {@link Map}. These app settings will be swapped
             * as well after a deployment slot swap.
             * @param settings a {@link Map} of app settings
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withStickyAppSettings(Map<String, String> settings);
        }

        
A web app definition stage allowing connection strings to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing connection strings to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithConnectionString<FluentT> {
            
Adds a connection string to the web app.
Params:
name – the name of the connection string
value – the connection string value
type – the connection string type
Returns:
the next stage of the definition/**
             * Adds a connection string to the web app.
             * @param name the name of the connection string
             * @param value the connection string value
             * @param type the connection string type
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withConnectionString(String name, String value, ConnectionStringType type);

            
Adds a connection string to the web app. This connection string will be swapped
as well after a deployment slot swap.
Params:
name – the name of the connection string
value – the connection string value
type – the connection string type
Returns:
the next stage of the definition/**
             * Adds a connection string to the web app. This connection string will be swapped
             * as well after a deployment slot swap.
             * @param name the name of the connection string
             * @param value the connection string value
             * @param type the connection string type
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withStickyConnectionString(String name, String value, ConnectionStringType type);
        }

        
A web app definition stage allowing source control to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing source control to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithSourceControl<FluentT> {
            
Starts the definition of a new source control.
Returns:
the first stage of a source control definition/**
             * Starts the definition of a new source control.
             * @return the first stage of a source control definition
             */
            @Method
            WebAppSourceControl.DefinitionStages.Blank<WithCreate<FluentT>> defineSourceControl();

            
Specifies the source control to be a local Git repository on the web app.
Returns:
the next stage of the definition/**
             * Specifies the source control to be a local Git repository on the web app.
             * @return the next stage of the definition
             */
            WithCreate<FluentT> withLocalGitSourceControl();
        }

        
A web app definition stage allowing authentication to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing authentication to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithAuthentication<FluentT> {
            
Specifies the definition of a new authentication configuration.
Returns:
the first stage of an authentication definition/**
             * Specifies the definition of a new authentication configuration.
             * @return the first stage of an authentication definition
             */

            @Method
            WebAppAuthentication.DefinitionStages.Blank<WithCreate<FluentT>> defineAuthentication();
        }

        
A web app definition stage allowing diagnostic logging to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing diagnostic logging to be set.
         * @param <FluentT> the type of the resource
         */
        @Beta(SinceVersion.V1_5_0)
        interface WithDiagnosticLogging<FluentT> {
            
Specifies the definition of a new diagnostic logs configuration.
Returns:
the first stage of an diagnostic logs definition/**
             * Specifies the definition of a new diagnostic logs configuration.
             * @return the first stage of an diagnostic logs definition
             */
            @Beta(SinceVersion.V1_18_0)
            WebAppDiagnosticLogs.DefinitionStages.Blank<WithCreate<FluentT>> defineDiagnosticLogsConfiguration();

            
Specifies the configuration for container logging for Linux web apps.
Params:
quotaInMB – the limit that restricts file system usage by app diagnostics logs. Value can range from 25 MB and 100 MB.
retentionDays – maximum days of logs that will be available
Returns:
the next stage of the web app definition/**
             * Specifies the configuration for container logging for Linux web apps.
             * @param quotaInMB the limit that restricts file system usage by app diagnostics logs. Value can range from 25 MB and 100 MB.
             * @param retentionDays maximum days of logs that will be available
             * @return the next stage of the web app definition
             */
            WithCreate<FluentT> withContainerLoggingEnabled(int quotaInMB, int retentionDays);

            
Specifies the configuration for container logging for Linux web apps.
Logs will be stored on the file system for up to 35 MB.
Returns:
the next stage of the web app definition/**
             * Specifies the configuration for container logging for Linux web apps.
             * Logs will be stored on the file system for up to 35 MB.
             * @return the next stage of the web app definition
             */
            @Method
            WithCreate<FluentT> withContainerLoggingEnabled();

            
Disable the container logging for Linux web apps.
Returns:
the next stage of the web app definition/**
             * Disable the container logging for Linux web apps.
             * @return the next stage of the web app definition
             */
            @Method
            WithCreate<FluentT> withContainerLoggingDisabled();
        }

        
A web app definition stage allowing System Assigned Managed Service Identity to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing System Assigned Managed Service Identity to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithManagedServiceIdentity<FluentT> {
            
Specifies that System Assigned Managed Service Identity needs to be enabled in the web app.
Returns:
the next stage of the web app definition/**
             * Specifies that System Assigned Managed Service Identity needs to be enabled in the web app.
             * @return the next stage of the web app definition
             */
            @Method
            WithSystemAssignedIdentityBasedAccessOrCreate<FluentT> withSystemAssignedManagedServiceIdentity();

            
Specifies that User Assigned Managed Service Identity needs to be enabled in the web app.
Returns:
the next stage of the web app definition/**
             * Specifies that User Assigned Managed Service Identity needs to be enabled in the web app.
             * @return the next stage of the web app definition
             */
            @Method
            WithUserAssignedManagedServiceIdentityBasedAccessOrCreate<FluentT> withUserAssignedManagedServiceIdentity();

            
Specifies that System Assigned (Local) Managed Service Identity needs to be disabled.
Returns:
the next stage of the update/**
             * Specifies that System Assigned (Local) Managed Service Identity needs to be disabled.
             *
             * @return the next stage of the update
             */
            @Method
            Update<FluentT> withoutSystemAssignedManagedServiceIdentity();

        }

        
The stage of the System Assigned (Local) Managed Service Identity enabled web app allowing to
set access role for the identity.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the System Assigned (Local) Managed Service Identity enabled web app allowing to
         * set access role for the identity.
         * @param <FluentT> the type of the resource
         */
        interface WithSystemAssignedIdentityBasedAccessOrCreate<FluentT> extends WithCreate<FluentT> {
            
Specifies that web app's system assigned (local) identity should have the given access
(described by the role) on an ARM resource identified by the resource ID. Applications running
on the web app will have the same permission (role) on the ARM resource.
Params:
resourceId – the ARM identifier of the resource
role – access role to assigned to the web app's local identity
Returns:
the next stage of the definition/**
             * Specifies that web app's system assigned (local) identity should have the given access
             * (described by the role) on an ARM resource identified by the resource ID. Applications running
             * on the web app will have the same permission (role) on the ARM resource.
             *
             * @param resourceId the ARM identifier of the resource
             * @param role access role to assigned to the web app's local identity
             * @return the next stage of the definition
             */
            WithSystemAssignedIdentityBasedAccessOrCreate<FluentT> withSystemAssignedIdentityBasedAccessTo(String resourceId, BuiltInRole role);

            
Specifies that web app's system assigned (local) identity should have the given access
(described by the role) on the resource group that web app resides. Applications running
on the web app will have the same permission (role) on the resource group.
Params:
role – access role to assigned to the web app's local identity
Returns:
the next stage of the definition/**
             * Specifies that web app's system assigned (local) identity should have the given access
             * (described by the role) on the resource group that web app resides. Applications running
             * on the web app will have the same permission (role) on the resource group.
             *
             * @param role access role to assigned to the web app's local identity
             * @return the next stage of the definition
             */
            WithSystemAssignedIdentityBasedAccessOrCreate<FluentT> withSystemAssignedIdentityBasedAccessToCurrentResourceGroup(BuiltInRole role);

            
Specifies that web app's system assigned (local) identity should have the access
(described by the role definition) on an ARM resource identified by the resource ID.
Applications running on the web app will have the same permission (role) on the ARM resource.
Params:
resourceId – scope of the access represented in ARM resource ID format
roleDefinitionId – access role definition to assigned to the web app's local identity
Returns:
the next stage of the definition/**
             * Specifies that web app's system assigned (local) identity should have the access
             * (described by the role definition) on an ARM resource identified by the resource ID.
             * Applications running on the web app will have the same permission (role) on the ARM resource.
             *
             * @param resourceId scope of the access represented in ARM resource ID format
             * @param roleDefinitionId access role definition to assigned to the web app's local identity
             * @return the next stage of the definition
             */
            WithSystemAssignedIdentityBasedAccessOrCreate<FluentT> withSystemAssignedIdentityBasedAccessTo(String resourceId, String roleDefinitionId);

            
Specifies that web app's system assigned (local) identity should have the access
(described by the role definition) on the resource group that web app resides.
Applications running on the web app will have the same permission (role) on the
resource group.
Params:
roleDefinitionId – access role definition to assigned to the web app's local identity
Returns:
the next stage of the definition/**
             * Specifies that web app's system assigned (local) identity should have the access
             * (described by the role definition) on the resource group that web app resides.
             * Applications running on the web app will have the same permission (role) on the
             * resource group.
             *
             * @param roleDefinitionId access role definition to assigned to the web app's local identity
             * @return the next stage of the definition
             */
            WithSystemAssignedIdentityBasedAccessOrCreate<FluentT> withSystemAssignedIdentityBasedAccessToCurrentResourceGroup(String roleDefinitionId);
        }

        
The stage of the web app update allowing to add User Assigned (External) Managed Service Identities.
/**
         * The stage of the web app update allowing to add User Assigned (External) Managed Service Identities.
         */
        interface WithUserAssignedManagedServiceIdentityBasedAccessOrCreate<FluentT> extends WithCreate<FluentT> {
            
Specifies the definition of a not-yet-created user assigned identity to be associated with the web app.
Params:
creatableIdentity – a creatable identity definition
Returns:
the next stage of the definition./**
             * Specifies the definition of a not-yet-created user assigned identity to be associated with the web app.
             *
             * @param creatableIdentity a creatable identity definition
             * @return the next stage of the definition.
             */
            WithUserAssignedManagedServiceIdentityBasedAccessOrCreate<FluentT> withNewUserAssignedManagedServiceIdentity(Creatable<Identity> creatableIdentity);

            
Specifies an existing user assigned identity to be associated with the web app.
Params:
identity – the identity
Returns:
the next stage of the definition./**
             * Specifies an existing user assigned identity to be associated with the web app.
             * @param identity the identity
             * @return the next stage of the definition.
             */
            WithUserAssignedManagedServiceIdentityBasedAccessOrCreate<FluentT> withExistingUserAssignedManagedServiceIdentity(Identity identity);

            
Specifies that an user assigned identity associated with the web app should be removed.
Params:
identityId – ARM resource id of the identity
Returns:
the next stage of the virtual machine update/**
             * Specifies that an user assigned identity associated with the web app should be removed.
             *
             * @param identityId ARM resource id of the identity
             * @return the next stage of the virtual machine update
             */
            Update<FluentT> withoutUserAssignedManagedServiceIdentity(String identityId);
        }

        
A site definition with sufficient inputs to create a new web app /
deployments slot in the cloud, but exposing additional optional
inputs to specify.
Type parameters:
<FluentT> – the type of the resource/**
         * A site definition with sufficient inputs to create a new web app /
         * deployments slot in the cloud, but exposing additional optional
         * inputs to specify.
         * @param <FluentT> the type of the resource
         */
        interface WithCreate<FluentT> extends
            Creatable<FluentT>,
            GroupableResource.DefinitionWithTags<WithCreate<FluentT>>,
            WithClientAffinityEnabled<FluentT>,
            WithClientCertEnabled<FluentT>,
            WithScmSiteAlsoStopped<FluentT>,
            WithSiteConfigs<FluentT>,
            WithAppSettings<FluentT>,
            WithConnectionString<FluentT>,
            WithSourceControl<FluentT>,
            WithHostNameBinding<FluentT>,
            WithHostNameSslBinding<FluentT>,
            WithAuthentication<FluentT>,
            WithDiagnosticLogging<FluentT>,
            WithManagedServiceIdentity<FluentT> {
        }
    }

    
Grouping of all the web app update stages.
/**
     * Grouping of all the web app update stages.
     */
    interface UpdateStages {
        
The stage of the web app update allowing host name binding to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing host name binding to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithHostNameBinding<FluentT> {
            
Starts the definition of a new host name binding.
Returns:
the first stage of a hostname binding update/**
             * Starts the definition of a new host name binding.
             * @return the first stage of a hostname binding update
             */
            @Method
            HostNameBinding.UpdateDefinitionStages.Blank<Update<FluentT>> defineHostnameBinding();

            
Defines a list of host names of an Azure managed domain. The DNS record type is
defaulted to be CNAME except for the root level domain ("@").
Params:
domain – the Azure managed domain
hostnames – the list of sub-domains
Returns:
the next stage of web app update/**
             * Defines a list of host names of an Azure managed domain. The DNS record type is
             * defaulted to be CNAME except for the root level domain ("@").
             * @param domain the Azure managed domain
             * @param hostnames the list of sub-domains
             * @return the next stage of web app update
             */
            Update<FluentT> withManagedHostnameBindings(AppServiceDomain domain, String... hostnames);

            
Defines a list of host names of an externally purchased domain. The hostnames
must be configured before hand to point to the web app.
Params:
domain – the external domain name
hostnames – the list of sub-domains
Returns:
the next stage of web app update/**
             * Defines a list of host names of an externally purchased domain. The hostnames
             * must be configured before hand to point to the web app.
             * @param domain the external domain name
             * @param hostnames the list of sub-domains
             * @return the next stage of web app update
             */
            Update<FluentT> withThirdPartyHostnameBinding(String domain, String... hostnames);

            
Unbinds a hostname from the web app.
Params:
hostname – the hostname to unbind
Returns:
the next stage of web app update/**
             * Unbinds a hostname from the web app.
             * @param hostname the hostname to unbind
             * @return the next stage of web app update
             */
            Update<FluentT> withoutHostnameBinding(String hostname);
        }

        
The stage of the web app update allowing SSL binding to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing SSL binding to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithHostNameSslBinding<FluentT> {
            
Starts a definition of an SSL binding.
Returns:
the first stage of an SSL binding definition/**
             * Starts a definition of an SSL binding.
             * @return the first stage of an SSL binding definition
             */
            @Method
            HostNameSslBinding.UpdateDefinitionStages.Blank<Update<FluentT>> defineSslBinding();

            
Removes an SSL binding for a specific hostname.
Params:
hostname – the hostname to remove SSL certificate from
Returns:
the next stage of web app update/**
             * Removes an SSL binding for a specific hostname.
             * @param hostname the hostname to remove SSL certificate from
             * @return the next stage of web app update
             */
            Update<FluentT> withoutSslBinding(String hostname);
        }

        
The stage of the web app update allowing disabling the web app upon creation.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing disabling the web app upon creation.
         * @param <FluentT> the type of the resource
         */
        interface WithSiteEnabled<FluentT> {
            
Disables the web app upon creation.
Returns:
the next stage of web app update/**
             * Disables the web app upon creation.
             * @return the next stage of web app update
             */
            Update<FluentT> withAppDisabledOnCreation();
        }

        
The stage of the web app update allowing setting if SCM site is also stopped when the web app is stopped.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing setting if SCM site is also stopped when the web app is stopped.
         * @param <FluentT> the type of the resource
         */
        interface WithScmSiteAlsoStopped<FluentT> {
            
Specifies if SCM site is also stopped when the web app is stopped.
Params:
scmSiteAlsoStopped – true if SCM site is also stopped
Returns:
the next stage of web app update/**
             * Specifies if SCM site is also stopped when the web app is stopped.
             * @param scmSiteAlsoStopped true if SCM site is also stopped
             * @return the next stage of web app update
             */
            Update<FluentT> withScmSiteAlsoStopped(boolean scmSiteAlsoStopped);
        }

        
The stage of the web app update allowing setting if client affinity is enabled.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing setting if client affinity is enabled.
         * @param <FluentT> the type of the resource
         */
        interface WithClientAffinityEnabled<FluentT> {
            
Specifies if client affinity is enabled.
Params:
enabled – true if client affinity is enabled
Returns:
the next stage of web app update/**
             * Specifies if client affinity is enabled.
             * @param enabled true if client affinity is enabled
             * @return the next stage of web app update
             */
            Update<FluentT> withClientAffinityEnabled(boolean enabled);
        }

        
The stage of the web app update allowing setting if client cert is enabled.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing setting if client cert is enabled.
         * @param <FluentT> the type of the resource
         */
        interface WithClientCertEnabled<FluentT> {
            
Specifies if client cert is enabled.
Params:
enabled – true if client cert is enabled
Returns:
the next stage of web app update/**
             * Specifies if client cert is enabled.
             * @param enabled true if client cert is enabled
             * @return the next stage of web app update
             */
            Update<FluentT> withClientCertEnabled(boolean enabled);
        }

        
The stage of the web app update allowing Java web container to be set. This is required
after specifying Java version.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing Java web container to be set. This is required
         * after specifying Java version.
         * @param <FluentT> the type of the resource
         */
        interface WithWebContainer<FluentT> {
            
Specifies the Java web container.
Params:
webContainer – the Java web container
Returns:
the next stage of the web app update/**
             * Specifies the Java web container.
             * @param webContainer the Java web container
             * @return the next stage of the web app update
             */
            Update<FluentT> withWebContainer(WebContainer webContainer);
        }

        
The stage of the web app update allowing other configurations to be set. These configurations
can be cloned when creating or swapping with a deployment slot.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the web app update allowing other configurations to be set. These configurations
         * can be cloned when creating or swapping with a deployment slot.
         * @param <FluentT> the type of the resource
         */
        interface WithSiteConfigs<FluentT> {
            
Specifies the .NET Framework version.
Params:
version – the .NET Framework version
Returns:
the next stage of web app update/**
             * Specifies the .NET Framework version.
             * @param version the .NET Framework version
             * @return the next stage of web app update
             */
            Update<FluentT> withNetFrameworkVersion(NetFrameworkVersion version);

            
Specifies the PHP version.
Params:
version – the PHP version
Returns:
the next stage of web app update/**
             * Specifies the PHP version.
             * @param version the PHP version
             * @return the next stage of web app update
             */
            Update<FluentT> withPhpVersion(PhpVersion version);

            
Specifies the Java version.
Params:
version – the Java version
Returns:
the next stage of web app update/**
             * Specifies the Java version.
             * @param version the Java version
             * @return the next stage of web app update
             */
            WithWebContainer<FluentT> withJavaVersion(JavaVersion version);

            
Turn off Java support.
Returns:
the next stage of web app update/**
             * Turn off Java support.
             * @return the next stage of web app update
             */
            Update<FluentT> withoutJava();

            
Specifies the Python version.
Params:
version – the Python version
Returns:
the next stage of web app update/**
             * Specifies the Python version.
             * @param version the Python version
             * @return the next stage of web app update
             */
            Update<FluentT> withPythonVersion(PythonVersion version);

            
Turn off Python support.
Returns:
the next stage of web app update/**
             * Turn off Python support.
             * @return the next stage of web app update
             */
            Update<FluentT> withoutPython();

            
Specifies the platform architecture to use.
Params:
platform – the platform architecture
Returns:
the next stage of web app update/**
             * Specifies the platform architecture to use.
             * @param platform the platform architecture
             * @return the next stage of web app update
             */
            Update<FluentT> withPlatformArchitecture(PlatformArchitecture platform);

            
Specifies if web sockets are enabled.
Params:
enabled – true if web sockets are enabled
Returns:
the next stage of web app update/**
             * Specifies if web sockets are enabled.
             * @param enabled true if web sockets are enabled
             * @return the next stage of web app update
             */
            Update<FluentT> withWebSocketsEnabled(boolean enabled);

            
Specifies if the VM powering the web app is always powered on.
Params:
alwaysOn – true if the web app is always powered on
Returns:
the next stage of web app update/**
             * Specifies if the VM powering the web app is always powered on.
             * @param alwaysOn true if the web app is always powered on
             * @return the next stage of web app update
             */
            Update<FluentT> withWebAppAlwaysOn(boolean alwaysOn);

            
Specifies the managed pipeline mode.
Params:
managedPipelineMode – managed pipeline mode
Returns:
the next stage of web app update/**
             * Specifies the managed pipeline mode.
             * @param managedPipelineMode managed pipeline mode
             * @return the next stage of web app update
             */
            Update<FluentT> withManagedPipelineMode(ManagedPipelineMode managedPipelineMode);

            
Specifies the slot name to auto-swap when a deployment is completed in this web app / deployment slot.
Params:
slotName – the name of the slot, or 'production', to auto-swap
Returns:
the next stage of web app update/**
             * Specifies the slot name to auto-swap when a deployment is completed in this web app / deployment slot.
             * @param slotName the name of the slot, or 'production', to auto-swap
             * @return the next stage of web app update
             */
            Update<FluentT> withAutoSwapSlotName(String slotName);

            
Specifies the Visual Studio version for remote debugging.
Params:
remoteVisualStudioVersion – the Visual Studio version for remote debugging
Returns:
the next stage of web app update/**
             * Specifies the Visual Studio version for remote debugging.
             * @param remoteVisualStudioVersion the Visual Studio version for remote debugging
             * @return the next stage of web app update
             */
            Update<FluentT> withRemoteDebuggingEnabled(RemoteVisualStudioVersion remoteVisualStudioVersion);

            
Disables remote debugging.
Returns:
the next stage of web app update/**
             * Disables remote debugging.
             * @return the next stage of web app update
             */
            Update<FluentT> withRemoteDebuggingDisabled();

            
Adds a default document.
Params:
document – default document
Returns:
the next stage of web app update/**
             * Adds a default document.
             * @param document default document
             * @return the next stage of web app update
             */
            Update<FluentT> withDefaultDocument(String document);

            
Adds a list of default documents.
Params:
documents – list of default documents
Returns:
the next stage of web app update/**
             * Adds a list of default documents.
             * @param documents list of default documents
             * @return the next stage of web app update
             */
            Update<FluentT> withDefaultDocuments(List<String> documents);

            
Removes a default document.
Params:
document – default document to remove
Returns:
the next stage of web app update/**
             * Removes a default document.
             * @param document default document to remove
             * @return the next stage of web app update
             */
            Update<FluentT> withoutDefaultDocument(String document);

            
Sets whether the web app only accepts HTTPS traffic.
Params:
httpsOnly – true if the web app only accepts HTTPS traffic
Returns:
the next stage of web app update/**
             * Sets whether the web app only accepts HTTPS traffic.
             * @param httpsOnly true if the web app only accepts HTTPS traffic
             * @return the next stage of web app update
             */
            Update<FluentT> withHttpsOnly(boolean httpsOnly);

            
Sets whether the web app accepts HTTP 2.0 traffic.
Params:
http20Enabled – true if the web app accepts HTTP 2.0 traffic
Returns:
the next stage of web app update/**
             * Sets whether the web app accepts HTTP 2.0 traffic.
             * @param http20Enabled true if the web app accepts HTTP 2.0 traffic
             * @return the next stage of web app update
             */
            Update<FluentT> withHttp20Enabled(boolean http20Enabled);

            
Sets whether the web app supports certain type of FTP(S).
Params:
ftpsState – the FTP(S) configuration
Returns:
the next stage of web app update/**
             * Sets whether the web app supports certain type of FTP(S).
             * @param ftpsState the FTP(S) configuration
             * @return the next stage of web app update
             */
            Update<FluentT> withFtpsState(FtpsState ftpsState);

            
Sets the virtual applications in the web app.
Params:
virtualApplications – the list of virtual applications in the web app
Returns:
the next stage of web app update/**
             * Sets the virtual applications in the web app.
             * @param virtualApplications the list of virtual applications in the web app
             * @return the next stage of web app update
             */
            Update<FluentT> withVirtualApplications(List<VirtualApplication> virtualApplications);

            
Sets the minimum version of TLS required for SSL requests.
Params:
minTlsVersion – the minimum version of TLS required for SSL requests.
Returns:
the next stage of web app definition/**
             * Sets the minimum version of TLS required for SSL requests.
             * @param minTlsVersion the minimum version of TLS required for SSL requests.
             * @return the next stage of web app definition
             */
            Update<FluentT> withMinTlsVersion(SupportedTlsVersions minTlsVersion);
        }

        
A web app update stage allowing app settings to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app update stage allowing app settings to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithAppSettings<FluentT> {
            
Adds an app setting to the web app.
Params:
key – the key for the app setting
value – the value for the app setting
Returns:
the next stage of the web app update/**
             * Adds an app setting to the web app.
             * @param key the key for the app setting
             * @param value the value for the app setting
             * @return the next stage of the web app update
             */
            Update<FluentT> withAppSetting(String key, String value);

            
Specifies the app settings for the web app as a Map. 
Params:
settings – a Map of app settings
Returns:
the next stage of the web app update/**
             * Specifies the app settings for the web app as a {@link Map}.
             * @param settings a {@link Map} of app settings
             * @return the next stage of the web app update
             */
            Update<FluentT> withAppSettings(Map<String, String> settings);

            
Adds an app setting to the web app. This app setting
will stay at the slot during a swap.
Params:
key – the key for the app setting
value – the value for the app setting
Returns:
the next stage of the web app update/**
             * Adds an app setting to the web app. This app setting
             * will stay at the slot during a swap.
             * @param key the key for the app setting
             * @param value the value for the app setting
             * @return the next stage of the web app update
             */
            Update<FluentT> withStickyAppSetting(String key, String value);

            
Specifies the app settings for the web app as a Map. These app settings will stay at the slot during a swap. 
Params:
settings – a Map of app settings
Returns:
the next stage of the web app update/**
             * Specifies the app settings for the web app as a {@link Map}. These app settings
             * will stay at the slot during a swap.
             * @param settings a {@link Map} of app settings
             * @return the next stage of the web app update
             */
            Update<FluentT> withStickyAppSettings(Map<String, String> settings);

            
Removes an app setting from the web app.
Params:
key – the key of the app setting to remove
Returns:
the next stage of the web app update/**
             * Removes an app setting from the web app.
             * @param key the key of the app setting to remove
             * @return the next stage of the web app update
             */
            Update<FluentT> withoutAppSetting(String key);

            
Changes the stickiness of an app setting.
Params:
key – the key of the app setting to change stickiness
sticky – true if the app setting sticks to the slot during a swap
Returns:
the next stage of the web app update/**
             * Changes the stickiness of an app setting.
             * @param key the key of the app setting to change stickiness
             * @param sticky true if the app setting sticks to the slot during a swap
             * @return the next stage of the web app update
             */
            Update<FluentT> withAppSettingStickiness(String key, boolean sticky);
        }

        
A web app update stage allowing connection strings to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app update stage allowing connection strings to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithConnectionString<FluentT> {
            
Adds a connection string to the web app.
Params:
name – the name of the connection string
value – the connection string value
type – the connection string type
Returns:
the next stage of the web app update/**
             * Adds a connection string to the web app.
             * @param name the name of the connection string
             * @param value the connection string value
             * @param type the connection string type
             * @return the next stage of the web app update
             */
            Update<FluentT> withConnectionString(String name, String value, ConnectionStringType type);

            
Adds a connection string to the web app. This connection string
will stay at the slot during a swap.
Params:
name – the name of the connection string
value – the connection string value
type – the connection string type
Returns:
the next stage of the web app update/**
             * Adds a connection string to the web app. This connection string
             * will stay at the slot during a swap.
             * @param name the name of the connection string
             * @param value the connection string value
             * @param type the connection string type
             * @return the next stage of the web app update
             */
            Update<FluentT> withStickyConnectionString(String name, String value, ConnectionStringType type);

            
Removes a connection string from the web app.
Params:
name – the name of the connection string
Returns:
the next stage of the web app update/**
             * Removes a connection string from the web app.
             * @param name the name of the connection string
             * @return the next stage of the web app update
             */
            Update<FluentT> withoutConnectionString(String name);

            
Changes the stickiness of a connection string.
Params:
name – the name of the connection string
sticky – true if the connection string sticks to the slot during a swap
Returns:
the next stage of the web app update/**
             * Changes the stickiness of a connection string.
             * @param name the name of the connection string
             * @param sticky true if the connection string sticks to the slot during a swap
             * @return the next stage of the web app update
             */
            Update<FluentT> withConnectionStringStickiness(String name, boolean sticky);
        }

        
A web app update stage allowing source control to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app update stage allowing source control to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithSourceControl<FluentT> {
            
Starts the definition of a new source control.
Returns:
the first stage of a source control definition/**
             * Starts the definition of a new source control.
             * @return the first stage of a source control definition
             */
            @Method
            WebAppSourceControl.UpdateDefinitionStages.Blank<Update<FluentT>> defineSourceControl();

            
Removes source control for deployment from the web app.
Returns:
the next stage of the web app update/**
             * Removes source control for deployment from the web app.
             * @return the next stage of the web app update
             */
            Update<FluentT> withoutSourceControl();

            
Specifies the source control to be a local Git repository on the web app.
Returns:
the next stage of the web app update/**
             * Specifies the source control to be a local Git repository on the web app.
             * @return the next stage of the web app update
             */
            Update<FluentT> withLocalGitSourceControl();

        }

        
A web app definition stage allowing authentication to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing authentication to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithAuthentication<FluentT> {
            
Specifies the definition of a new authentication configuration.
Returns:
the first stage of an authentication definition/**
             * Specifies the definition of a new authentication configuration.
             * @return the first stage of an authentication definition
             */
            @Method
            WebAppAuthentication.UpdateDefinitionStages.Blank<Update<FluentT>> defineAuthentication();

            
Turns off the authentication on the web app.
Returns:
the next stage of the web app update/**
             * Turns off the authentication on the web app.
             * @return the next stage of the web app update
             */
            Update<FluentT> withoutAuthentication();
        }

        
A web app definition stage allowing diagnostic logging to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing diagnostic logging to be set.
         * @param <FluentT> the type of the resource
         */
        @Beta(SinceVersion.V1_5_0)
        interface WithDiagnosticLogging<FluentT> {
            
Specifies the update of an existing diagnostic logs configuration.
Returns:
the first stage of an diagnostic logs update/**
             * Specifies the update of an existing diagnostic logs configuration.
             * @return the first stage of an diagnostic logs update
             */
            @Beta(SinceVersion.V1_18_0)
            WebAppDiagnosticLogs.UpdateStages.Blank<Update<FluentT>> updateDiagnosticLogsConfiguration();

            
Specifies the configuration for container logging for Linux web apps.
Params:
quotaInMB – the limit that restricts file system usage by app diagnostics logs. Value can range from 25 MB and 100 MB.
retentionDays – maximum days of logs that will be available
Returns:
the next stage of the web app update/**
             * Specifies the configuration for container logging for Linux web apps.
             * @param quotaInMB the limit that restricts file system usage by app diagnostics logs. Value can range from 25 MB and 100 MB.
             * @param retentionDays maximum days of logs that will be available
             * @return the next stage of the web app update
             */
            Update<FluentT> withContainerLoggingEnabled(int quotaInMB, int retentionDays);

            
Specifies the configuration for container logging for Linux web apps.
Logs will be stored on the file system for up to 35 MB.
Returns:
the next stage of the web app update/**
             * Specifies the configuration for container logging for Linux web apps.
             * Logs will be stored on the file system for up to 35 MB.
             * @return the next stage of the web app update
             */
            @Method
            Update<FluentT> withContainerLoggingEnabled();

            
Disable the container logging for Linux web apps.
Returns:
the next stage of the web app update/**
             * Disable the container logging for Linux web apps.
             * @return the next stage of the web app update
             */
            @Method
            Update<FluentT> withContainerLoggingDisabled();
        }

        
A web app definition stage allowing System Assigned Managed Service Identity to be set.
Type parameters:
<FluentT> – the type of the resource/**
         * A web app definition stage allowing System Assigned Managed Service Identity to be set.
         * @param <FluentT> the type of the resource
         */
        interface WithManagedServiceIdentity<FluentT> {
            
Specifies that System Assigned Managed Service Identity needs to be enabled in the web app.
Returns:
the next stage of the web app definition/**
             * Specifies that System Assigned Managed Service Identity needs to be enabled in the web app.
             * @return the next stage of the web app definition
             */
            @Method
            Update<FluentT> withSystemAssignedManagedServiceIdentity();

            
Specifies that User Assigned Managed Service Identity needs to be enabled in the web app.
Returns:
the next stage of the web app definition/**
             * Specifies that User Assigned Managed Service Identity needs to be enabled in the web app.
             * @return the next stage of the web app definition
             */
            @Method
            Update<FluentT> withUserAssignedManagedServiceIdentity();
        }

        
The stage of the System Assigned (Local) Managed Service Identity enabled web app allowing to
set access role for the identity.
Type parameters:
<FluentT> – the type of the resource/**
         * The stage of the System Assigned (Local) Managed Service Identity enabled web app allowing to
         * set access role for the identity.
         * @param <FluentT> the type of the resource
         */
        interface WithSystemAssignedIdentityBasedAccess<FluentT> {
            
Specifies that web app's system assigned (local) identity should have the given access
(described by the role) on an ARM resource identified by the resource ID. Applications running
on the web app will have the same permission (role) on the ARM resource.
Params:
resourceId – the ARM identifier of the resource
role – access role to assigned to the web app's local identity
Returns:
the next stage of the update/**
             * Specifies that web app's system assigned (local) identity should have the given access
             * (described by the role) on an ARM resource identified by the resource ID. Applications running
             * on the web app will have the same permission (role) on the ARM resource.
             *
             * @param resourceId the ARM identifier of the resource
             * @param role access role to assigned to the web app's local identity
             * @return the next stage of the update
             */
            Update<FluentT> withSystemAssignedIdentityBasedAccessTo(String resourceId, BuiltInRole role);

            
Specifies that web app's system assigned (local) identity should have the given access
(described by the role) on the resource group that web app resides. Applications running
on the web app will have the same permission (role) on the resource group.
Params:
role – access role to assigned to the web app's local identity
Returns:
the next stage of the update/**
             * Specifies that web app's system assigned (local) identity should have the given access
             * (described by the role) on the resource group that web app resides. Applications running
             * on the web app will have the same permission (role) on the resource group.
             *
             * @param role access role to assigned to the web app's local identity
             * @return the next stage of the update
             */
            Update<FluentT> withSystemAssignedIdentityBasedAccessToCurrentResourceGroup(BuiltInRole role);

            
Specifies that web app's system assigned (local) identity should have the access
(described by the role definition) on an ARM resource identified by the resource ID.
Applications running on the web app will have the same permission (role) on the ARM resource.
Params:
resourceId – scope of the access represented in ARM resource ID format
roleDefinitionId – access role definition to assigned to the web app's local identity
Returns:
the next stage of the update/**
             * Specifies that web app's system assigned (local) identity should have the access
             * (described by the role definition) on an ARM resource identified by the resource ID.
             * Applications running on the web app will have the same permission (role) on the ARM resource.
             *
             * @param resourceId scope of the access represented in ARM resource ID format
             * @param roleDefinitionId access role definition to assigned to the web app's local identity
             * @return the next stage of the update
             */
            Update<FluentT> withSystemAssignedIdentityBasedAccessTo(String resourceId, String roleDefinitionId);

            
Specifies that web app's system assigned (local) identity should have the access
(described by the role definition) on the resource group that web app resides.
Applications running on the web app will have the same permission (role) on the
resource group.
Params:
roleDefinitionId – access role definition to assigned to the web app's local identity
Returns:
the next stage of the update/**
             * Specifies that web app's system assigned (local) identity should have the access
             * (described by the role definition) on the resource group that web app resides.
             * Applications running on the web app will have the same permission (role) on the
             * resource group.
             *
             * @param roleDefinitionId access role definition to assigned to the web app's local identity
             * @return the next stage of the update
             */
            Update<FluentT> withSystemAssignedIdentityBasedAccessToCurrentResourceGroup(String roleDefinitionId);
        }

        
The stage of the web app update allowing to add User Assigned (External) Managed Service Identities.
/**
         * The stage of the web app update allowing to add User Assigned (External) Managed Service Identities.
         */
        interface WithUserAssignedManagedServiceIdentityBasedAccess<FluentT> {
            
Specifies the definition of a not-yet-created user assigned identity to be associated with the web app.
Params:
creatableIdentity – a creatable identity definition
Returns:
the next stage of the definition./**
             * Specifies the definition of a not-yet-created user assigned identity to be associated with the web app.
             *
             * @param creatableIdentity a creatable identity definition
             * @return the next stage of the definition.
             */
            Update<FluentT> withNewUserAssignedManagedServiceIdentity(Creatable<Identity> creatableIdentity);

            
Specifies an existing user assigned identity to be associated with the web app.
Params:
identity – the identity
Returns:
the next stage of the definition./**
             * Specifies an existing user assigned identity to be associated with the web app.
             * @param identity the identity
             * @return the next stage of the definition.
             */
            Update<FluentT> withExistingUserAssignedManagedServiceIdentity(Identity identity);
        }
    }

    
The template for a site update operation, containing all the settings that can be modified.
Type parameters:
<FluentT> – the type of the resource/**
     * The template for a site update operation, containing all the settings that can be modified.
     * @param <FluentT> the type of the resource
     */
    interface Update<FluentT> extends
        Appliable<FluentT>,
        GroupableResource.UpdateWithTags<Update<FluentT>>,
        UpdateStages.WithClientAffinityEnabled<FluentT>,
        UpdateStages.WithClientCertEnabled<FluentT>,
        UpdateStages.WithScmSiteAlsoStopped<FluentT>,
        UpdateStages.WithSiteConfigs<FluentT>,
        UpdateStages.WithAppSettings<FluentT>,
        UpdateStages.WithConnectionString<FluentT>,
        UpdateStages.WithSourceControl<FluentT>,
        UpdateStages.WithHostNameBinding<FluentT>,
        UpdateStages.WithHostNameSslBinding<FluentT>,
        UpdateStages.WithAuthentication<FluentT>,
        UpdateStages.WithDiagnosticLogging<FluentT>,
        UpdateStages.WithManagedServiceIdentity<FluentT>,
        UpdateStages.WithSystemAssignedIdentityBasedAccess<FluentT>,
        UpdateStages.WithUserAssignedManagedServiceIdentityBasedAccess<FluentT> {
    }
}