botbook/node_modules/@azure/arm-appservice/review/arm-appservice.api.md

## API Report File for "@azure/arm-appservice"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

/// <reference types="node" />

import * as coreAuth from '@azure/core-auth';
import * as coreClient from '@azure/core-client';
import { OperationState } from '@azure/core-lro';
import { PagedAsyncIterableIterator } from '@azure/core-paging';
import { SimplePollerLike } from '@azure/core-lro';

// @public
export interface AbnormalTimePeriod {
    endTime?: Date;
    events?: DetectorAbnormalTimePeriod[];
    solutions?: Solution[];
    startTime?: Date;
}

// @public
export type ActiveRevisionsMode = string;

// @public
export interface Address {
    address1: string;
    address2?: string;
    city: string;
    country: string;
    postalCode: string;
    state: string;
}

// @public
export interface AddressResponse extends ProxyOnlyResource {
    internalIpAddress?: string;
    outboundIpAddresses?: string[];
    serviceIpAddress?: string;
    vipMappings?: VirtualIPMapping[];
}

// @public
export interface AllowedAudiencesValidation {
    allowedAudiences?: string[];
}

// @public
export interface AllowedPrincipals {
    groups?: string[];
    identities?: string[];
}

// @public
export interface AnalysisData {
    data?: NameValuePair[][];
    detectorDefinition?: DetectorDefinition;
    detectorMetaData?: ResponseMetaData;
    metrics?: DiagnosticMetricSet[];
    source?: string;
}

// @public
export interface AnalysisDefinition extends ProxyOnlyResource {
    readonly description?: string;
}

// @public
export interface ApiDefinitionInfo {
    url?: string;
}

// @public
export interface ApiKVReference extends ProxyOnlyResource {
    // (undocumented)
    activeVersion?: string;
    // (undocumented)
    details?: string;
    identityType?: ManagedServiceIdentity;
    // (undocumented)
    reference?: string;
    // (undocumented)
    secretName?: string;
    // (undocumented)
    secretVersion?: string;
    // (undocumented)
    source?: "KeyVault";
    // (undocumented)
    status?: ResolveStatus;
    // (undocumented)
    vaultName?: string;
}

// @public (undocumented)
export interface ApiKVReferenceCollection {
    readonly nextLink?: string;
    value: ApiKVReference[];
}

// @public
export interface ApiManagementConfig {
    id?: string;
}

// @public
export interface AppInsightsWebAppStackSettings {
    readonly isDefaultOff?: boolean;
    readonly isSupported?: boolean;
}

// @public
export interface Apple {
    enabled?: boolean;
    login?: LoginScopes;
    registration?: AppleRegistration;
}

// @public
export interface AppleRegistration {
    clientId?: string;
    clientSecretSettingName?: string;
}

// @public
export interface ApplicationLogsConfig {
    azureBlobStorage?: AzureBlobStorageApplicationLogsConfig;
    azureTableStorage?: AzureTableStorageApplicationLogsConfig;
    fileSystem?: FileSystemApplicationLogsConfig;
}

// @public
export interface ApplicationStack {
    dependency?: string;
    display?: string;
    frameworks?: ApplicationStack[];
    isDeprecated?: ApplicationStack[];
    majorVersions?: StackMajorVersion[];
    name?: string;
}

// @public
export interface ApplicationStackCollection {
    readonly nextLink?: string;
    value: ApplicationStackResource[];
}

// @public
export interface ApplicationStackResource extends ProxyOnlyResource {
    dependency?: string;
    display?: string;
    frameworks?: ApplicationStack[];
    isDeprecated?: ApplicationStack[];
    majorVersions?: StackMajorVersion[];
    namePropertiesName?: string;
}

// @public (undocumented)
export interface AppLogsConfiguration {
    // (undocumented)
    destination?: string;
    // (undocumented)
    logAnalyticsConfiguration?: LogAnalyticsConfiguration;
}

// @public
export interface AppRegistration {
    appId?: string;
    appSecretSettingName?: string;
}

// @public
export interface AppServiceCertificate {
    keyVaultId?: string;
    keyVaultSecretName?: string;
    readonly provisioningState?: KeyVaultSecretStatus;
}

// @public
export interface AppServiceCertificateCollection {
    readonly nextLink?: string;
    value: AppServiceCertificateResource[];
}

// @public
export interface AppServiceCertificateOrder extends Resource {
    readonly appServiceCertificateNotRenewableReasons?: ResourceNotRenewableReason[];
    autoRenew?: boolean;
    certificates?: {
        [propertyName: string]: AppServiceCertificate;
    };
    readonly contact?: CertificateOrderContact;
    csr?: string;
    distinguishedName?: string;
    readonly domainVerificationToken?: string;
    readonly expirationTime?: Date;
    readonly intermediate?: CertificateDetails;
    readonly isPrivateKeyExternal?: boolean;
    keySize?: number;
    readonly lastCertificateIssuanceTime?: Date;
    readonly nextAutoRenewalTimeStamp?: Date;
    productType?: CertificateProductType;
    readonly provisioningState?: ProvisioningState;
    readonly root?: CertificateDetails;
    readonly serialNumber?: string;
    readonly signedCertificate?: CertificateDetails;
    readonly status?: CertificateOrderStatus;
    validityInYears?: number;
}

// @public
export interface AppServiceCertificateOrderCollection {
    readonly nextLink?: string;
    value: AppServiceCertificateOrder[];
}

// @public
export interface AppServiceCertificateOrderPatchResource extends ProxyOnlyResource {
    readonly appServiceCertificateNotRenewableReasons?: ResourceNotRenewableReason[];
    autoRenew?: boolean;
    certificates?: {
        [propertyName: string]: AppServiceCertificate;
    };
    readonly contact?: CertificateOrderContact;
    csr?: string;
    distinguishedName?: string;
    readonly domainVerificationToken?: string;
    readonly expirationTime?: Date;
    readonly intermediate?: CertificateDetails;
    readonly isPrivateKeyExternal?: boolean;
    keySize?: number;
    readonly lastCertificateIssuanceTime?: Date;
    readonly nextAutoRenewalTimeStamp?: Date;
    productType?: CertificateProductType;
    readonly provisioningState?: ProvisioningState;
    readonly root?: CertificateDetails;
    readonly serialNumber?: string;
    readonly signedCertificate?: CertificateDetails;
    readonly status?: CertificateOrderStatus;
    validityInYears?: number;
}

// @public
export interface AppServiceCertificateOrders {
    beginCreateOrUpdate(resourceGroupName: string, certificateOrderName: string, certificateDistinguishedName: AppServiceCertificateOrder, options?: AppServiceCertificateOrdersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceCertificateOrdersCreateOrUpdateResponse>, AppServiceCertificateOrdersCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, certificateOrderName: string, certificateDistinguishedName: AppServiceCertificateOrder, options?: AppServiceCertificateOrdersCreateOrUpdateOptionalParams): Promise<AppServiceCertificateOrdersCreateOrUpdateResponse>;
    beginCreateOrUpdateCertificate(resourceGroupName: string, certificateOrderName: string, name: string, keyVaultCertificate: AppServiceCertificateResource, options?: AppServiceCertificateOrdersCreateOrUpdateCertificateOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceCertificateOrdersCreateOrUpdateCertificateResponse>, AppServiceCertificateOrdersCreateOrUpdateCertificateResponse>>;
    beginCreateOrUpdateCertificateAndWait(resourceGroupName: string, certificateOrderName: string, name: string, keyVaultCertificate: AppServiceCertificateResource, options?: AppServiceCertificateOrdersCreateOrUpdateCertificateOptionalParams): Promise<AppServiceCertificateOrdersCreateOrUpdateCertificateResponse>;
    delete(resourceGroupName: string, certificateOrderName: string, options?: AppServiceCertificateOrdersDeleteOptionalParams): Promise<void>;
    deleteCertificate(resourceGroupName: string, certificateOrderName: string, name: string, options?: AppServiceCertificateOrdersDeleteCertificateOptionalParams): Promise<void>;
    get(resourceGroupName: string, certificateOrderName: string, options?: AppServiceCertificateOrdersGetOptionalParams): Promise<AppServiceCertificateOrdersGetResponse>;
    getCertificate(resourceGroupName: string, certificateOrderName: string, name: string, options?: AppServiceCertificateOrdersGetCertificateOptionalParams): Promise<AppServiceCertificateOrdersGetCertificateResponse>;
    list(options?: AppServiceCertificateOrdersListOptionalParams): PagedAsyncIterableIterator<AppServiceCertificateOrder>;
    listByResourceGroup(resourceGroupName: string, options?: AppServiceCertificateOrdersListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AppServiceCertificateOrder>;
    listCertificates(resourceGroupName: string, certificateOrderName: string, options?: AppServiceCertificateOrdersListCertificatesOptionalParams): PagedAsyncIterableIterator<AppServiceCertificateResource>;
    reissue(resourceGroupName: string, certificateOrderName: string, reissueCertificateOrderRequest: ReissueCertificateOrderRequest, options?: AppServiceCertificateOrdersReissueOptionalParams): Promise<void>;
    renew(resourceGroupName: string, certificateOrderName: string, renewCertificateOrderRequest: RenewCertificateOrderRequest, options?: AppServiceCertificateOrdersRenewOptionalParams): Promise<void>;
    resendEmail(resourceGroupName: string, certificateOrderName: string, options?: AppServiceCertificateOrdersResendEmailOptionalParams): Promise<void>;
    resendRequestEmails(resourceGroupName: string, certificateOrderName: string, nameIdentifier: NameIdentifier, options?: AppServiceCertificateOrdersResendRequestEmailsOptionalParams): Promise<void>;
    retrieveCertificateActions(resourceGroupName: string, name: string, options?: AppServiceCertificateOrdersRetrieveCertificateActionsOptionalParams): Promise<AppServiceCertificateOrdersRetrieveCertificateActionsResponse>;
    retrieveCertificateEmailHistory(resourceGroupName: string, name: string, options?: AppServiceCertificateOrdersRetrieveCertificateEmailHistoryOptionalParams): Promise<AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse>;
    retrieveSiteSeal(resourceGroupName: string, certificateOrderName: string, siteSealRequest: SiteSealRequest, options?: AppServiceCertificateOrdersRetrieveSiteSealOptionalParams): Promise<AppServiceCertificateOrdersRetrieveSiteSealResponse>;
    update(resourceGroupName: string, certificateOrderName: string, certificateDistinguishedName: AppServiceCertificateOrderPatchResource, options?: AppServiceCertificateOrdersUpdateOptionalParams): Promise<AppServiceCertificateOrdersUpdateResponse>;
    updateCertificate(resourceGroupName: string, certificateOrderName: string, name: string, keyVaultCertificate: AppServiceCertificatePatchResource, options?: AppServiceCertificateOrdersUpdateCertificateOptionalParams): Promise<AppServiceCertificateOrdersUpdateCertificateResponse>;
    validatePurchaseInformation(appServiceCertificateOrder: AppServiceCertificateOrder, options?: AppServiceCertificateOrdersValidatePurchaseInformationOptionalParams): Promise<void>;
    verifyDomainOwnership(resourceGroupName: string, certificateOrderName: string, options?: AppServiceCertificateOrdersVerifyDomainOwnershipOptionalParams): Promise<void>;
}

// @public
export interface AppServiceCertificateOrdersCreateOrUpdateCertificateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceCertificateOrdersCreateOrUpdateCertificateResponse = AppServiceCertificateResource;

// @public
export interface AppServiceCertificateOrdersCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceCertificateOrdersCreateOrUpdateResponse = AppServiceCertificateOrder;

// @public
export interface AppServiceCertificateOrdersDeleteCertificateOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersGetCertificateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersGetCertificateResponse = AppServiceCertificateResource;

// @public
export interface AppServiceCertificateOrdersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersGetResponse = AppServiceCertificateOrder;

// @public
export interface AppServiceCertificateOrdersListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersListByResourceGroupNextResponse = AppServiceCertificateOrderCollection;

// @public
export interface AppServiceCertificateOrdersListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersListByResourceGroupResponse = AppServiceCertificateOrderCollection;

// @public
export interface AppServiceCertificateOrdersListCertificatesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersListCertificatesNextResponse = AppServiceCertificateCollection;

// @public
export interface AppServiceCertificateOrdersListCertificatesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersListCertificatesResponse = AppServiceCertificateCollection;

// @public
export interface AppServiceCertificateOrdersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersListNextResponse = AppServiceCertificateOrderCollection;

// @public
export interface AppServiceCertificateOrdersListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersListResponse = AppServiceCertificateOrderCollection;

// @public
export interface AppServiceCertificateOrdersReissueOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersRenewOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersResendEmailOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersResendRequestEmailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersRetrieveCertificateActionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersRetrieveCertificateActionsResponse = CertificateOrderAction[];

// @public
export interface AppServiceCertificateOrdersRetrieveCertificateEmailHistoryOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse = CertificateEmail[];

// @public
export interface AppServiceCertificateOrdersRetrieveSiteSealOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersRetrieveSiteSealResponse = SiteSeal;

// @public
export interface AppServiceCertificateOrdersUpdateCertificateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersUpdateCertificateResponse = AppServiceCertificateResource;

// @public
export interface AppServiceCertificateOrdersUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceCertificateOrdersUpdateResponse = AppServiceCertificateOrder;

// @public
export interface AppServiceCertificateOrdersValidatePurchaseInformationOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificateOrdersVerifyDomainOwnershipOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceCertificatePatchResource extends ProxyOnlyResource {
    keyVaultId?: string;
    keyVaultSecretName?: string;
    readonly provisioningState?: KeyVaultSecretStatus;
}

// @public
export interface AppServiceCertificateResource extends Resource {
    keyVaultId?: string;
    keyVaultSecretName?: string;
    readonly provisioningState?: KeyVaultSecretStatus;
}

// @public
export interface AppServiceEnvironment {
    clusterSettings?: NameValuePair[];
    customDnsSuffixConfiguration?: CustomDnsSuffixConfiguration;
    dedicatedHostCount?: number;
    dnsSuffix?: string;
    frontEndScaleFactor?: number;
    readonly hasLinuxWorkers?: boolean;
    internalLoadBalancingMode?: LoadBalancingMode;
    ipsslAddressCount?: number;
    readonly maximumNumberOfMachines?: number;
    readonly multiRoleCount?: number;
    multiSize?: string;
    networkingConfiguration?: AseV3NetworkingConfiguration;
    readonly provisioningState?: ProvisioningState;
    readonly status?: HostingEnvironmentStatus;
    readonly suspended?: boolean;
    readonly upgradeAvailability?: UpgradeAvailability;
    upgradePreference?: UpgradePreference;
    userWhitelistedIpRanges?: string[];
    virtualNetwork: VirtualNetworkProfile;
    zoneRedundant?: boolean;
}

// @public
export interface AppServiceEnvironmentCollection {
    readonly nextLink?: string;
    value: AppServiceEnvironmentResource[];
}

// @public
export interface AppServiceEnvironmentPatchResource extends ProxyOnlyResource {
    clusterSettings?: NameValuePair[];
    customDnsSuffixConfiguration?: CustomDnsSuffixConfiguration;
    dedicatedHostCount?: number;
    dnsSuffix?: string;
    frontEndScaleFactor?: number;
    readonly hasLinuxWorkers?: boolean;
    internalLoadBalancingMode?: LoadBalancingMode;
    ipsslAddressCount?: number;
    readonly maximumNumberOfMachines?: number;
    readonly multiRoleCount?: number;
    multiSize?: string;
    networkingConfiguration?: AseV3NetworkingConfiguration;
    readonly provisioningState?: ProvisioningState;
    readonly status?: HostingEnvironmentStatus;
    readonly suspended?: boolean;
    readonly upgradeAvailability?: UpgradeAvailability;
    upgradePreference?: UpgradePreference;
    userWhitelistedIpRanges?: string[];
    virtualNetwork?: VirtualNetworkProfile;
    zoneRedundant?: boolean;
}

// @public
export interface AppServiceEnvironmentResource extends Resource {
    clusterSettings?: NameValuePair[];
    customDnsSuffixConfiguration?: CustomDnsSuffixConfiguration;
    dedicatedHostCount?: number;
    dnsSuffix?: string;
    frontEndScaleFactor?: number;
    readonly hasLinuxWorkers?: boolean;
    internalLoadBalancingMode?: LoadBalancingMode;
    ipsslAddressCount?: number;
    readonly maximumNumberOfMachines?: number;
    readonly multiRoleCount?: number;
    multiSize?: string;
    networkingConfiguration?: AseV3NetworkingConfiguration;
    readonly provisioningState?: ProvisioningState;
    readonly status?: HostingEnvironmentStatus;
    readonly suspended?: boolean;
    readonly upgradeAvailability?: UpgradeAvailability;
    upgradePreference?: UpgradePreference;
    userWhitelistedIpRanges?: string[];
    virtualNetwork?: VirtualNetworkProfile;
    zoneRedundant?: boolean;
}

// @public
export interface AppServiceEnvironments {
    beginApproveOrRejectPrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionResponse>, AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionResponse>>;
    beginApproveOrRejectPrivateEndpointConnectionAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionOptionalParams): Promise<AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionResponse>;
    beginCreateOrUpdate(resourceGroupName: string, name: string, hostingEnvironmentEnvelope: AppServiceEnvironmentResource, options?: AppServiceEnvironmentsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceEnvironmentsCreateOrUpdateResponse>, AppServiceEnvironmentsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, name: string, hostingEnvironmentEnvelope: AppServiceEnvironmentResource, options?: AppServiceEnvironmentsCreateOrUpdateOptionalParams): Promise<AppServiceEnvironmentsCreateOrUpdateResponse>;
    beginCreateOrUpdateMultiRolePool(resourceGroupName: string, name: string, multiRolePoolEnvelope: WorkerPoolResource, options?: AppServiceEnvironmentsCreateOrUpdateMultiRolePoolOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceEnvironmentsCreateOrUpdateMultiRolePoolResponse>, AppServiceEnvironmentsCreateOrUpdateMultiRolePoolResponse>>;
    beginCreateOrUpdateMultiRolePoolAndWait(resourceGroupName: string, name: string, multiRolePoolEnvelope: WorkerPoolResource, options?: AppServiceEnvironmentsCreateOrUpdateMultiRolePoolOptionalParams): Promise<AppServiceEnvironmentsCreateOrUpdateMultiRolePoolResponse>;
    beginCreateOrUpdateWorkerPool(resourceGroupName: string, name: string, workerPoolName: string, workerPoolEnvelope: WorkerPoolResource, options?: AppServiceEnvironmentsCreateOrUpdateWorkerPoolOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceEnvironmentsCreateOrUpdateWorkerPoolResponse>, AppServiceEnvironmentsCreateOrUpdateWorkerPoolResponse>>;
    beginCreateOrUpdateWorkerPoolAndWait(resourceGroupName: string, name: string, workerPoolName: string, workerPoolEnvelope: WorkerPoolResource, options?: AppServiceEnvironmentsCreateOrUpdateWorkerPoolOptionalParams): Promise<AppServiceEnvironmentsCreateOrUpdateWorkerPoolResponse>;
    beginDelete(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsDeleteOptionalParams): Promise<void>;
    beginDeletePrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: AppServiceEnvironmentsDeletePrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<AppServiceEnvironmentsDeletePrivateEndpointConnectionResponse>, AppServiceEnvironmentsDeletePrivateEndpointConnectionResponse>>;
    beginDeletePrivateEndpointConnectionAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: AppServiceEnvironmentsDeletePrivateEndpointConnectionOptionalParams): Promise<AppServiceEnvironmentsDeletePrivateEndpointConnectionResponse>;
    beginListChangeVnetAndWait(resourceGroupName: string, name: string, vnetInfo: VirtualNetworkProfile, options?: AppServiceEnvironmentsChangeVnetOptionalParams): PagedAsyncIterableIterator<Site>;
    beginListResumeAndWait(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsResumeOptionalParams): PagedAsyncIterableIterator<Site>;
    beginListSuspendAndWait(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsSuspendOptionalParams): PagedAsyncIterableIterator<Site>;
    beginUpgrade(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsUpgradeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginUpgradeAndWait(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsUpgradeOptionalParams): Promise<void>;
    deleteAseCustomDnsSuffixConfiguration(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsDeleteAseCustomDnsSuffixConfigurationOptionalParams): Promise<AppServiceEnvironmentsDeleteAseCustomDnsSuffixConfigurationResponse>;
    get(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetOptionalParams): Promise<AppServiceEnvironmentsGetResponse>;
    getAseCustomDnsSuffixConfiguration(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetAseCustomDnsSuffixConfigurationOptionalParams): Promise<AppServiceEnvironmentsGetAseCustomDnsSuffixConfigurationResponse>;
    getAseV3NetworkingConfiguration(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetAseV3NetworkingConfigurationOptionalParams): Promise<AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse>;
    getDiagnosticsItem(resourceGroupName: string, name: string, diagnosticsName: string, options?: AppServiceEnvironmentsGetDiagnosticsItemOptionalParams): Promise<AppServiceEnvironmentsGetDiagnosticsItemResponse>;
    getMultiRolePool(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetMultiRolePoolOptionalParams): Promise<AppServiceEnvironmentsGetMultiRolePoolResponse>;
    getPrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: AppServiceEnvironmentsGetPrivateEndpointConnectionOptionalParams): Promise<AppServiceEnvironmentsGetPrivateEndpointConnectionResponse>;
    getPrivateLinkResources(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetPrivateLinkResourcesOptionalParams): Promise<AppServiceEnvironmentsGetPrivateLinkResourcesResponse>;
    getVipInfo(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetVipInfoOptionalParams): Promise<AppServiceEnvironmentsGetVipInfoResponse>;
    getWorkerPool(resourceGroupName: string, name: string, workerPoolName: string, options?: AppServiceEnvironmentsGetWorkerPoolOptionalParams): Promise<AppServiceEnvironmentsGetWorkerPoolResponse>;
    list(options?: AppServiceEnvironmentsListOptionalParams): PagedAsyncIterableIterator<AppServiceEnvironmentResource>;
    listAppServicePlans(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListAppServicePlansOptionalParams): PagedAsyncIterableIterator<AppServicePlan>;
    listByResourceGroup(resourceGroupName: string, options?: AppServiceEnvironmentsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AppServiceEnvironmentResource>;
    listCapacities(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListCapacitiesOptionalParams): PagedAsyncIterableIterator<StampCapacity>;
    listDiagnostics(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListDiagnosticsOptionalParams): Promise<AppServiceEnvironmentsListDiagnosticsResponse>;
    listInboundNetworkDependenciesEndpoints(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsOptionalParams): PagedAsyncIterableIterator<InboundEnvironmentEndpoint>;
    listMultiRoleMetricDefinitions(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListMultiRoleMetricDefinitionsOptionalParams): PagedAsyncIterableIterator<ResourceMetricDefinition>;
    listMultiRolePoolInstanceMetricDefinitions(resourceGroupName: string, name: string, instance: string, options?: AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsOptionalParams): PagedAsyncIterableIterator<ResourceMetricDefinition>;
    listMultiRolePools(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListMultiRolePoolsOptionalParams): PagedAsyncIterableIterator<WorkerPoolResource>;
    listMultiRolePoolSkus(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListMultiRolePoolSkusOptionalParams): PagedAsyncIterableIterator<SkuInfo>;
    listMultiRoleUsages(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListMultiRoleUsagesOptionalParams): PagedAsyncIterableIterator<Usage>;
    listOperations(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListOperationsOptionalParams): Promise<AppServiceEnvironmentsListOperationsResponse>;
    listOutboundNetworkDependenciesEndpoints(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsOptionalParams): PagedAsyncIterableIterator<OutboundEnvironmentEndpoint>;
    listPrivateEndpointConnectionList(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsGetPrivateEndpointConnectionListOptionalParams): PagedAsyncIterableIterator<RemotePrivateEndpointConnectionARMResource>;
    listUsages(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListUsagesOptionalParams): PagedAsyncIterableIterator<CsmUsageQuota>;
    listWebApps(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListWebAppsOptionalParams): PagedAsyncIterableIterator<Site>;
    listWebWorkerMetricDefinitions(resourceGroupName: string, name: string, workerPoolName: string, options?: AppServiceEnvironmentsListWebWorkerMetricDefinitionsOptionalParams): PagedAsyncIterableIterator<ResourceMetricDefinition>;
    listWebWorkerUsages(resourceGroupName: string, name: string, workerPoolName: string, options?: AppServiceEnvironmentsListWebWorkerUsagesOptionalParams): PagedAsyncIterableIterator<Usage>;
    listWorkerPoolInstanceMetricDefinitions(resourceGroupName: string, name: string, workerPoolName: string, instance: string, options?: AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsOptionalParams): PagedAsyncIterableIterator<ResourceMetricDefinition>;
    listWorkerPools(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsListWorkerPoolsOptionalParams): PagedAsyncIterableIterator<WorkerPoolResource>;
    listWorkerPoolSkus(resourceGroupName: string, name: string, workerPoolName: string, options?: AppServiceEnvironmentsListWorkerPoolSkusOptionalParams): PagedAsyncIterableIterator<SkuInfo>;
    reboot(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsRebootOptionalParams): Promise<void>;
    testUpgradeAvailableNotification(resourceGroupName: string, name: string, options?: AppServiceEnvironmentsTestUpgradeAvailableNotificationOptionalParams): Promise<void>;
    update(resourceGroupName: string, name: string, hostingEnvironmentEnvelope: AppServiceEnvironmentPatchResource, options?: AppServiceEnvironmentsUpdateOptionalParams): Promise<AppServiceEnvironmentsUpdateResponse>;
    updateAseCustomDnsSuffixConfiguration(resourceGroupName: string, name: string, customDnsSuffixConfiguration: CustomDnsSuffixConfiguration, options?: AppServiceEnvironmentsUpdateAseCustomDnsSuffixConfigurationOptionalParams): Promise<AppServiceEnvironmentsUpdateAseCustomDnsSuffixConfigurationResponse>;
    updateAseNetworkingConfiguration(resourceGroupName: string, name: string, aseNetworkingConfiguration: AseV3NetworkingConfiguration, options?: AppServiceEnvironmentsUpdateAseNetworkingConfigurationOptionalParams): Promise<AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse>;
    updateMultiRolePool(resourceGroupName: string, name: string, multiRolePoolEnvelope: WorkerPoolResource, options?: AppServiceEnvironmentsUpdateMultiRolePoolOptionalParams): Promise<AppServiceEnvironmentsUpdateMultiRolePoolResponse>;
    updateWorkerPool(resourceGroupName: string, name: string, workerPoolName: string, workerPoolEnvelope: WorkerPoolResource, options?: AppServiceEnvironmentsUpdateWorkerPoolOptionalParams): Promise<AppServiceEnvironmentsUpdateWorkerPoolResponse>;
}

// @public
export interface AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface AppServiceEnvironmentsChangeVnetNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsChangeVnetNextResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsChangeVnetOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsChangeVnetResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsCreateOrUpdateHeaders {
    location?: string;
}

// @public
export interface AppServiceEnvironmentsCreateOrUpdateMultiRolePoolOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsCreateOrUpdateMultiRolePoolResponse = WorkerPoolResource;

// @public
export interface AppServiceEnvironmentsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsCreateOrUpdateResponse = AppServiceEnvironmentResource;

// @public
export interface AppServiceEnvironmentsCreateOrUpdateWorkerPoolOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsCreateOrUpdateWorkerPoolResponse = WorkerPoolResource;

// @public
export interface AppServiceEnvironmentsDeleteAseCustomDnsSuffixConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsDeleteAseCustomDnsSuffixConfigurationResponse = Record<string, unknown>;

// @public
export interface AppServiceEnvironmentsDeleteOptionalParams extends coreClient.OperationOptions {
    forceDelete?: boolean;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface AppServiceEnvironmentsDeletePrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsDeletePrivateEndpointConnectionResponse = Record<string, unknown>;

// @public
export interface AppServiceEnvironmentsGetAseCustomDnsSuffixConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetAseCustomDnsSuffixConfigurationResponse = CustomDnsSuffixConfiguration;

// @public
export interface AppServiceEnvironmentsGetAseV3NetworkingConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse = AseV3NetworkingConfiguration;

// @public
export interface AppServiceEnvironmentsGetDiagnosticsItemOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetDiagnosticsItemResponse = HostingEnvironmentDiagnostics;

// @public
export interface AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsNextResponse = InboundEnvironmentEndpointCollection;

// @public
export interface AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsResponse = InboundEnvironmentEndpointCollection;

// @public
export interface AppServiceEnvironmentsGetMultiRolePoolOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetMultiRolePoolResponse = WorkerPoolResource;

// @public
export interface AppServiceEnvironmentsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsNextResponse = OutboundEnvironmentEndpointCollection;

// @public
export interface AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsResponse = OutboundEnvironmentEndpointCollection;

// @public
export interface AppServiceEnvironmentsGetPrivateEndpointConnectionListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetPrivateEndpointConnectionListNextResponse = PrivateEndpointConnectionCollection;

// @public
export interface AppServiceEnvironmentsGetPrivateEndpointConnectionListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetPrivateEndpointConnectionListResponse = PrivateEndpointConnectionCollection;

// @public
export interface AppServiceEnvironmentsGetPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetPrivateEndpointConnectionResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface AppServiceEnvironmentsGetPrivateLinkResourcesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetPrivateLinkResourcesResponse = PrivateLinkResourcesWrapper;

// @public
export type AppServiceEnvironmentsGetResponse = AppServiceEnvironmentResource;

// @public
export interface AppServiceEnvironmentsGetVipInfoOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetVipInfoResponse = AddressResponse;

// @public
export interface AppServiceEnvironmentsGetWorkerPoolOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsGetWorkerPoolResponse = WorkerPoolResource;

// @public
export interface AppServiceEnvironmentsListAppServicePlansNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListAppServicePlansNextResponse = AppServicePlanCollection;

// @public
export interface AppServiceEnvironmentsListAppServicePlansOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListAppServicePlansResponse = AppServicePlanCollection;

// @public
export interface AppServiceEnvironmentsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListByResourceGroupNextResponse = AppServiceEnvironmentCollection;

// @public
export interface AppServiceEnvironmentsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListByResourceGroupResponse = AppServiceEnvironmentCollection;

// @public
export interface AppServiceEnvironmentsListCapacitiesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListCapacitiesNextResponse = StampCapacityCollection;

// @public
export interface AppServiceEnvironmentsListCapacitiesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListCapacitiesResponse = StampCapacityCollection;

// @public
export interface AppServiceEnvironmentsListDiagnosticsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListDiagnosticsResponse = HostingEnvironmentDiagnostics[];

// @public
export interface AppServiceEnvironmentsListMultiRoleMetricDefinitionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRoleMetricDefinitionsNextResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListMultiRoleMetricDefinitionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRoleMetricDefinitionsResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsNextResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListMultiRolePoolSkusNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRolePoolSkusNextResponse = SkuInfoCollection;

// @public
export interface AppServiceEnvironmentsListMultiRolePoolSkusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRolePoolSkusResponse = SkuInfoCollection;

// @public
export interface AppServiceEnvironmentsListMultiRolePoolsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRolePoolsNextResponse = WorkerPoolCollection;

// @public
export interface AppServiceEnvironmentsListMultiRolePoolsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRolePoolsResponse = WorkerPoolCollection;

// @public
export interface AppServiceEnvironmentsListMultiRoleUsagesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRoleUsagesNextResponse = UsageCollection;

// @public
export interface AppServiceEnvironmentsListMultiRoleUsagesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListMultiRoleUsagesResponse = UsageCollection;

// @public
export interface AppServiceEnvironmentsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListNextResponse = AppServiceEnvironmentCollection;

// @public
export interface AppServiceEnvironmentsListOperationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListOperationsResponse = Operation[];

// @public
export interface AppServiceEnvironmentsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListResponse = AppServiceEnvironmentCollection;

// @public
export interface AppServiceEnvironmentsListUsagesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListUsagesNextResponse = CsmUsageQuotaCollection;

// @public
export interface AppServiceEnvironmentsListUsagesOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type AppServiceEnvironmentsListUsagesResponse = CsmUsageQuotaCollection;

// @public
export interface AppServiceEnvironmentsListWebAppsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWebAppsNextResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsListWebAppsOptionalParams extends coreClient.OperationOptions {
    propertiesToInclude?: string;
}

// @public
export type AppServiceEnvironmentsListWebAppsResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsListWebWorkerMetricDefinitionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWebWorkerMetricDefinitionsNextResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListWebWorkerMetricDefinitionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWebWorkerMetricDefinitionsResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListWebWorkerUsagesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWebWorkerUsagesNextResponse = UsageCollection;

// @public
export interface AppServiceEnvironmentsListWebWorkerUsagesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWebWorkerUsagesResponse = UsageCollection;

// @public
export interface AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsNextResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsResponse = ResourceMetricDefinitionCollection;

// @public
export interface AppServiceEnvironmentsListWorkerPoolSkusNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWorkerPoolSkusNextResponse = SkuInfoCollection;

// @public
export interface AppServiceEnvironmentsListWorkerPoolSkusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWorkerPoolSkusResponse = SkuInfoCollection;

// @public
export interface AppServiceEnvironmentsListWorkerPoolsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWorkerPoolsNextResponse = WorkerPoolCollection;

// @public
export interface AppServiceEnvironmentsListWorkerPoolsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsListWorkerPoolsResponse = WorkerPoolCollection;

// @public
export interface AppServiceEnvironmentsRebootOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceEnvironmentsResumeNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsResumeNextResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsResumeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsResumeResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsSuspendNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsSuspendNextResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsSuspendOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServiceEnvironmentsSuspendResponse = WebAppCollection;

// @public
export interface AppServiceEnvironmentsTestUpgradeAvailableNotificationOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServiceEnvironmentsUpdateAseCustomDnsSuffixConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsUpdateAseCustomDnsSuffixConfigurationResponse = CustomDnsSuffixConfiguration;

// @public
export interface AppServiceEnvironmentsUpdateAseNetworkingConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse = AseV3NetworkingConfiguration;

// @public
export interface AppServiceEnvironmentsUpdateMultiRolePoolOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsUpdateMultiRolePoolResponse = WorkerPoolResource;

// @public
export interface AppServiceEnvironmentsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsUpdateResponse = AppServiceEnvironmentResource;

// @public
export interface AppServiceEnvironmentsUpdateWorkerPoolOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServiceEnvironmentsUpdateWorkerPoolResponse = WorkerPoolResource;

// @public
export interface AppServiceEnvironmentsUpgradeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface AppserviceGithubToken {
    accessToken?: string;
    errorMessage?: string;
    gotToken?: boolean;
    scope?: string;
    tokenType?: string;
}

// @public
export interface AppserviceGithubTokenRequest {
    code: string;
    state: string;
}

// @public
export interface AppServicePlan extends Resource {
    elasticScaleEnabled?: boolean;
    extendedLocation?: ExtendedLocation;
    freeOfferExpirationTime?: Date;
    readonly geoRegion?: string;
    hostingEnvironmentProfile?: HostingEnvironmentProfile;
    hyperV?: boolean;
    isSpot?: boolean;
    isXenon?: boolean;
    kubeEnvironmentProfile?: KubeEnvironmentProfile;
    maximumElasticWorkerCount?: number;
    readonly maximumNumberOfWorkers?: number;
    readonly numberOfSites?: number;
    readonly numberOfWorkers?: number;
    perSiteScaling?: boolean;
    readonly provisioningState?: ProvisioningState;
    reserved?: boolean;
    readonly resourceGroup?: string;
    sku?: SkuDescription;
    spotExpirationTime?: Date;
    readonly status?: StatusOptions;
    readonly subscription?: string;
    targetWorkerCount?: number;
    targetWorkerSizeId?: number;
    workerTierName?: string;
    zoneRedundant?: boolean;
}

// @public
export interface AppServicePlanCollection {
    readonly nextLink?: string;
    value: AppServicePlan[];
}

// @public
export interface AppServicePlanPatchResource extends ProxyOnlyResource {
    elasticScaleEnabled?: boolean;
    freeOfferExpirationTime?: Date;
    readonly geoRegion?: string;
    hostingEnvironmentProfile?: HostingEnvironmentProfile;
    hyperV?: boolean;
    isSpot?: boolean;
    isXenon?: boolean;
    kubeEnvironmentProfile?: KubeEnvironmentProfile;
    maximumElasticWorkerCount?: number;
    readonly maximumNumberOfWorkers?: number;
    readonly numberOfSites?: number;
    readonly numberOfWorkers?: number;
    perSiteScaling?: boolean;
    readonly provisioningState?: ProvisioningState;
    reserved?: boolean;
    readonly resourceGroup?: string;
    spotExpirationTime?: Date;
    readonly status?: StatusOptions;
    readonly subscription?: string;
    targetWorkerCount?: number;
    targetWorkerSizeId?: number;
    workerTierName?: string;
    zoneRedundant?: boolean;
}

// @public
export type AppServicePlanRestrictions = "None" | "Free" | "Shared" | "Basic" | "Standard" | "Premium";

// @public
export interface AppServicePlans {
    beginCreateOrUpdate(resourceGroupName: string, name: string, appServicePlan: AppServicePlan, options?: AppServicePlansCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AppServicePlansCreateOrUpdateResponse>, AppServicePlansCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, name: string, appServicePlan: AppServicePlan, options?: AppServicePlansCreateOrUpdateOptionalParams): Promise<AppServicePlansCreateOrUpdateResponse>;
    createOrUpdateVnetRoute(resourceGroupName: string, name: string, vnetName: string, routeName: string, route: VnetRoute, options?: AppServicePlansCreateOrUpdateVnetRouteOptionalParams): Promise<AppServicePlansCreateOrUpdateVnetRouteResponse>;
    delete(resourceGroupName: string, name: string, options?: AppServicePlansDeleteOptionalParams): Promise<void>;
    deleteHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, options?: AppServicePlansDeleteHybridConnectionOptionalParams): Promise<void>;
    deleteVnetRoute(resourceGroupName: string, name: string, vnetName: string, routeName: string, options?: AppServicePlansDeleteVnetRouteOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, options?: AppServicePlansGetOptionalParams): Promise<AppServicePlansGetResponse>;
    getHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, options?: AppServicePlansGetHybridConnectionOptionalParams): Promise<AppServicePlansGetHybridConnectionResponse>;
    getHybridConnectionPlanLimit(resourceGroupName: string, name: string, options?: AppServicePlansGetHybridConnectionPlanLimitOptionalParams): Promise<AppServicePlansGetHybridConnectionPlanLimitResponse>;
    getRouteForVnet(resourceGroupName: string, name: string, vnetName: string, routeName: string, options?: AppServicePlansGetRouteForVnetOptionalParams): Promise<AppServicePlansGetRouteForVnetResponse>;
    getServerFarmSkus(resourceGroupName: string, name: string, options?: AppServicePlansGetServerFarmSkusOptionalParams): Promise<AppServicePlansGetServerFarmSkusResponse>;
    getVnetFromServerFarm(resourceGroupName: string, name: string, vnetName: string, options?: AppServicePlansGetVnetFromServerFarmOptionalParams): Promise<AppServicePlansGetVnetFromServerFarmResponse>;
    getVnetGateway(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, options?: AppServicePlansGetVnetGatewayOptionalParams): Promise<AppServicePlansGetVnetGatewayResponse>;
    list(options?: AppServicePlansListOptionalParams): PagedAsyncIterableIterator<AppServicePlan>;
    listByResourceGroup(resourceGroupName: string, options?: AppServicePlansListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AppServicePlan>;
    listCapabilities(resourceGroupName: string, name: string, options?: AppServicePlansListCapabilitiesOptionalParams): Promise<AppServicePlansListCapabilitiesResponse>;
    listHybridConnectionKeys(resourceGroupName: string, name: string, namespaceName: string, relayName: string, options?: AppServicePlansListHybridConnectionKeysOptionalParams): Promise<AppServicePlansListHybridConnectionKeysResponse>;
    listHybridConnections(resourceGroupName: string, name: string, options?: AppServicePlansListHybridConnectionsOptionalParams): PagedAsyncIterableIterator<HybridConnection>;
    listRoutesForVnet(resourceGroupName: string, name: string, vnetName: string, options?: AppServicePlansListRoutesForVnetOptionalParams): Promise<AppServicePlansListRoutesForVnetResponse>;
    listUsages(resourceGroupName: string, name: string, options?: AppServicePlansListUsagesOptionalParams): PagedAsyncIterableIterator<CsmUsageQuota>;
    listVnets(resourceGroupName: string, name: string, options?: AppServicePlansListVnetsOptionalParams): Promise<AppServicePlansListVnetsResponse>;
    listWebApps(resourceGroupName: string, name: string, options?: AppServicePlansListWebAppsOptionalParams): PagedAsyncIterableIterator<Site>;
    listWebAppsByHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, options?: AppServicePlansListWebAppsByHybridConnectionOptionalParams): PagedAsyncIterableIterator<string>;
    rebootWorker(resourceGroupName: string, name: string, workerName: string, options?: AppServicePlansRebootWorkerOptionalParams): Promise<void>;
    restartWebApps(resourceGroupName: string, name: string, options?: AppServicePlansRestartWebAppsOptionalParams): Promise<void>;
    update(resourceGroupName: string, name: string, appServicePlan: AppServicePlanPatchResource, options?: AppServicePlansUpdateOptionalParams): Promise<AppServicePlansUpdateResponse>;
    updateVnetGateway(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, connectionEnvelope: VnetGateway, options?: AppServicePlansUpdateVnetGatewayOptionalParams): Promise<AppServicePlansUpdateVnetGatewayResponse>;
    updateVnetRoute(resourceGroupName: string, name: string, vnetName: string, routeName: string, route: VnetRoute, options?: AppServicePlansUpdateVnetRouteOptionalParams): Promise<AppServicePlansUpdateVnetRouteResponse>;
}

// @public
export interface AppServicePlansCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AppServicePlansCreateOrUpdateResponse = AppServicePlan;

// @public
export interface AppServicePlansCreateOrUpdateVnetRouteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansCreateOrUpdateVnetRouteResponse = VnetRoute;

// @public
export interface AppServicePlansDeleteHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServicePlansDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServicePlansDeleteVnetRouteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServicePlansGetHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServicePlansGetHybridConnectionPlanLimitOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansGetHybridConnectionPlanLimitResponse = HybridConnectionLimits;

// @public
export type AppServicePlansGetHybridConnectionResponse = HybridConnection;

// @public
export interface AppServicePlansGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansGetResponse = AppServicePlan;

// @public
export interface AppServicePlansGetRouteForVnetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansGetRouteForVnetResponse = VnetRoute[];

// @public
export interface AppServicePlansGetServerFarmSkusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansGetServerFarmSkusResponse = Record<string, unknown>;

// @public
export interface AppServicePlansGetVnetFromServerFarmOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansGetVnetFromServerFarmResponse = VnetInfoResource;

// @public
export interface AppServicePlansGetVnetGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansGetVnetGatewayResponse = VnetGateway;

// @public
export interface AppServicePlansListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListByResourceGroupNextResponse = AppServicePlanCollection;

// @public
export interface AppServicePlansListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListByResourceGroupResponse = AppServicePlanCollection;

// @public
export interface AppServicePlansListCapabilitiesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListCapabilitiesResponse = Capability[];

// @public
export interface AppServicePlansListHybridConnectionKeysOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListHybridConnectionKeysResponse = HybridConnectionKey;

// @public
export interface AppServicePlansListHybridConnectionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListHybridConnectionsNextResponse = HybridConnectionCollection;

// @public
export interface AppServicePlansListHybridConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListHybridConnectionsResponse = HybridConnectionCollection;

// @public
export interface AppServicePlansListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListNextResponse = AppServicePlanCollection;

// @public
export interface AppServicePlansListOptionalParams extends coreClient.OperationOptions {
    detailed?: boolean;
}

// @public
export type AppServicePlansListResponse = AppServicePlanCollection;

// @public
export interface AppServicePlansListRoutesForVnetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListRoutesForVnetResponse = VnetRoute[];

// @public
export interface AppServicePlansListUsagesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListUsagesNextResponse = CsmUsageQuotaCollection;

// @public
export interface AppServicePlansListUsagesOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type AppServicePlansListUsagesResponse = CsmUsageQuotaCollection;

// @public
export interface AppServicePlansListVnetsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListVnetsResponse = VnetInfoResource[];

// @public
export interface AppServicePlansListWebAppsByHybridConnectionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListWebAppsByHybridConnectionNextResponse = ResourceCollection;

// @public
export interface AppServicePlansListWebAppsByHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListWebAppsByHybridConnectionResponse = ResourceCollection;

// @public
export interface AppServicePlansListWebAppsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansListWebAppsNextResponse = WebAppCollection;

// @public
export interface AppServicePlansListWebAppsOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skipToken?: string;
    top?: string;
}

// @public
export type AppServicePlansListWebAppsResponse = WebAppCollection;

// @public
export interface AppServicePlansRebootWorkerOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AppServicePlansRestartWebAppsOptionalParams extends coreClient.OperationOptions {
    softRestart?: boolean;
}

// @public
export interface AppServicePlansUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansUpdateResponse = AppServicePlan;

// @public
export interface AppServicePlansUpdateVnetGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansUpdateVnetGatewayResponse = VnetGateway;

// @public
export interface AppServicePlansUpdateVnetRouteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AppServicePlansUpdateVnetRouteResponse = VnetRoute;

// @public (undocumented)
export interface ArcConfiguration {
    // (undocumented)
    artifactsStorageType?: StorageType;
    // (undocumented)
    artifactStorageAccessMode?: string;
    // (undocumented)
    artifactStorageClassName?: string;
    // (undocumented)
    artifactStorageMountPath?: string;
    // (undocumented)
    artifactStorageNodeName?: string;
    // (undocumented)
    frontEndServiceConfiguration?: FrontEndConfiguration;
    // (undocumented)
    kubeConfig?: string;
}

// @public
export interface ArmIdWrapper {
    readonly id?: string;
}

// @public
export interface ArmPlan {
    name?: string;
    product?: string;
    promotionCode?: string;
    publisher?: string;
    version?: string;
}

// @public
export interface AseRegion extends ProxyOnlyResource {
    availableOS?: string[];
    availableSku?: string[];
    readonly dedicatedHost?: boolean;
    readonly displayName?: string;
    readonly standard?: boolean;
    readonly zoneRedundant?: boolean;
}

// @public
export interface AseRegionCollection {
    readonly nextLink?: string;
    value: AseRegion[];
}

// @public
export interface AseV3NetworkingConfiguration extends ProxyOnlyResource {
    allowNewPrivateEndpointConnections?: boolean;
    readonly externalInboundIpAddresses?: string[];
    ftpEnabled?: boolean;
    inboundIpAddressOverride?: string;
    readonly internalInboundIpAddresses?: string[];
    readonly linuxOutboundIpAddresses?: string[];
    remoteDebugEnabled?: boolean;
    readonly windowsOutboundIpAddresses?: string[];
}

// @public
export type AuthenticationType = string;

// @public
export interface AuthPlatform {
    configFilePath?: string;
    enabled?: boolean;
    runtimeVersion?: string;
}

// @public
export type AuthType = "Anonymous" | "UserCredentials" | "SystemIdentity" | "UserAssigned";

// @public
export interface AutoHealActions {
    actionType?: AutoHealActionType;
    customAction?: AutoHealCustomAction;
    minProcessExecutionTime?: string;
}

// @public
export type AutoHealActionType = "Recycle" | "LogEvent" | "CustomAction";

// @public
export interface AutoHealCustomAction {
    exe?: string;
    parameters?: string;
}

// @public
export interface AutoHealRules {
    actions?: AutoHealActions;
    triggers?: AutoHealTriggers;
}

// @public
export interface AutoHealTriggers {
    privateBytesInKB?: number;
    requests?: RequestsBasedTrigger;
    slowRequests?: SlowRequestsBasedTrigger;
    slowRequestsWithPath?: SlowRequestsBasedTrigger[];
    statusCodes?: StatusCodesBasedTrigger[];
    statusCodesRange?: StatusCodesRangeBasedTrigger[];
}

// @public
export interface AzureActiveDirectory {
    enabled?: boolean;
    isAutoProvisioned?: boolean;
    login?: AzureActiveDirectoryLogin;
    registration?: AzureActiveDirectoryRegistration;
    validation?: AzureActiveDirectoryValidation;
}

// @public
export interface AzureActiveDirectoryLogin {
    disableWWWAuthenticate?: boolean;
    loginParameters?: string[];
}

// @public
export interface AzureActiveDirectoryRegistration {
    clientId?: string;
    clientSecretCertificateIssuer?: string;
    clientSecretCertificateSubjectAlternativeName?: string;
    clientSecretCertificateThumbprint?: string;
    clientSecretSettingName?: string;
    openIdIssuer?: string;
}

// @public
export interface AzureActiveDirectoryValidation {
    allowedAudiences?: string[];
    defaultAuthorizationPolicy?: DefaultAuthorizationPolicy;
    jwtClaimChecks?: JwtClaimChecks;
}

// @public
export interface AzureBlobStorageApplicationLogsConfig {
    level?: LogLevel;
    retentionInDays?: number;
    sasUrl?: string;
}

// @public
export interface AzureBlobStorageHttpLogsConfig {
    enabled?: boolean;
    retentionInDays?: number;
    sasUrl?: string;
}

// @public
export interface AzureResourceErrorInfo extends ErrorInfo {
    details?: AzureResourceErrorInfo[];
    message: string;
}

// @public
export type AzureResourceType = "Website" | "TrafficManager";

// @public
export interface AzureStaticWebApps {
    enabled?: boolean;
    registration?: AzureStaticWebAppsRegistration;
}

// @public
export interface AzureStaticWebAppsRegistration {
    clientId?: string;
}

// @public
export interface AzureStorageInfoValue {
    accessKey?: string;
    accountName?: string;
    mountPath?: string;
    protocol?: AzureStorageProtocol;
    shareName?: string;
    readonly state?: AzureStorageState;
    type?: AzureStorageType;
}

// @public
export interface AzureStoragePropertyDictionaryResource extends ProxyOnlyResource {
    properties?: {
        [propertyName: string]: AzureStorageInfoValue;
    };
}

// @public
export type AzureStorageProtocol = string;

// @public
export type AzureStorageState = "Ok" | "InvalidCredentials" | "InvalidShare" | "NotValidated";

// @public
export type AzureStorageType = "AzureFiles" | "AzureBlob";

// @public
export interface AzureTableStorageApplicationLogsConfig {
    level?: LogLevel;
    sasUrl: string;
}

// @public
export interface BackupItem extends ProxyOnlyResource {
    readonly backupId?: number;
    readonly blobName?: string;
    readonly correlationId?: string;
    readonly created?: Date;
    readonly databases?: DatabaseBackupSetting[];
    readonly finishedTimeStamp?: Date;
    readonly lastRestoreTimeStamp?: Date;
    readonly log?: string;
    readonly namePropertiesName?: string;
    readonly scheduled?: boolean;
    readonly sizeInBytes?: number;
    readonly status?: BackupItemStatus;
    readonly storageAccountUrl?: string;
    readonly websiteSizeInBytes?: number;
}

// @public
export interface BackupItemCollection {
    readonly nextLink?: string;
    value: BackupItem[];
}

// @public
export type BackupItemStatus = "InProgress" | "Failed" | "Succeeded" | "TimedOut" | "Created" | "Skipped" | "PartiallySucceeded" | "DeleteInProgress" | "DeleteFailed" | "Deleted";

// @public
export interface BackupRequest extends ProxyOnlyResource {
    backupName?: string;
    backupSchedule?: BackupSchedule;
    databases?: DatabaseBackupSetting[];
    enabled?: boolean;
    storageAccountUrl?: string;
}

// @public
export type BackupRestoreOperationType = "Default" | "Clone" | "Relocation" | "Snapshot" | "CloudFS";

// @public
export interface BackupSchedule {
    frequencyInterval: number;
    frequencyUnit: FrequencyUnit;
    keepAtLeastOneBackup: boolean;
    readonly lastExecutionTime?: Date;
    retentionPeriodInDays: number;
    startTime?: Date;
}

// @public
export type BasicAuthName = string;

// @public
export interface BillingMeter extends ProxyOnlyResource {
    billingLocation?: string;
    friendlyName?: string;
    meterId?: string;
    multiplier?: number;
    osType?: string;
    resourceType?: string;
    shortName?: string;
}

// @public
export interface BillingMeterCollection {
    readonly nextLink?: string;
    value: BillingMeter[];
}

// @public
export interface BlobStorageTokenStore {
    sasUrlSettingName?: string;
}

// @public
export type BuildStatus = string;

// @public
export type BuiltInAuthenticationProvider = "AzureActiveDirectory" | "Facebook" | "Google" | "MicrosoftAccount" | "Twitter" | "Github";

// @public
export interface Capability {
    name?: string;
    reason?: string;
    value?: string;
}

// @public
export interface Certificate extends Resource {
    canonicalName?: string;
    readonly cerBlob?: Uint8Array;
    domainValidationMethod?: string;
    readonly expirationDate?: Date;
    readonly friendlyName?: string;
    readonly hostingEnvironmentProfile?: HostingEnvironmentProfile;
    hostNames?: string[];
    readonly issueDate?: Date;
    readonly issuer?: string;
    keyVaultId?: string;
    keyVaultSecretName?: string;
    readonly keyVaultSecretStatus?: KeyVaultSecretStatus;
    password?: string;
    pfxBlob?: Uint8Array;
    readonly publicKeyHash?: string;
    readonly selfLink?: string;
    serverFarmId?: string;
    readonly siteName?: string;
    readonly subjectName?: string;
    readonly thumbprint?: string;
    readonly valid?: boolean;
}

// @public
export interface CertificateCollection {
    readonly nextLink?: string;
    value: Certificate[];
}

// @public
export interface CertificateDetails {
    readonly issuer?: string;
    readonly notAfter?: Date;
    readonly notBefore?: Date;
    readonly rawData?: string;
    readonly serialNumber?: string;
    readonly signatureAlgorithm?: string;
    readonly subject?: string;
    readonly thumbprint?: string;
    readonly version?: number;
}

// @public
export interface CertificateEmail {
    emailId?: string;
    timeStamp?: Date;
}

// @public
export interface CertificateOrderAction {
    readonly actionType?: CertificateOrderActionType;
    readonly createdAt?: Date;
}

// @public
export type CertificateOrderActionType = "CertificateIssued" | "CertificateOrderCanceled" | "CertificateOrderCreated" | "CertificateRevoked" | "DomainValidationComplete" | "FraudDetected" | "OrgNameChange" | "OrgValidationComplete" | "SanDrop" | "FraudCleared" | "CertificateExpired" | "CertificateExpirationWarning" | "FraudDocumentationRequired" | "Unknown";

// @public (undocumented)
export interface CertificateOrderContact {
    // (undocumented)
    email?: string;
    // (undocumented)
    nameFirst?: string;
    // (undocumented)
    nameLast?: string;
    // (undocumented)
    phone?: string;
}

// @public
export interface CertificateOrdersDiagnostics {
    getAppServiceCertificateOrderDetectorResponse(resourceGroupName: string, certificateOrderName: string, detectorName: string, options?: CertificateOrdersDiagnosticsGetAppServiceCertificateOrderDetectorResponseOptionalParams): Promise<CertificateOrdersDiagnosticsGetAppServiceCertificateOrderDetectorResponseResponse>;
    listAppServiceCertificateOrderDetectorResponse(resourceGroupName: string, certificateOrderName: string, options?: CertificateOrdersDiagnosticsListAppServiceCertificateOrderDetectorResponseOptionalParams): PagedAsyncIterableIterator<DetectorResponse>;
}

// @public
export interface CertificateOrdersDiagnosticsGetAppServiceCertificateOrderDetectorResponseOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type CertificateOrdersDiagnosticsGetAppServiceCertificateOrderDetectorResponseResponse = DetectorResponse;

// @public
export interface CertificateOrdersDiagnosticsListAppServiceCertificateOrderDetectorResponseNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificateOrdersDiagnosticsListAppServiceCertificateOrderDetectorResponseNextResponse = DetectorResponseCollection;

// @public
export interface CertificateOrdersDiagnosticsListAppServiceCertificateOrderDetectorResponseOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificateOrdersDiagnosticsListAppServiceCertificateOrderDetectorResponseResponse = DetectorResponseCollection;

// @public
export type CertificateOrderStatus = "Pendingissuance" | "Issued" | "Revoked" | "Canceled" | "Denied" | "Pendingrevocation" | "PendingRekey" | "Unused" | "Expired" | "NotSubmitted";

// @public
export interface CertificatePatchResource extends ProxyOnlyResource {
    canonicalName?: string;
    readonly cerBlob?: Uint8Array;
    domainValidationMethod?: string;
    readonly expirationDate?: Date;
    readonly friendlyName?: string;
    readonly hostingEnvironmentProfile?: HostingEnvironmentProfile;
    hostNames?: string[];
    readonly issueDate?: Date;
    readonly issuer?: string;
    keyVaultId?: string;
    keyVaultSecretName?: string;
    readonly keyVaultSecretStatus?: KeyVaultSecretStatus;
    password?: string;
    pfxBlob?: Uint8Array;
    readonly publicKeyHash?: string;
    readonly selfLink?: string;
    serverFarmId?: string;
    readonly siteName?: string;
    readonly subjectName?: string;
    readonly thumbprint?: string;
    readonly valid?: boolean;
}

// @public
export type CertificateProductType = "StandardDomainValidatedSsl" | "StandardDomainValidatedWildCardSsl";

// @public
export interface CertificateRegistrationProvider {
    listOperations(options?: CertificateRegistrationProviderListOperationsOptionalParams): PagedAsyncIterableIterator<CsmOperationDescription>;
}

// @public
export interface CertificateRegistrationProviderListOperationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificateRegistrationProviderListOperationsNextResponse = CsmOperationCollection;

// @public
export interface CertificateRegistrationProviderListOperationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificateRegistrationProviderListOperationsResponse = CsmOperationCollection;

// @public
export interface Certificates {
    createOrUpdate(resourceGroupName: string, name: string, certificateEnvelope: Certificate, options?: CertificatesCreateOrUpdateOptionalParams): Promise<CertificatesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, name: string, options?: CertificatesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, options?: CertificatesGetOptionalParams): Promise<CertificatesGetResponse>;
    list(options?: CertificatesListOptionalParams): PagedAsyncIterableIterator<Certificate>;
    listByResourceGroup(resourceGroupName: string, options?: CertificatesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<Certificate>;
    update(resourceGroupName: string, name: string, certificateEnvelope: CertificatePatchResource, options?: CertificatesUpdateOptionalParams): Promise<CertificatesUpdateResponse>;
}

// @public
export interface CertificatesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificatesCreateOrUpdateResponse = Certificate;

// @public
export interface CertificatesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface CertificatesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificatesGetResponse = Certificate;

// @public
export interface CertificatesListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificatesListByResourceGroupNextResponse = CertificateCollection;

// @public
export interface CertificatesListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificatesListByResourceGroupResponse = CertificateCollection;

// @public
export interface CertificatesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificatesListNextResponse = CertificateCollection;

// @public
export interface CertificatesListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type CertificatesListResponse = CertificateCollection;

// @public
export interface CertificatesUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CertificatesUpdateResponse = Certificate;

// @public
export type Channels = "Notification" | "Api" | "Email" | "Webhook" | "All";

// @public
export interface CheckNameAvailabilityOptionalParams extends coreClient.OperationOptions {
    environmentId?: string;
    isFqdn?: boolean;
}

// @public
export type CheckNameAvailabilityResponse = ResourceNameAvailability;

// @public
export type CheckNameResourceTypes = string;

// @public
export type ClientCertMode = "Required" | "Optional" | "OptionalInteractiveUser";

// @public
export interface ClientRegistration {
    clientId?: string;
    clientSecretSettingName?: string;
}

// @public
export type CloneAbilityResult = "Cloneable" | "PartiallyCloneable" | "NotCloneable";

// @public
export interface CloningInfo {
    appSettingsOverrides?: {
        [propertyName: string]: string;
    };
    cloneCustomHostNames?: boolean;
    cloneSourceControl?: boolean;
    configureLoadBalancing?: boolean;
    correlationId?: string;
    hostingEnvironment?: string;
    overwrite?: boolean;
    sourceWebAppId: string;
    sourceWebAppLocation?: string;
    trafficManagerProfileId?: string;
    trafficManagerProfileName?: string;
}

// @public
export type ComputeModeOptions = "Shared" | "Dedicated" | "Dynamic";

// @public
export interface Configuration {
    activeRevisionsMode?: ActiveRevisionsMode;
    ingress?: Ingress;
    registries?: RegistryCredentials[];
    secrets?: Secret[];
}

// @public
export interface ConnectionStringDictionary extends ProxyOnlyResource {
    properties?: {
        [propertyName: string]: ConnStringValueTypePair;
    };
}

// @public
export type ConnectionStringType = "MySql" | "SQLServer" | "SQLAzure" | "Custom" | "NotificationHub" | "ServiceBus" | "EventHub" | "ApiHub" | "DocDb" | "RedisCache" | "PostgreSQL";

// @public
export interface ConnStringInfo {
    connectionString?: string;
    name?: string;
    type?: ConnectionStringType;
}

// @public
export interface ConnStringValueTypePair {
    type: ConnectionStringType;
    value: string;
}

// @public
export interface Contact {
    addressMailing?: Address;
    email: string;
    fax?: string;
    jobTitle?: string;
    nameFirst: string;
    nameLast: string;
    nameMiddle?: string;
    organization?: string;
    phone: string;
}

// @public
export interface Container {
    args?: string[];
    command?: string[];
    env?: EnvironmentVar[];
    image?: string;
    name?: string;
    resources?: ContainerResources;
}

// @public
export interface ContainerApp extends Resource {
    configuration?: Configuration;
    kubeEnvironmentId?: string;
    readonly latestRevisionFqdn?: string;
    readonly latestRevisionName?: string;
    readonly provisioningState?: ContainerAppProvisioningState;
    template?: Template;
}

// @public
export interface ContainerAppCollection {
    readonly nextLink?: string;
    value: ContainerApp[];
}

// @public
export type ContainerAppProvisioningState = string;

// @public
export interface ContainerApps {
    beginCreateOrUpdate(resourceGroupName: string, name: string, containerAppEnvelope: ContainerApp, options?: ContainerAppsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ContainerAppsCreateOrUpdateResponse>, ContainerAppsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, name: string, containerAppEnvelope: ContainerApp, options?: ContainerAppsCreateOrUpdateOptionalParams): Promise<ContainerAppsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, name: string, options?: ContainerAppsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, name: string, options?: ContainerAppsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, options?: ContainerAppsGetOptionalParams): Promise<ContainerAppsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: ContainerAppsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ContainerApp>;
    listBySubscription(options?: ContainerAppsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<ContainerApp>;
    listSecrets(name: string, options?: ContainerAppsListSecretsOptionalParams): Promise<ContainerAppsListSecretsResponse>;
}

// @public (undocumented)
export interface ContainerAppsConfiguration {
    appSubnetResourceId?: string;
    controlPlaneSubnetResourceId?: string;
    daprAIInstrumentationKey?: string;
    dockerBridgeCidr?: string;
    platformReservedCidr?: string;
    platformReservedDnsIP?: string;
}

// @public
export interface ContainerAppsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ContainerAppsCreateOrUpdateResponse = ContainerApp;

// @public
export interface ContainerAppsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ContainerAppSecret {
    readonly name?: string;
    readonly value?: string;
}

// @public
export interface ContainerAppsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsGetResponse = ContainerApp;

// @public
export interface ContainerAppsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsListByResourceGroupNextResponse = ContainerAppCollection;

// @public
export interface ContainerAppsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsListByResourceGroupResponse = ContainerAppCollection;

// @public
export interface ContainerAppsListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsListBySubscriptionNextResponse = ContainerAppCollection;

// @public
export interface ContainerAppsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsListBySubscriptionResponse = ContainerAppCollection;

// @public
export interface ContainerAppsListSecretsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsListSecretsResponse = SecretsCollection;

// @public
export interface ContainerAppsRevisions {
    activateRevision(resourceGroupName: string, containerAppName: string, name: string, options?: ContainerAppsRevisionsActivateRevisionOptionalParams): Promise<void>;
    deactivateRevision(resourceGroupName: string, containerAppName: string, name: string, options?: ContainerAppsRevisionsDeactivateRevisionOptionalParams): Promise<void>;
    getRevision(resourceGroupName: string, containerAppName: string, name: string, options?: ContainerAppsRevisionsGetRevisionOptionalParams): Promise<ContainerAppsRevisionsGetRevisionResponse>;
    listRevisions(resourceGroupName: string, containerAppName: string, options?: ContainerAppsRevisionsListRevisionsOptionalParams): PagedAsyncIterableIterator<Revision>;
    restartRevision(resourceGroupName: string, containerAppName: string, name: string, options?: ContainerAppsRevisionsRestartRevisionOptionalParams): Promise<void>;
}

// @public
export interface ContainerAppsRevisionsActivateRevisionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ContainerAppsRevisionsDeactivateRevisionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ContainerAppsRevisionsGetRevisionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsRevisionsGetRevisionResponse = Revision;

// @public
export interface ContainerAppsRevisionsListRevisionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsRevisionsListRevisionsNextResponse = RevisionCollection;

// @public
export interface ContainerAppsRevisionsListRevisionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ContainerAppsRevisionsListRevisionsResponse = RevisionCollection;

// @public
export interface ContainerAppsRevisionsRestartRevisionOptionalParams extends coreClient.OperationOptions {
}

// @public (undocumented)
export interface ContainerCpuStatistics {
    // (undocumented)
    cpuUsage?: ContainerCpuUsage;
    // (undocumented)
    onlineCpuCount?: number;
    // (undocumented)
    systemCpuUsage?: number;
    // (undocumented)
    throttlingData?: ContainerThrottlingData;
}

// @public (undocumented)
export interface ContainerCpuUsage {
    // (undocumented)
    kernelModeUsage?: number;
    // (undocumented)
    perCpuUsage?: number[];
    // (undocumented)
    totalUsage?: number;
    // (undocumented)
    userModeUsage?: number;
}

// @public (undocumented)
export interface ContainerInfo {
    // (undocumented)
    currentCpuStats?: ContainerCpuStatistics;
    // (undocumented)
    currentTimeStamp?: Date;
    // (undocumented)
    eth0?: ContainerNetworkInterfaceStatistics;
    // (undocumented)
    id?: string;
    // (undocumented)
    memoryStats?: ContainerMemoryStatistics;
    // (undocumented)
    name?: string;
    // (undocumented)
    previousCpuStats?: ContainerCpuStatistics;
    // (undocumented)
    previousTimeStamp?: Date;
}

// @public (undocumented)
export interface ContainerMemoryStatistics {
    // (undocumented)
    limit?: number;
    // (undocumented)
    maxUsage?: number;
    // (undocumented)
    usage?: number;
}

// @public (undocumented)
export interface ContainerNetworkInterfaceStatistics {
    // (undocumented)
    rxBytes?: number;
    // (undocumented)
    rxDropped?: number;
    // (undocumented)
    rxErrors?: number;
    // (undocumented)
    rxPackets?: number;
    // (undocumented)
    txBytes?: number;
    // (undocumented)
    txDropped?: number;
    // (undocumented)
    txErrors?: number;
    // (undocumented)
    txPackets?: number;
}

// @public
export interface ContainerResources {
    cpu?: number;
    memory?: string;
}

// @public (undocumented)
export interface ContainerThrottlingData {
    // (undocumented)
    periods?: number;
    // (undocumented)
    throttledPeriods?: number;
    // (undocumented)
    throttledTime?: number;
}

// @public
export interface ContentHash {
    algorithm?: string;
    value?: string;
}

// @public
export interface ContentLink {
    readonly contentHash?: ContentHash;
    readonly contentSize?: number;
    readonly contentVersion?: string;
    readonly metadata?: Record<string, unknown>;
    uri?: string;
}

// @public
export interface ContinuousWebJob extends ProxyOnlyResource {
    detailedStatus?: string;
    error?: string;
    extraInfoUrl?: string;
    logUrl?: string;
    runCommand?: string;
    settings?: {
        [propertyName: string]: Record<string, unknown>;
    };
    status?: ContinuousWebJobStatus;
    url?: string;
    usingSdk?: boolean;
    webJobType?: WebJobType;
}

// @public
export interface ContinuousWebJobCollection {
    readonly nextLink?: string;
    value: ContinuousWebJob[];
}

// @public
export type ContinuousWebJobStatus = "Initializing" | "Starting" | "Running" | "PendingRestart" | "Stopped";

// @public
export interface CookieExpiration {
    convention?: CookieExpirationConvention;
    timeToExpiration?: string;
}

// @public
export type CookieExpirationConvention = "FixedTime" | "IdentityProviderDerived";

// @public
export interface Correlation {
    clientTrackingId?: string;
}

// @public
export interface CorsSettings {
    allowedOrigins?: string[];
    supportCredentials?: boolean;
}

// @public
export interface CsmDeploymentStatus extends ProxyOnlyResource {
    deploymentId?: string;
    errors?: ErrorEntity[];
    failedInstancesLogs?: string[];
    numberOfInstancesFailed?: number;
    numberOfInstancesInProgress?: number;
    numberOfInstancesSuccessful?: number;
    status?: DeploymentBuildStatus;
}

// @public
export interface CsmDeploymentStatusCollection {
    readonly nextLink?: string;
    value: CsmDeploymentStatus[];
}

// @public
export interface CsmMoveResourceEnvelope {
    // (undocumented)
    resources?: string[];
    // (undocumented)
    targetResourceGroup?: string;
}

// @public
export interface CsmOperationCollection {
    readonly nextLink?: string;
    value: CsmOperationDescription[];
}

// @public
export interface CsmOperationDescription {
    display?: CsmOperationDisplay;
    // (undocumented)
    isDataAction?: boolean;
    // (undocumented)
    name?: string;
    // (undocumented)
    origin?: string;
    properties?: CsmOperationDescriptionProperties;
}

// @public
export interface CsmOperationDescriptionProperties {
    serviceSpecification?: ServiceSpecification;
}

// @public
export interface CsmOperationDisplay {
    // (undocumented)
    description?: string;
    // (undocumented)
    operation?: string;
    // (undocumented)
    provider?: string;
    // (undocumented)
    resource?: string;
}

// @public
export interface CsmPublishingCredentialsPoliciesEntity extends ProxyOnlyResource {
    allow?: boolean;
}

// @public
export interface CsmPublishingProfileOptions {
    format?: PublishingProfileFormat;
    includeDisasterRecoveryEndpoints?: boolean;
}

// @public
export interface CsmSlotEntity {
    preserveVnet: boolean;
    targetSlot: string;
}

// @public
export interface CsmUsageQuota {
    currentValue?: number;
    limit?: number;
    name?: LocalizableString;
    nextResetTime?: Date;
    unit?: string;
}

// @public
export interface CsmUsageQuotaCollection {
    readonly nextLink?: string;
    value: CsmUsageQuota[];
}

// @public
export interface CustomDnsSuffixConfiguration extends ProxyOnlyResource {
    certificateUrl?: string;
    dnsSuffix?: string;
    keyVaultReferenceIdentity?: string;
    readonly provisioningDetails?: string;
    readonly provisioningState?: CustomDnsSuffixProvisioningState;
}

// @public
export type CustomDnsSuffixProvisioningState = "Succeeded" | "Failed" | "Degraded" | "InProgress";

// @public
export type CustomDomainStatus = string;

// @public
export interface CustomHostnameAnalysisResult extends ProxyOnlyResource {
    alternateCNameRecords?: string[];
    alternateTxtRecords?: string[];
    aRecords?: string[];
    cNameRecords?: string[];
    readonly conflictingAppResourceId?: string;
    readonly customDomainVerificationFailureInfo?: ErrorEntity;
    readonly customDomainVerificationTest?: DnsVerificationTestResult;
    readonly hasConflictAcrossSubscription?: boolean;
    readonly hasConflictOnScaleUnit?: boolean;
    readonly isHostnameAlreadyVerified?: boolean;
    txtRecords?: string[];
}

// @public
export type CustomHostNameDnsRecordType = "CName" | "A";

// @public
export interface CustomHostnameSites extends ProxyOnlyResource {
    // (undocumented)
    customHostname?: string;
    // (undocumented)
    region?: string;
    // (undocumented)
    siteResourceIds?: Identifier[];
}

// @public
export interface CustomHostnameSitesCollection {
    readonly nextLink?: string;
    value: CustomHostnameSites[];
}

// @public
export interface CustomOpenIdConnectProvider {
    enabled?: boolean;
    login?: OpenIdConnectLogin;
    registration?: OpenIdConnectRegistration;
}

// @public
export interface CustomScaleRule {
    auth?: ScaleRuleAuth[];
    metadata?: {
        [propertyName: string]: string;
    };
    type?: string;
}

// @public
export interface Dapr {
    appId?: string;
    appPort?: number;
    components?: DaprComponent[];
    enabled?: boolean;
}

// @public
export interface DaprComponent {
    metadata?: DaprMetadata[];
    name?: string;
    type?: string;
    version?: string;
}

// @public
export interface DaprConfig {
    appId?: string;
    appPort?: number;
    enableApiLogging?: boolean;
    enabled?: boolean;
    httpMaxRequestSize?: number;
    httpReadBufferSize?: number;
    logLevel?: DaprLogLevel;
}

// @public
export type DaprLogLevel = string;

// @public
export interface DaprMetadata {
    name?: string;
    secretRef?: string;
    value?: string;
}

// @public
export interface DatabaseBackupSetting {
    connectionString?: string;
    connectionStringName?: string;
    databaseType: DatabaseType;
    // (undocumented)
    name?: string;
}

// @public
export interface DatabaseConnection extends ProxyOnlyResource {
    readonly configurationFiles?: StaticSiteDatabaseConnectionConfigurationFileOverview[];
    connectionIdentity?: string;
    connectionString?: string;
    region?: string;
    resourceId?: string;
}

// @public
export interface DatabaseConnectionCollection {
    readonly nextLink?: string;
    value: DatabaseConnection[];
}

// @public
export interface DatabaseConnectionOverview {
    readonly configurationFiles?: StaticSiteDatabaseConnectionConfigurationFileOverview[];
    readonly connectionIdentity?: string;
    readonly name?: string;
    readonly region?: string;
    readonly resourceId?: string;
}

// @public
export interface DatabaseConnectionPatchRequest {
    connectionIdentity?: string;
    connectionString?: string;
    region?: string;
    resourceId?: string;
}

// @public
export type DatabaseType = string;

// @public
export interface DataProviderMetadata {
    readonly propertyBag?: KeyValuePairStringObject[];
    // (undocumented)
    providerName?: string;
}

// @public
export interface DataSource {
    dataSourceUri?: NameValuePair[];
    instructions?: string[];
}

// @public
export interface DataTableResponseColumn {
    columnName?: string;
    columnType?: string;
    dataType?: string;
}

// @public
export interface DataTableResponseObject {
    columns?: DataTableResponseColumn[];
    rows?: string[][];
    tableName?: string;
}

// @public
export type DayOfWeek = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";

// @public
export type DaysOfWeek = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";

// @public
export type DefaultAction = string;

// @public
export interface DefaultAuthorizationPolicy {
    allowedApplications?: string[];
    allowedPrincipals?: AllowedPrincipals;
}

// @public
export interface DefaultErrorResponse {
    readonly error?: DefaultErrorResponseError;
}

// @public
export interface DefaultErrorResponseError {
    readonly code?: string;
    // (undocumented)
    details?: DefaultErrorResponseErrorDetailsItem[];
    readonly innererror?: string;
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface DefaultErrorResponseErrorDetailsItem {
    readonly code?: string;
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface DeletedAppRestoreRequest extends ProxyOnlyResource {
    deletedSiteId?: string;
    recoverConfiguration?: boolean;
    snapshotTime?: string;
    useDRSecondary?: boolean;
}

// @public
export interface DeletedSite extends ProxyOnlyResource {
    readonly deletedSiteId?: number;
    readonly deletedSiteName?: string;
    readonly deletedTimestamp?: string;
    readonly geoRegionName?: string;
    readonly kindPropertiesKind?: string;
    readonly resourceGroup?: string;
    readonly slot?: string;
    readonly subscription?: string;
}

// @public
export interface DeletedWebAppCollection {
    readonly nextLink?: string;
    value: DeletedSite[];
}

// @public
export interface DeletedWebApps {
    getDeletedWebAppByLocation(location: string, deletedSiteId: string, options?: DeletedWebAppsGetDeletedWebAppByLocationOptionalParams): Promise<DeletedWebAppsGetDeletedWebAppByLocationResponse>;
    list(options?: DeletedWebAppsListOptionalParams): PagedAsyncIterableIterator<DeletedSite>;
    listByLocation(location: string, options?: DeletedWebAppsListByLocationOptionalParams): PagedAsyncIterableIterator<DeletedSite>;
}

// @public
export interface DeletedWebAppsGetDeletedWebAppByLocationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DeletedWebAppsGetDeletedWebAppByLocationResponse = DeletedSite;

// @public
export interface DeletedWebAppsListByLocationNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DeletedWebAppsListByLocationNextResponse = DeletedWebAppCollection;

// @public
export interface DeletedWebAppsListByLocationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DeletedWebAppsListByLocationResponse = DeletedWebAppCollection;

// @public
export interface DeletedWebAppsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DeletedWebAppsListNextResponse = DeletedWebAppCollection;

// @public
export interface DeletedWebAppsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DeletedWebAppsListResponse = DeletedWebAppCollection;

// @public
export interface Deployment extends ProxyOnlyResource {
    active?: boolean;
    author?: string;
    authorEmail?: string;
    deployer?: string;
    details?: string;
    endTime?: Date;
    message?: string;
    startTime?: Date;
    status?: number;
}

// @public
export type DeploymentBuildStatus = string;

// @public
export interface DeploymentCollection {
    readonly nextLink?: string;
    value: Deployment[];
}

// @public
export interface DeploymentLocations {
    hostingEnvironmentDeploymentInfos?: HostingEnvironmentDeploymentInfo[];
    hostingEnvironments?: AppServiceEnvironment[];
    locations?: GeoRegion[];
}

// @public
export interface DetectorAbnormalTimePeriod {
    endTime?: Date;
    message?: string;
    metaData?: NameValuePair[][];
    priority?: number;
    solutions?: Solution[];
    source?: string;
    startTime?: Date;
    type?: IssueType;
}

// @public
export interface DetectorDefinition {
    readonly description?: string;
    readonly displayName?: string;
    readonly isEnabled?: boolean;
    readonly rank?: number;
}

// @public
export interface DetectorDefinitionResource extends ProxyOnlyResource {
    readonly description?: string;
    readonly displayName?: string;
    readonly isEnabled?: boolean;
    readonly rank?: number;
}

// @public
export interface DetectorInfo {
    readonly analysisType?: string[];
    readonly author?: string;
    readonly category?: string;
    readonly description?: string;
    readonly id?: string;
    readonly name?: string;
    readonly score?: number;
    readonly supportTopicList?: SupportTopic[];
    readonly type?: DetectorType;
}

// @public
export interface DetectorResponse extends ProxyOnlyResource {
    dataProvidersMetadata?: DataProviderMetadata[];
    dataset?: DiagnosticData_2[];
    metadata?: DetectorInfo;
    status?: Status;
    suggestedUtterances?: QueryUtterancesResults;
}

// @public
export interface DetectorResponseCollection {
    readonly nextLink?: string;
    value: DetectorResponse[];
}

// @public
export type DetectorType = "Detector" | "Analysis" | "CategoryOverview";

// @public
export interface DiagnosticAnalysis extends ProxyOnlyResource {
    abnormalTimePeriods?: AbnormalTimePeriod[];
    endTime?: Date;
    nonCorrelatedDetectors?: DetectorDefinition[];
    payload?: AnalysisData[];
    startTime?: Date;
}

// @public
export interface DiagnosticAnalysisCollection {
    readonly nextLink?: string;
    value: AnalysisDefinition[];
}

// @public
export interface DiagnosticCategory extends ProxyOnlyResource {
    readonly description?: string;
}

// @public
export interface DiagnosticCategoryCollection {
    readonly nextLink?: string;
    value: DiagnosticCategory[];
}

// @public
interface DiagnosticData_2 {
    renderingProperties?: Rendering;
    table?: DataTableResponseObject;
}
export { DiagnosticData_2 as DiagnosticData }

// @public
export interface DiagnosticDetectorCollection {
    readonly nextLink?: string;
    value: DetectorDefinitionResource[];
}

// @public
export interface DiagnosticDetectorResponse extends ProxyOnlyResource {
    abnormalTimePeriods?: DetectorAbnormalTimePeriod[];
    data?: NameValuePair[][];
    detectorDefinition?: DetectorDefinition;
    endTime?: Date;
    issueDetected?: boolean;
    metrics?: DiagnosticMetricSet[];
    responseMetaData?: ResponseMetaData;
    startTime?: Date;
}

// @public
export interface DiagnosticMetricSample {
    isAggregated?: boolean;
    maximum?: number;
    minimum?: number;
    roleInstance?: string;
    timestamp?: Date;
    total?: number;
}

// @public
export interface DiagnosticMetricSet {
    endTime?: Date;
    name?: string;
    startTime?: Date;
    timeGrain?: string;
    unit?: string;
    values?: DiagnosticMetricSample[];
}

// @public
export interface Diagnostics {
    executeSiteAnalysis(resourceGroupName: string, siteName: string, diagnosticCategory: string, analysisName: string, options?: DiagnosticsExecuteSiteAnalysisOptionalParams): Promise<DiagnosticsExecuteSiteAnalysisResponse>;
    executeSiteAnalysisSlot(resourceGroupName: string, siteName: string, diagnosticCategory: string, analysisName: string, slot: string, options?: DiagnosticsExecuteSiteAnalysisSlotOptionalParams): Promise<DiagnosticsExecuteSiteAnalysisSlotResponse>;
    executeSiteDetector(resourceGroupName: string, siteName: string, detectorName: string, diagnosticCategory: string, options?: DiagnosticsExecuteSiteDetectorOptionalParams): Promise<DiagnosticsExecuteSiteDetectorResponse>;
    executeSiteDetectorSlot(resourceGroupName: string, siteName: string, detectorName: string, diagnosticCategory: string, slot: string, options?: DiagnosticsExecuteSiteDetectorSlotOptionalParams): Promise<DiagnosticsExecuteSiteDetectorSlotResponse>;
    getHostingEnvironmentDetectorResponse(resourceGroupName: string, name: string, detectorName: string, options?: DiagnosticsGetHostingEnvironmentDetectorResponseOptionalParams): Promise<DiagnosticsGetHostingEnvironmentDetectorResponseResponse>;
    getSiteAnalysis(resourceGroupName: string, siteName: string, diagnosticCategory: string, analysisName: string, options?: DiagnosticsGetSiteAnalysisOptionalParams): Promise<DiagnosticsGetSiteAnalysisResponse>;
    getSiteAnalysisSlot(resourceGroupName: string, siteName: string, diagnosticCategory: string, analysisName: string, slot: string, options?: DiagnosticsGetSiteAnalysisSlotOptionalParams): Promise<DiagnosticsGetSiteAnalysisSlotResponse>;
    getSiteDetector(resourceGroupName: string, siteName: string, diagnosticCategory: string, detectorName: string, options?: DiagnosticsGetSiteDetectorOptionalParams): Promise<DiagnosticsGetSiteDetectorResponse>;
    getSiteDetectorResponse(resourceGroupName: string, siteName: string, detectorName: string, options?: DiagnosticsGetSiteDetectorResponseOptionalParams): Promise<DiagnosticsGetSiteDetectorResponseResponse>;
    getSiteDetectorResponseSlot(resourceGroupName: string, siteName: string, detectorName: string, slot: string, options?: DiagnosticsGetSiteDetectorResponseSlotOptionalParams): Promise<DiagnosticsGetSiteDetectorResponseSlotResponse>;
    getSiteDetectorSlot(resourceGroupName: string, siteName: string, diagnosticCategory: string, detectorName: string, slot: string, options?: DiagnosticsGetSiteDetectorSlotOptionalParams): Promise<DiagnosticsGetSiteDetectorSlotResponse>;
    getSiteDiagnosticCategory(resourceGroupName: string, siteName: string, diagnosticCategory: string, options?: DiagnosticsGetSiteDiagnosticCategoryOptionalParams): Promise<DiagnosticsGetSiteDiagnosticCategoryResponse>;
    getSiteDiagnosticCategorySlot(resourceGroupName: string, siteName: string, diagnosticCategory: string, slot: string, options?: DiagnosticsGetSiteDiagnosticCategorySlotOptionalParams): Promise<DiagnosticsGetSiteDiagnosticCategorySlotResponse>;
    listHostingEnvironmentDetectorResponses(resourceGroupName: string, name: string, options?: DiagnosticsListHostingEnvironmentDetectorResponsesOptionalParams): PagedAsyncIterableIterator<DetectorResponse>;
    listSiteAnalyses(resourceGroupName: string, siteName: string, diagnosticCategory: string, options?: DiagnosticsListSiteAnalysesOptionalParams): PagedAsyncIterableIterator<AnalysisDefinition>;
    listSiteAnalysesSlot(resourceGroupName: string, siteName: string, diagnosticCategory: string, slot: string, options?: DiagnosticsListSiteAnalysesSlotOptionalParams): PagedAsyncIterableIterator<AnalysisDefinition>;
    listSiteDetectorResponses(resourceGroupName: string, siteName: string, options?: DiagnosticsListSiteDetectorResponsesOptionalParams): PagedAsyncIterableIterator<DetectorResponse>;
    listSiteDetectorResponsesSlot(resourceGroupName: string, siteName: string, slot: string, options?: DiagnosticsListSiteDetectorResponsesSlotOptionalParams): PagedAsyncIterableIterator<DetectorResponse>;
    listSiteDetectors(resourceGroupName: string, siteName: string, diagnosticCategory: string, options?: DiagnosticsListSiteDetectorsOptionalParams): PagedAsyncIterableIterator<DetectorDefinitionResource>;
    listSiteDetectorsSlot(resourceGroupName: string, siteName: string, diagnosticCategory: string, slot: string, options?: DiagnosticsListSiteDetectorsSlotOptionalParams): PagedAsyncIterableIterator<DetectorDefinitionResource>;
    listSiteDiagnosticCategories(resourceGroupName: string, siteName: string, options?: DiagnosticsListSiteDiagnosticCategoriesOptionalParams): PagedAsyncIterableIterator<DiagnosticCategory>;
    listSiteDiagnosticCategoriesSlot(resourceGroupName: string, siteName: string, slot: string, options?: DiagnosticsListSiteDiagnosticCategoriesSlotOptionalParams): PagedAsyncIterableIterator<DiagnosticCategory>;
}

// @public
export interface DiagnosticsExecuteSiteAnalysisOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsExecuteSiteAnalysisResponse = DiagnosticAnalysis;

// @public
export interface DiagnosticsExecuteSiteAnalysisSlotOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsExecuteSiteAnalysisSlotResponse = DiagnosticAnalysis;

// @public
export interface DiagnosticsExecuteSiteDetectorOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsExecuteSiteDetectorResponse = DiagnosticDetectorResponse;

// @public
export interface DiagnosticsExecuteSiteDetectorSlotOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsExecuteSiteDetectorSlotResponse = DiagnosticDetectorResponse;

// @public
export interface DiagnosticsGetHostingEnvironmentDetectorResponseOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsGetHostingEnvironmentDetectorResponseResponse = DetectorResponse;

// @public
export interface DiagnosticsGetSiteAnalysisOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsGetSiteAnalysisResponse = AnalysisDefinition;

// @public
export interface DiagnosticsGetSiteAnalysisSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsGetSiteAnalysisSlotResponse = AnalysisDefinition;

// @public
export interface DiagnosticsGetSiteDetectorOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsGetSiteDetectorResponse = DetectorDefinitionResource;

// @public
export interface DiagnosticsGetSiteDetectorResponseOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsGetSiteDetectorResponseResponse = DetectorResponse;

// @public
export interface DiagnosticsGetSiteDetectorResponseSlotOptionalParams extends coreClient.OperationOptions {
    endTime?: Date;
    startTime?: Date;
    timeGrain?: string;
}

// @public
export type DiagnosticsGetSiteDetectorResponseSlotResponse = DetectorResponse;

// @public
export interface DiagnosticsGetSiteDetectorSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsGetSiteDetectorSlotResponse = DetectorDefinitionResource;

// @public
export interface DiagnosticsGetSiteDiagnosticCategoryOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsGetSiteDiagnosticCategoryResponse = DiagnosticCategory;

// @public
export interface DiagnosticsGetSiteDiagnosticCategorySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsGetSiteDiagnosticCategorySlotResponse = DiagnosticCategory;

// @public
export interface DiagnosticsListHostingEnvironmentDetectorResponsesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListHostingEnvironmentDetectorResponsesNextResponse = DetectorResponseCollection;

// @public
export interface DiagnosticsListHostingEnvironmentDetectorResponsesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListHostingEnvironmentDetectorResponsesResponse = DetectorResponseCollection;

// @public
export interface DiagnosticsListSiteAnalysesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteAnalysesNextResponse = DiagnosticAnalysisCollection;

// @public
export interface DiagnosticsListSiteAnalysesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteAnalysesResponse = DiagnosticAnalysisCollection;

// @public
export interface DiagnosticsListSiteAnalysesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteAnalysesSlotNextResponse = DiagnosticAnalysisCollection;

// @public
export interface DiagnosticsListSiteAnalysesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteAnalysesSlotResponse = DiagnosticAnalysisCollection;

// @public
export interface DiagnosticsListSiteDetectorResponsesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorResponsesNextResponse = DetectorResponseCollection;

// @public
export interface DiagnosticsListSiteDetectorResponsesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorResponsesResponse = DetectorResponseCollection;

// @public
export interface DiagnosticsListSiteDetectorResponsesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorResponsesSlotNextResponse = DetectorResponseCollection;

// @public
export interface DiagnosticsListSiteDetectorResponsesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorResponsesSlotResponse = DetectorResponseCollection;

// @public
export interface DiagnosticsListSiteDetectorsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorsNextResponse = DiagnosticDetectorCollection;

// @public
export interface DiagnosticsListSiteDetectorsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorsResponse = DiagnosticDetectorCollection;

// @public
export interface DiagnosticsListSiteDetectorsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorsSlotNextResponse = DiagnosticDetectorCollection;

// @public
export interface DiagnosticsListSiteDetectorsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDetectorsSlotResponse = DiagnosticDetectorCollection;

// @public
export interface DiagnosticsListSiteDiagnosticCategoriesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDiagnosticCategoriesNextResponse = DiagnosticCategoryCollection;

// @public
export interface DiagnosticsListSiteDiagnosticCategoriesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDiagnosticCategoriesResponse = DiagnosticCategoryCollection;

// @public
export interface DiagnosticsListSiteDiagnosticCategoriesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDiagnosticCategoriesSlotNextResponse = DiagnosticCategoryCollection;

// @public
export interface DiagnosticsListSiteDiagnosticCategoriesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticsListSiteDiagnosticCategoriesSlotResponse = DiagnosticCategoryCollection;

// @public
export interface Dimension {
    // (undocumented)
    displayName?: string;
    // (undocumented)
    internalName?: string;
    // (undocumented)
    name?: string;
    // (undocumented)
    toBeExportedForShoebox?: boolean;
}

// @public
export type DnsType = "AzureDns" | "DefaultDomainRegistrarDns";

// @public
export type DnsVerificationTestResult = "Passed" | "Failed" | "Skipped";

// @public
export interface Domain extends Resource {
    // (undocumented)
    authCode?: string;
    autoRenew?: boolean;
    consent?: DomainPurchaseConsent;
    contactAdmin?: Contact;
    contactBilling?: Contact;
    contactRegistrant?: Contact;
    contactTech?: Contact;
    readonly createdTime?: Date;
    dnsType?: DnsType;
    dnsZoneId?: string;
    readonly domainNotRenewableReasons?: ResourceNotRenewableReason[];
    readonly expirationTime?: Date;
    readonly lastRenewedTime?: Date;
    readonly managedHostNames?: HostName[];
    readonly nameServers?: string[];
    privacy?: boolean;
    readonly provisioningState?: ProvisioningState;
    readonly readyForDnsRecordManagement?: boolean;
    readonly registrationStatus?: DomainStatus;
    targetDnsType?: DnsType;
}

// @public
export interface DomainAvailabilityCheckResult {
    available?: boolean;
    domainType?: DomainType;
    name?: string;
}

// @public
export interface DomainCollection {
    readonly nextLink?: string;
    value: Domain[];
}

// @public
export interface DomainControlCenterSsoRequest {
    readonly postParameterKey?: string;
    readonly postParameterValue?: string;
    readonly url?: string;
}

// @public
export interface DomainOwnershipIdentifier extends ProxyOnlyResource {
    ownershipId?: string;
}

// @public
export interface DomainOwnershipIdentifierCollection {
    readonly nextLink?: string;
    value: DomainOwnershipIdentifier[];
}

// @public
export interface DomainPatchResource extends ProxyOnlyResource {
    // (undocumented)
    authCode?: string;
    autoRenew?: boolean;
    consent?: DomainPurchaseConsent;
    contactAdmin?: Contact;
    contactBilling?: Contact;
    contactRegistrant?: Contact;
    contactTech?: Contact;
    readonly createdTime?: Date;
    dnsType?: DnsType;
    dnsZoneId?: string;
    readonly domainNotRenewableReasons?: ResourceNotRenewableReason[];
    readonly expirationTime?: Date;
    readonly lastRenewedTime?: Date;
    readonly managedHostNames?: HostName[];
    readonly nameServers?: string[];
    privacy?: boolean;
    readonly provisioningState?: ProvisioningState;
    readonly readyForDnsRecordManagement?: boolean;
    readonly registrationStatus?: DomainStatus;
    targetDnsType?: DnsType;
}

// @public
export interface DomainPurchaseConsent {
    agreedAt?: Date;
    agreedBy?: string;
    agreementKeys?: string[];
}

// @public
export interface DomainRecommendationSearchParameters {
    keywords?: string;
    maxDomainRecommendations?: number;
}

// @public
export interface DomainRegistrationProvider {
    listOperations(options?: DomainRegistrationProviderListOperationsOptionalParams): PagedAsyncIterableIterator<CsmOperationDescription>;
}

// @public
export interface DomainRegistrationProviderListOperationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainRegistrationProviderListOperationsNextResponse = CsmOperationCollection;

// @public
export interface DomainRegistrationProviderListOperationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainRegistrationProviderListOperationsResponse = CsmOperationCollection;

// @public
export interface Domains {
    beginCreateOrUpdate(resourceGroupName: string, domainName: string, domain: Domain, options?: DomainsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DomainsCreateOrUpdateResponse>, DomainsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, domainName: string, domain: Domain, options?: DomainsCreateOrUpdateOptionalParams): Promise<DomainsCreateOrUpdateResponse>;
    checkAvailability(identifier: NameIdentifier, options?: DomainsCheckAvailabilityOptionalParams): Promise<DomainsCheckAvailabilityResponse>;
    createOrUpdateOwnershipIdentifier(resourceGroupName: string, domainName: string, name: string, domainOwnershipIdentifier: DomainOwnershipIdentifier, options?: DomainsCreateOrUpdateOwnershipIdentifierOptionalParams): Promise<DomainsCreateOrUpdateOwnershipIdentifierResponse>;
    delete(resourceGroupName: string, domainName: string, options?: DomainsDeleteOptionalParams): Promise<void>;
    deleteOwnershipIdentifier(resourceGroupName: string, domainName: string, name: string, options?: DomainsDeleteOwnershipIdentifierOptionalParams): Promise<void>;
    get(resourceGroupName: string, domainName: string, options?: DomainsGetOptionalParams): Promise<DomainsGetResponse>;
    getControlCenterSsoRequest(options?: DomainsGetControlCenterSsoRequestOptionalParams): Promise<DomainsGetControlCenterSsoRequestResponse>;
    getOwnershipIdentifier(resourceGroupName: string, domainName: string, name: string, options?: DomainsGetOwnershipIdentifierOptionalParams): Promise<DomainsGetOwnershipIdentifierResponse>;
    list(options?: DomainsListOptionalParams): PagedAsyncIterableIterator<Domain>;
    listByResourceGroup(resourceGroupName: string, options?: DomainsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<Domain>;
    listOwnershipIdentifiers(resourceGroupName: string, domainName: string, options?: DomainsListOwnershipIdentifiersOptionalParams): PagedAsyncIterableIterator<DomainOwnershipIdentifier>;
    listRecommendations(parameters: DomainRecommendationSearchParameters, options?: DomainsListRecommendationsOptionalParams): PagedAsyncIterableIterator<NameIdentifier>;
    renew(resourceGroupName: string, domainName: string, options?: DomainsRenewOptionalParams): Promise<void>;
    transferOut(resourceGroupName: string, domainName: string, options?: DomainsTransferOutOptionalParams): Promise<DomainsTransferOutResponse>;
    update(resourceGroupName: string, domainName: string, domain: DomainPatchResource, options?: DomainsUpdateOptionalParams): Promise<DomainsUpdateResponse>;
    updateOwnershipIdentifier(resourceGroupName: string, domainName: string, name: string, domainOwnershipIdentifier: DomainOwnershipIdentifier, options?: DomainsUpdateOwnershipIdentifierOptionalParams): Promise<DomainsUpdateOwnershipIdentifierResponse>;
}

// @public
export interface DomainsCheckAvailabilityOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsCheckAvailabilityResponse = DomainAvailabilityCheckResult;

// @public
export interface DomainsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface DomainsCreateOrUpdateOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsCreateOrUpdateOwnershipIdentifierResponse = DomainOwnershipIdentifier;

// @public
export type DomainsCreateOrUpdateResponse = Domain;

// @public
export interface DomainsDeleteOptionalParams extends coreClient.OperationOptions {
    forceHardDeleteDomain?: boolean;
}

// @public
export interface DomainsDeleteOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DomainsGetControlCenterSsoRequestOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsGetControlCenterSsoRequestResponse = DomainControlCenterSsoRequest;

// @public
export interface DomainsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DomainsGetOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsGetOwnershipIdentifierResponse = DomainOwnershipIdentifier;

// @public
export type DomainsGetResponse = Domain;

// @public
export interface DomainsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListByResourceGroupNextResponse = DomainCollection;

// @public
export interface DomainsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListByResourceGroupResponse = DomainCollection;

// @public
export interface DomainsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListNextResponse = DomainCollection;

// @public
export interface DomainsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DomainsListOwnershipIdentifiersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListOwnershipIdentifiersNextResponse = DomainOwnershipIdentifierCollection;

// @public
export interface DomainsListOwnershipIdentifiersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListOwnershipIdentifiersResponse = DomainOwnershipIdentifierCollection;

// @public
export interface DomainsListRecommendationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListRecommendationsNextResponse = NameIdentifierCollection;

// @public
export interface DomainsListRecommendationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsListRecommendationsResponse = NameIdentifierCollection;

// @public
export type DomainsListResponse = DomainCollection;

// @public
export interface DomainsRenewOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainStatus = "Active" | "Awaiting" | "Cancelled" | "Confiscated" | "Disabled" | "Excluded" | "Expired" | "Failed" | "Held" | "Locked" | "Parked" | "Pending" | "Reserved" | "Reverted" | "Suspended" | "Transferred" | "Unknown" | "Unlocked" | "Unparked" | "Updated" | "JsonConverterFailed";

// @public
export interface DomainsTransferOutOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsTransferOutResponse = Domain;

// @public
export interface DomainsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DomainsUpdateOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DomainsUpdateOwnershipIdentifierResponse = DomainOwnershipIdentifier;

// @public
export type DomainsUpdateResponse = Domain;

// @public
export type DomainType = "Regular" | "SoftDeleted";

// @public
export interface EnabledConfig {
    enabled?: boolean;
}

// @public
export interface EndpointDependency {
    domainName?: string;
    endpointDetails?: EndpointDetail[];
}

// @public
export interface EndpointDetail {
    ipAddress?: string;
    isAccessible?: boolean;
    latency?: number;
    port?: number;
}

// @public
export type EnterpriseGradeCdnStatus = string;

// @public
export interface EnvironmentVar {
    name?: string;
    secretRef?: string;
    value?: string;
}

// @public (undocumented)
export interface EnvironmentVariable {
    name: string;
    value: string;
}

// @public
export interface ErrorEntity {
    code?: string;
    details?: ErrorEntity[];
    extendedCode?: string;
    innerErrors?: ErrorEntity[];
    message?: string;
    messageTemplate?: string;
    parameters?: string[];
    target?: string;
}

// @public
export interface ErrorInfo {
    code: string;
}

// @public
export interface ErrorProperties {
    code?: string;
    message?: string;
}

// @public
export interface ErrorResponse {
    error?: ErrorProperties;
}

// @public
export interface Experiments {
    rampUpRules?: RampUpRule[];
}

// @public
export interface Expression {
    error?: AzureResourceErrorInfo;
    subexpressions?: Expression[];
    text?: string;
    value?: any;
}

// @public
export interface ExpressionRoot extends Expression {
    path?: string;
}

// @public
export interface ExpressionTraces {
    // (undocumented)
    inputs?: ExpressionRoot[];
    nextLink?: string;
    value?: any;
}

// @public
export interface ExtendedLocation {
    name?: string;
    readonly type?: string;
}

// @public
export interface Facebook {
    enabled?: boolean;
    graphApiVersion?: string;
    login?: LoginScopes;
    registration?: AppRegistration;
}

// @public
export interface FileSystemApplicationLogsConfig {
    level?: LogLevel;
}

// @public
export interface FileSystemHttpLogsConfig {
    enabled?: boolean;
    retentionInDays?: number;
    retentionInMb?: number;
}

// @public
export interface FileSystemTokenStore {
    directory?: string;
}

// @public
export interface FlowAccessControlConfiguration {
    actions?: FlowAccessControlConfigurationPolicy;
    contents?: FlowAccessControlConfigurationPolicy;
    triggers?: FlowAccessControlConfigurationPolicy;
    workflowManagement?: FlowAccessControlConfigurationPolicy;
}

// @public
export interface FlowAccessControlConfigurationPolicy {
    allowedCallerIpAddresses?: IpAddressRange[];
    openAuthenticationPolicies?: OpenAuthenticationAccessPolicies;
}

// @public
export interface FlowEndpoints {
    accessEndpointIpAddresses?: IpAddress[];
    outgoingIpAddresses?: IpAddress[];
}

// @public
export interface FlowEndpointsConfiguration {
    connector?: FlowEndpoints;
    workflow?: FlowEndpoints;
}

// @public
export interface ForwardProxy {
    convention?: ForwardProxyConvention;
    customHostHeaderName?: string;
    customProtoHeaderName?: string;
}

// @public
export type ForwardProxyConvention = "NoProxy" | "Standard" | "Custom";

// @public
export type FrequencyUnit = "Day" | "Hour";

// @public (undocumented)
export interface FrontEndConfiguration {
    // (undocumented)
    kind?: FrontEndServiceType;
}

// @public
export type FrontEndServiceType = "NodePort" | "LoadBalancer";

// @public
export type FtpsState = string;

// @public
export interface FunctionAppConfig {
    deployment?: FunctionsDeployment;
    runtime?: FunctionsRuntime;
    scaleAndConcurrency?: FunctionsScaleAndConcurrency;
}

// @public
export interface FunctionAppMajorVersion {
    readonly displayText?: string;
    readonly minorVersions?: FunctionAppMinorVersion[];
    readonly value?: string;
}

// @public
export interface FunctionAppMinorVersion {
    readonly displayText?: string;
    readonly stackSettings?: FunctionAppRuntimes;
    readonly value?: string;
}

// @public
export interface FunctionAppRuntimes {
    readonly linuxRuntimeSettings?: FunctionAppRuntimeSettings;
    readonly windowsRuntimeSettings?: FunctionAppRuntimeSettings;
}

// @public
export interface FunctionAppRuntimeSettings {
    readonly appInsightsSettings?: AppInsightsWebAppStackSettings;
    readonly appSettingsDictionary?: {
        [propertyName: string]: string;
    };
    readonly endOfLifeDate?: Date;
    readonly gitHubActionSettings?: GitHubActionWebAppStackSettings;
    readonly isAutoUpdate?: boolean;
    readonly isDefault?: boolean;
    readonly isDeprecated?: boolean;
    readonly isEarlyAccess?: boolean;
    readonly isHidden?: boolean;
    readonly isPreview?: boolean;
    readonly remoteDebuggingSupported?: boolean;
    readonly runtimeVersion?: string;
    readonly siteConfigPropertiesDictionary?: SiteConfigPropertiesDictionary;
    readonly supportedFunctionsExtensionVersions?: string[];
}

// @public
export interface FunctionAppStack extends ProxyOnlyResource {
    readonly displayText?: string;
    readonly location?: string;
    readonly majorVersions?: FunctionAppMajorVersion[];
    readonly preferredOs?: StackPreferredOs;
    readonly value?: string;
}

// @public
export interface FunctionAppStackCollection {
    readonly nextLink?: string;
    value: FunctionAppStack[];
}

// @public
export interface FunctionEnvelope extends ProxyOnlyResource {
    config?: Record<string, unknown>;
    configHref?: string;
    files?: {
        [propertyName: string]: string;
    };
    functionAppId?: string;
    href?: string;
    invokeUrlTemplate?: string;
    isDisabled?: boolean;
    language?: string;
    scriptHref?: string;
    scriptRootPathHref?: string;
    secretsFileHref?: string;
    testData?: string;
    testDataHref?: string;
}

// @public
export interface FunctionEnvelopeCollection {
    readonly nextLink?: string;
    value: FunctionEnvelope[];
}

// @public
export interface FunctionsAlwaysReadyConfig {
    instanceCount?: number;
    name?: string;
}

// @public
export interface FunctionsDeployment {
    storage?: FunctionsDeploymentStorage;
}

// @public
export interface FunctionsDeploymentStorage {
    authentication?: FunctionsDeploymentStorageAuthentication;
    type?: FunctionsDeploymentStorageType;
    value?: string;
}

// @public
export interface FunctionsDeploymentStorageAuthentication {
    storageAccountConnectionStringName?: string;
    type?: AuthenticationType;
    userAssignedIdentityResourceId?: string;
}

// @public
export type FunctionsDeploymentStorageType = string;

// @public
export interface FunctionSecrets {
    key?: string;
    triggerUrl?: string;
}

// @public
export interface FunctionsRuntime {
    name?: RuntimeName;
    version?: string;
}

// @public
export interface FunctionsScaleAndConcurrency {
    alwaysReady?: FunctionsAlwaysReadyConfig[];
    instanceMemoryMB?: number;
    maximumInstanceCount?: number;
    triggers?: FunctionsScaleAndConcurrencyTriggers;
}

// @public
export interface FunctionsScaleAndConcurrencyTriggers {
    http?: FunctionsScaleAndConcurrencyTriggersHttp;
}

// @public
export interface FunctionsScaleAndConcurrencyTriggersHttp {
    perInstanceConcurrency?: number;
}

// @public
export interface GeoRegion extends ProxyOnlyResource {
    readonly description?: string;
    readonly displayName?: string;
    readonly orgDomain?: string;
}

// @public
export interface GeoRegionCollection {
    readonly nextLink?: string;
    value: GeoRegion[];
}

// @public
export function getContinuationToken(page: unknown): string | undefined;

// @public
export interface GetPublishingUserOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GetPublishingUserResponse = User;

// @public
export interface GetSourceControlOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GetSourceControlResponse = SourceControl;

// @public
export interface GetSubscriptionDeploymentLocationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GetSubscriptionDeploymentLocationsResponse = DeploymentLocations;

// @public
export interface GetUsagesInLocation {
    list(location: string, options?: GetUsagesInLocationListOptionalParams): PagedAsyncIterableIterator<CsmUsageQuota>;
}

// @public
export interface GetUsagesInLocationListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GetUsagesInLocationListNextResponse = CsmUsageQuotaCollection;

// @public
export interface GetUsagesInLocationListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GetUsagesInLocationListResponse = CsmUsageQuotaCollection;

// @public
export interface GitHub {
    enabled?: boolean;
    login?: LoginScopes;
    registration?: ClientRegistration;
}

// @public
export interface GitHubActionCodeConfiguration {
    runtimeStack?: string;
    runtimeVersion?: string;
}

// @public
export interface GitHubActionConfiguration {
    codeConfiguration?: GitHubActionCodeConfiguration;
    containerConfiguration?: GitHubActionContainerConfiguration;
    generateWorkflowFile?: boolean;
    isLinux?: boolean;
}

// @public
export interface GitHubActionContainerConfiguration {
    imageName?: string;
    password?: string;
    serverUrl?: string;
    username?: string;
}

// @public
export interface GitHubActionWebAppStackSettings {
    readonly isSupported?: boolean;
    readonly supportedVersion?: string;
}

// @public
interface Global_2 {
    getDeletedWebApp(deletedSiteId: string, options?: GlobalGetDeletedWebAppOptionalParams): Promise<GlobalGetDeletedWebAppResponse>;
    getDeletedWebAppSnapshots(deletedSiteId: string, options?: GlobalGetDeletedWebAppSnapshotsOptionalParams): Promise<GlobalGetDeletedWebAppSnapshotsResponse>;
    getSubscriptionOperationWithAsyncResponse(location: string, operationId: string, options?: GlobalGetSubscriptionOperationWithAsyncResponseOptionalParams): Promise<void>;
}
export { Global_2 as Global }

// @public
export interface GlobalCsmSkuDescription {
    capabilities?: Capability[];
    capacity?: SkuCapacity;
    family?: string;
    locations?: string[];
    name?: string;
    size?: string;
    tier?: string;
}

// @public
export interface GlobalGetDeletedWebAppOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GlobalGetDeletedWebAppResponse = DeletedSite;

// @public
export interface GlobalGetDeletedWebAppSnapshotsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GlobalGetDeletedWebAppSnapshotsResponse = Snapshot[];

// @public
export interface GlobalGetSubscriptionOperationWithAsyncResponseOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface GlobalValidation {
    excludedPaths?: string[];
    redirectToProvider?: string;
    requireAuthentication?: boolean;
    unauthenticatedClientAction?: UnauthenticatedClientActionV2;
}

// @public
export interface Google {
    enabled?: boolean;
    login?: LoginScopes;
    registration?: ClientRegistration;
    validation?: AllowedAudiencesValidation;
}

// @public
export interface HandlerMapping {
    arguments?: string;
    extension?: string;
    scriptProcessor?: string;
}

// @public
export interface HostingEnvironmentDeploymentInfo {
    location?: string;
    name?: string;
}

// @public
export interface HostingEnvironmentDiagnostics {
    diagnosticsOutput?: string;
    name?: string;
}

// @public
export interface HostingEnvironmentProfile {
    id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export type HostingEnvironmentStatus = "Preparing" | "Ready" | "Scaling" | "Deleting";

// @public
export interface HostKeys {
    functionKeys?: {
        [propertyName: string]: string;
    };
    masterKey?: string;
    systemKeys?: {
        [propertyName: string]: string;
    };
}

// @public
export interface HostName {
    azureResourceName?: string;
    azureResourceType?: AzureResourceType;
    customHostNameDnsRecordType?: CustomHostNameDnsRecordType;
    hostNameType?: HostNameType;
    name?: string;
    siteNames?: string[];
}

// @public
export interface HostNameBinding extends ProxyOnlyResource {
    azureResourceName?: string;
    azureResourceType?: AzureResourceType;
    customHostNameDnsRecordType?: CustomHostNameDnsRecordType;
    domainId?: string;
    hostNameType?: HostNameType;
    siteName?: string;
    sslState?: SslState;
    thumbprint?: string;
    readonly virtualIP?: string;
}

// @public
export interface HostNameBindingCollection {
    readonly nextLink?: string;
    value: HostNameBinding[];
}

// @public
export interface HostNameSslState {
    hostType?: HostType;
    name?: string;
    sslState?: SslState;
    thumbprint?: string;
    toUpdate?: boolean;
    virtualIP?: string;
}

// @public
export type HostNameType = "Verified" | "Managed";

// @public
export type HostType = "Standard" | "Repository";

// @public
export interface HttpLogsConfig {
    azureBlobStorage?: AzureBlobStorageHttpLogsConfig;
    fileSystem?: FileSystemHttpLogsConfig;
}

// @public
export interface HttpScaleRule {
    auth?: ScaleRuleAuth[];
    metadata?: {
        [propertyName: string]: string;
    };
}

// @public
export interface HttpSettings {
    forwardProxy?: ForwardProxy;
    requireHttps?: boolean;
    routes?: HttpSettingsRoutes;
}

// @public
export interface HttpSettingsRoutes {
    apiPrefix?: string;
}

// @public
export interface HybridConnection extends ProxyOnlyResource {
    hostname?: string;
    port?: number;
    relayArmUri?: string;
    relayName?: string;
    sendKeyName?: string;
    sendKeyValue?: string;
    serviceBusNamespace?: string;
    serviceBusSuffix?: string;
}

// @public
export interface HybridConnectionCollection {
    readonly nextLink?: string;
    value: HybridConnection[];
}

// @public
export interface HybridConnectionKey extends ProxyOnlyResource {
    readonly sendKeyName?: string;
    readonly sendKeyValue?: string;
}

// @public
export interface HybridConnectionLimits extends ProxyOnlyResource {
    readonly current?: number;
    readonly maximum?: number;
}

// @public
export interface Identifier extends ProxyOnlyResource {
    value?: string;
}

// @public
export interface IdentifierCollection {
    readonly nextLink?: string;
    value: Identifier[];
}

// @public
export interface IdentityProviders {
    apple?: Apple;
    azureActiveDirectory?: AzureActiveDirectory;
    azureStaticWebApps?: AzureStaticWebApps;
    customOpenIdConnectProviders?: {
        [propertyName: string]: CustomOpenIdConnectProvider;
    };
    facebook?: Facebook;
    gitHub?: GitHub;
    google?: Google;
    legacyMicrosoftAccount?: LegacyMicrosoftAccount;
    twitter?: Twitter;
}

// @public
export type InAvailabilityReasonType = string;

// @public
export interface InboundEnvironmentEndpoint {
    description?: string;
    endpoints?: string[];
    ports?: string[];
}

// @public
export interface InboundEnvironmentEndpointCollection {
    readonly nextLink?: string;
    value: InboundEnvironmentEndpoint[];
}

// @public
export interface Ingress {
    allowInsecure?: boolean;
    external?: boolean;
    readonly fqdn?: string;
    targetPort?: number;
    // (undocumented)
    traffic?: TrafficWeight[];
    transport?: IngressTransportMethod;
}

// @public
export type IngressTransportMethod = string;

// @public
export type InsightStatus = "Critical" | "Warning" | "Info" | "Success" | "None";

// @public
export interface IpAddress {
    address?: string;
}

// @public
export interface IpAddressRange {
    addressRange?: string;
}

// @public
export type IpFilterTag = string;

// @public
export interface IpSecurityRestriction {
    action?: string;
    description?: string;
    headers?: {
        [propertyName: string]: string[];
    };
    ipAddress?: string;
    name?: string;
    priority?: number;
    subnetMask?: string;
    subnetTrafficTag?: number;
    tag?: IpFilterTag;
    vnetSubnetResourceId?: string;
    vnetTrafficTag?: number;
}

// @public
export type IssueType = "ServiceIncident" | "AppDeployment" | "AppCrash" | "RuntimeIssueDetected" | "AseDeployment" | "UserIssue" | "PlatformIssue" | "Other";

// @public
export interface JsonSchema {
    content?: string;
    title?: string;
}

// @public
export interface JwtClaimChecks {
    allowedClientApplications?: string[];
    allowedGroups?: string[];
}

// @public
export interface KeyInfo {
    name?: string;
    value?: string;
}

// @public
type KeyType_2 = string;
export { KeyType_2 as KeyType }

// @public (undocumented)
export interface KeyValuePairStringObject {
    readonly key?: string;
    readonly value?: Record<string, unknown>;
}

// @public
export type KeyVaultSecretStatus = "Initialized" | "WaitingOnCertificateOrder" | "Succeeded" | "CertificateOrderFailed" | "OperationNotPermittedOnKeyVault" | "AzureServiceUnauthorizedToAccessKeyVault" | "KeyVaultDoesNotExist" | "KeyVaultSecretDoesNotExist" | "UnknownError" | "ExternalPrivateKey" | "Unknown";

// @public
export type Kind = string;

// @public
export enum KnownActiveRevisionsMode {
    Multiple = "multiple",
    Single = "single"
}

// @public
export enum KnownAuthenticationType {
    StorageAccountConnectionString = "StorageAccountConnectionString",
    SystemAssignedIdentity = "SystemAssignedIdentity",
    UserAssignedIdentity = "UserAssignedIdentity"
}

// @public
export enum KnownAzureStorageProtocol {
    Http = "Http",
    Nfs = "Nfs",
    Smb = "Smb"
}

// @public
export enum KnownBasicAuthName {
    Default = "default"
}

// @public
export enum KnownBuildStatus {
    Deleting = "Deleting",
    Deploying = "Deploying",
    Detached = "Detached",
    Failed = "Failed",
    Ready = "Ready",
    Uploading = "Uploading",
    WaitingForDeployment = "WaitingForDeployment"
}

// @public
export enum KnownCheckNameResourceTypes {
    HostingEnvironment = "HostingEnvironment",
    MicrosoftWebHostingEnvironments = "Microsoft.Web/hostingEnvironments",
    MicrosoftWebPublishingUsers = "Microsoft.Web/publishingUsers",
    MicrosoftWebSites = "Microsoft.Web/sites",
    MicrosoftWebSitesSlots = "Microsoft.Web/sites/slots",
    PublishingUser = "PublishingUser",
    Site = "Site",
    Slot = "Slot"
}

// @public
export enum KnownContainerAppProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    InProgress = "InProgress",
    Succeeded = "Succeeded"
}

// @public
export enum KnownCustomDomainStatus {
    Adding = "Adding",
    Deleting = "Deleting",
    Failed = "Failed",
    Ready = "Ready",
    RetrievingValidationToken = "RetrievingValidationToken",
    Unhealthy = "Unhealthy",
    Validating = "Validating"
}

// @public
export enum KnownDaprLogLevel {
    Debug = "debug",
    Error = "error",
    Info = "info",
    Warn = "warn"
}

// @public
export enum KnownDatabaseType {
    LocalMySql = "LocalMySql",
    MySql = "MySql",
    PostgreSql = "PostgreSql",
    SqlAzure = "SqlAzure"
}

// @public
export enum KnownDefaultAction {
    Allow = "Allow",
    Deny = "Deny"
}

// @public
export enum KnownDeploymentBuildStatus {
    BuildAborted = "BuildAborted",
    BuildFailed = "BuildFailed",
    BuildInProgress = "BuildInProgress",
    BuildPending = "BuildPending",
    BuildRequestReceived = "BuildRequestReceived",
    BuildSuccessful = "BuildSuccessful",
    PostBuildRestartRequired = "PostBuildRestartRequired",
    RuntimeFailed = "RuntimeFailed",
    RuntimeStarting = "RuntimeStarting",
    RuntimeSuccessful = "RuntimeSuccessful",
    StartPolling = "StartPolling",
    StartPollingWithRestart = "StartPollingWithRestart",
    TimedOut = "TimedOut"
}

// @public
export enum KnownEnterpriseGradeCdnStatus {
    Disabled = "Disabled",
    Disabling = "Disabling",
    Enabled = "Enabled",
    Enabling = "Enabling"
}

// @public
export enum KnownFtpsState {
    AllAllowed = "AllAllowed",
    Disabled = "Disabled",
    FtpsOnly = "FtpsOnly"
}

// @public
export enum KnownFunctionsDeploymentStorageType {
    BlobContainer = "blobContainer"
}

// @public
export enum KnownInAvailabilityReasonType {
    AlreadyExists = "AlreadyExists",
    Invalid = "Invalid"
}

// @public
export enum KnownIngressTransportMethod {
    Auto = "auto",
    Http = "http",
    Http2 = "http2"
}

// @public
export enum KnownIpFilterTag {
    Default = "Default",
    ServiceTag = "ServiceTag",
    XffProxy = "XffProxy"
}

// @public
export enum KnownKeyType {
    NotSpecified = "NotSpecified",
    Primary = "Primary",
    Secondary = "Secondary"
}

// @public
export enum KnownKind {
    Stateful = "Stateful",
    Stateless = "Stateless"
}

// @public
export enum KnownLoadBalancingMode {
    None = "None",
    Publishing = "Publishing",
    Web = "Web",
    WebPublishing = "Web, Publishing"
}

// @public
export enum KnownOpenAuthenticationProviderType {
    AAD = "AAD"
}

// @public
export enum KnownParameterType {
    Array = "Array",
    Bool = "Bool",
    Float = "Float",
    Int = "Int",
    NotSpecified = "NotSpecified",
    Object = "Object",
    SecureObject = "SecureObject",
    SecureString = "SecureString",
    String = "String"
}

// @public
export enum KnownProviderOsTypeSelected {
    All = "All",
    Linux = "Linux",
    LinuxFunctions = "LinuxFunctions",
    Windows = "Windows",
    WindowsFunctions = "WindowsFunctions"
}

// @public
export enum KnownProviderStackOsType {
    All = "All",
    Linux = "Linux",
    Windows = "Windows"
}

// @public
export enum KnownPublishingProfileFormat {
    FileZilla3 = "FileZilla3",
    Ftp = "Ftp",
    WebDeploy = "WebDeploy"
}

// @public
export enum KnownRecurrenceFrequency {
    Day = "Day",
    Hour = "Hour",
    Minute = "Minute",
    Month = "Month",
    NotSpecified = "NotSpecified",
    Second = "Second",
    Week = "Week",
    Year = "Year"
}

// @public
export enum KnownResourceNotRenewableReason {
    ExpirationNotInRenewalTimeRange = "ExpirationNotInRenewalTimeRange",
    RegistrationStatusNotSupportedForRenewal = "RegistrationStatusNotSupportedForRenewal",
    SubscriptionNotActive = "SubscriptionNotActive"
}

// @public
export enum KnownResourceScopeType {
    ServerFarm = "ServerFarm",
    Subscription = "Subscription",
    WebSite = "WebSite"
}

// @public
export enum KnownRevisionHealthState {
    Healthy = "Healthy",
    None = "None",
    Unhealthy = "Unhealthy"
}

// @public
export enum KnownRevisionProvisioningState {
    Deprovisioned = "Deprovisioned",
    Deprovisioning = "Deprovisioning",
    Failed = "Failed",
    Provisioned = "Provisioned",
    Provisioning = "Provisioning"
}

// @public
export enum KnownRouteType {
    Default = "DEFAULT",
    Inherited = "INHERITED",
    Static = "STATIC"
}

// @public
export enum KnownRuntimeName {
    Custom = "custom",
    DotnetIsolated = "dotnet-isolated",
    Java = "java",
    Node = "node",
    Powershell = "powershell",
    Python = "python"
}

// @public
export enum KnownScmType {
    BitbucketGit = "BitbucketGit",
    BitbucketHg = "BitbucketHg",
    CodePlexGit = "CodePlexGit",
    CodePlexHg = "CodePlexHg",
    Dropbox = "Dropbox",
    ExternalGit = "ExternalGit",
    ExternalHg = "ExternalHg",
    GitHub = "GitHub",
    LocalGit = "LocalGit",
    None = "None",
    OneDrive = "OneDrive",
    Tfs = "Tfs",
    VSO = "VSO",
    Vstsrm = "VSTSRM"
}

// @public
export enum KnownSkuName {
    Basic = "Basic",
    Dynamic = "Dynamic",
    ElasticIsolated = "ElasticIsolated",
    ElasticPremium = "ElasticPremium",
    FlexConsumption = "FlexConsumption",
    Free = "Free",
    Isolated = "Isolated",
    IsolatedV2 = "IsolatedV2",
    Premium = "Premium",
    PremiumContainer = "PremiumContainer",
    PremiumV2 = "PremiumV2",
    PremiumV3 = "PremiumV3",
    Shared = "Shared",
    Standard = "Standard"
}

// @public
export enum KnownSupportedTlsVersions {
    One0 = "1.0",
    One1 = "1.1",
    One2 = "1.2",
    One3 = "1.3"
}

// @public
export enum KnownTlsCipherSuites {
    TLSAES128GCMSHA256 = "TLS_AES_128_GCM_SHA256",
    TLSAES256GCMSHA384 = "TLS_AES_256_GCM_SHA384",
    TLSEcdheEcdsaWithAES128CBCSHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
    TLSEcdheEcdsaWithAES128GCMSHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
    TLSEcdheEcdsaWithAES256GCMSHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
    TLSEcdheRSAWithAES128CBCSHA = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
    TLSEcdheRSAWithAES128CBCSHA256 = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
    TLSEcdheRSAWithAES128GCMSHA256 = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
    TLSEcdheRSAWithAES256CBCSHA = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
    TLSEcdheRSAWithAES256CBCSHA384 = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384",
    TLSEcdheRSAWithAES256GCMSHA384 = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
    TLSRSAWithAES128CBCSHA = "TLS_RSA_WITH_AES_128_CBC_SHA",
    TLSRSAWithAES128CBCSHA256 = "TLS_RSA_WITH_AES_128_CBC_SHA256",
    TLSRSAWithAES128GCMSHA256 = "TLS_RSA_WITH_AES_128_GCM_SHA256",
    TLSRSAWithAES256CBCSHA = "TLS_RSA_WITH_AES_256_CBC_SHA",
    TLSRSAWithAES256CBCSHA256 = "TLS_RSA_WITH_AES_256_CBC_SHA256",
    TLSRSAWithAES256GCMSHA384 = "TLS_RSA_WITH_AES_256_GCM_SHA384"
}

// @public
export enum KnownTriggerTypes {
    HttpTrigger = "HttpTrigger",
    Unknown = "Unknown"
}

// @public
export enum KnownUpgradeAvailability {
    None = "None",
    Ready = "Ready"
}

// @public
export enum KnownUpgradePreference {
    Early = "Early",
    Late = "Late",
    Manual = "Manual",
    None = "None"
}

// @public
export enum KnownValidateResourceTypes {
    MicrosoftWebHostingEnvironments = "Microsoft.Web/hostingEnvironments",
    ServerFarm = "ServerFarm",
    Site = "Site"
}

// @public
export enum KnownWorkflowProvisioningState {
    Accepted = "Accepted",
    Canceled = "Canceled",
    Completed = "Completed",
    Created = "Created",
    Creating = "Creating",
    Deleted = "Deleted",
    Deleting = "Deleting",
    Failed = "Failed",
    InProgress = "InProgress",
    Moving = "Moving",
    NotSpecified = "NotSpecified",
    Pending = "Pending",
    Ready = "Ready",
    Registered = "Registered",
    Registering = "Registering",
    Renewing = "Renewing",
    Running = "Running",
    Succeeded = "Succeeded",
    Unregistered = "Unregistered",
    Unregistering = "Unregistering",
    Updating = "Updating",
    Waiting = "Waiting"
}

// @public
export enum KnownWorkflowSkuName {
    Basic = "Basic",
    Free = "Free",
    NotSpecified = "NotSpecified",
    Premium = "Premium",
    Shared = "Shared",
    Standard = "Standard"
}

// @public
export enum KnownWorkflowState {
    Completed = "Completed",
    Deleted = "Deleted",
    Disabled = "Disabled",
    Enabled = "Enabled",
    NotSpecified = "NotSpecified",
    Suspended = "Suspended"
}

// @public
export enum KnownWorkflowStatus {
    Aborted = "Aborted",
    Cancelled = "Cancelled",
    Failed = "Failed",
    Faulted = "Faulted",
    Ignored = "Ignored",
    NotSpecified = "NotSpecified",
    Paused = "Paused",
    Running = "Running",
    Skipped = "Skipped",
    Succeeded = "Succeeded",
    Suspended = "Suspended",
    TimedOut = "TimedOut",
    Waiting = "Waiting"
}

// @public
export enum KnownWorkflowTriggerProvisioningState {
    Accepted = "Accepted",
    Canceled = "Canceled",
    Completed = "Completed",
    Created = "Created",
    Creating = "Creating",
    Deleted = "Deleted",
    Deleting = "Deleting",
    Failed = "Failed",
    Moving = "Moving",
    NotSpecified = "NotSpecified",
    Ready = "Ready",
    Registered = "Registered",
    Registering = "Registering",
    Running = "Running",
    Succeeded = "Succeeded",
    Unregistered = "Unregistered",
    Unregistering = "Unregistering",
    Updating = "Updating"
}

// @public
export interface KubeEnvironment extends Resource {
    // (undocumented)
    aksResourceID?: string;
    appLogsConfiguration?: AppLogsConfiguration;
    arcConfiguration?: ArcConfiguration;
    containerAppsConfiguration?: ContainerAppsConfiguration;
    readonly defaultDomain?: string;
    readonly deploymentErrors?: string;
    environmentType?: string;
    extendedLocation?: ExtendedLocation;
    internalLoadBalancerEnabled?: boolean;
    readonly provisioningState?: KubeEnvironmentProvisioningState;
    staticIp?: string;
}

// @public
export interface KubeEnvironmentCollection {
    readonly nextLink?: string;
    value: KubeEnvironment[];
}

// @public
export interface KubeEnvironmentPatchResource extends ProxyOnlyResource {
    // (undocumented)
    aksResourceID?: string;
    appLogsConfiguration?: AppLogsConfiguration;
    arcConfiguration?: ArcConfiguration;
    containerAppsConfiguration?: ContainerAppsConfiguration;
    readonly defaultDomain?: string;
    readonly deploymentErrors?: string;
    internalLoadBalancerEnabled?: boolean;
    readonly provisioningState?: KubeEnvironmentProvisioningState;
    staticIp?: string;
}

// @public
export interface KubeEnvironmentProfile {
    id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export type KubeEnvironmentProvisioningState = "Succeeded" | "Failed" | "Canceled" | "Waiting" | "InitializationInProgress" | "InfrastructureSetupInProgress" | "InfrastructureSetupComplete" | "ScheduledForDelete" | "UpgradeRequested" | "UpgradeFailed";

// @public
export interface KubeEnvironments {
    beginCreateOrUpdate(resourceGroupName: string, name: string, kubeEnvironmentEnvelope: KubeEnvironment, options?: KubeEnvironmentsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<KubeEnvironmentsCreateOrUpdateResponse>, KubeEnvironmentsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, name: string, kubeEnvironmentEnvelope: KubeEnvironment, options?: KubeEnvironmentsCreateOrUpdateOptionalParams): Promise<KubeEnvironmentsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, name: string, options?: KubeEnvironmentsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, name: string, options?: KubeEnvironmentsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, options?: KubeEnvironmentsGetOptionalParams): Promise<KubeEnvironmentsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: KubeEnvironmentsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<KubeEnvironment>;
    listBySubscription(options?: KubeEnvironmentsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<KubeEnvironment>;
    update(resourceGroupName: string, name: string, kubeEnvironmentEnvelope: KubeEnvironmentPatchResource, options?: KubeEnvironmentsUpdateOptionalParams): Promise<KubeEnvironmentsUpdateResponse>;
}

// @public
export interface KubeEnvironmentsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type KubeEnvironmentsCreateOrUpdateResponse = KubeEnvironment;

// @public
export interface KubeEnvironmentsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface KubeEnvironmentsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type KubeEnvironmentsGetResponse = KubeEnvironment;

// @public
export interface KubeEnvironmentsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type KubeEnvironmentsListByResourceGroupNextResponse = KubeEnvironmentCollection;

// @public
export interface KubeEnvironmentsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type KubeEnvironmentsListByResourceGroupResponse = KubeEnvironmentCollection;

// @public
export interface KubeEnvironmentsListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type KubeEnvironmentsListBySubscriptionNextResponse = KubeEnvironmentCollection;

// @public
export interface KubeEnvironmentsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type KubeEnvironmentsListBySubscriptionResponse = KubeEnvironmentCollection;

// @public
export interface KubeEnvironmentsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type KubeEnvironmentsUpdateResponse = KubeEnvironment;

// @public
export interface LegacyMicrosoftAccount {
    enabled?: boolean;
    login?: LoginScopes;
    registration?: ClientRegistration;
    validation?: AllowedAudiencesValidation;
}

// @public
export interface LinuxJavaContainerSettings {
    readonly endOfLifeDate?: Date;
    readonly isAutoUpdate?: boolean;
    readonly isDeprecated?: boolean;
    readonly isEarlyAccess?: boolean;
    readonly isHidden?: boolean;
    readonly isPreview?: boolean;
    readonly java11Runtime?: string;
    readonly java8Runtime?: string;
}

// @public
export interface ListAseRegionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListAseRegionsNextResponse = AseRegionCollection;

// @public
export interface ListAseRegionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListAseRegionsResponse = AseRegionCollection;

// @public
export interface ListBillingMetersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListBillingMetersNextResponse = BillingMeterCollection;

// @public
export interface ListBillingMetersOptionalParams extends coreClient.OperationOptions {
    billingLocation?: string;
    osType?: string;
}

// @public
export type ListBillingMetersResponse = BillingMeterCollection;

// @public
export interface ListCustomHostNameSitesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListCustomHostNameSitesNextResponse = CustomHostnameSitesCollection;

// @public
export interface ListCustomHostNameSitesOptionalParams extends coreClient.OperationOptions {
    hostname?: string;
}

// @public
export type ListCustomHostNameSitesResponse = CustomHostnameSitesCollection;

// @public
export interface ListGeoRegionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListGeoRegionsNextResponse = GeoRegionCollection;

// @public
export interface ListGeoRegionsOptionalParams extends coreClient.OperationOptions {
    linuxDynamicWorkersEnabled?: boolean;
    linuxWorkersEnabled?: boolean;
    sku?: SkuName;
    xenonWorkersEnabled?: boolean;
}

// @public
export type ListGeoRegionsResponse = GeoRegionCollection;

// @public
export interface ListPremierAddOnOffersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListPremierAddOnOffersNextResponse = PremierAddOnOfferCollection;

// @public
export interface ListPremierAddOnOffersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListPremierAddOnOffersResponse = PremierAddOnOfferCollection;

// @public
export interface ListSiteIdentifiersAssignedToHostNameNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListSiteIdentifiersAssignedToHostNameNextResponse = IdentifierCollection;

// @public
export interface ListSiteIdentifiersAssignedToHostNameOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListSiteIdentifiersAssignedToHostNameResponse = IdentifierCollection;

// @public
export interface ListSkusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListSkusResponse = SkuInfos;

// @public
export interface ListSourceControlsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListSourceControlsNextResponse = SourceControlCollection;

// @public
export interface ListSourceControlsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ListSourceControlsResponse = SourceControlCollection;

// @public
export type LoadBalancingMode = string;

// @public
export interface LocalizableString {
    localizedValue?: string;
    value?: string;
}

// @public (undocumented)
export interface LogAnalyticsConfiguration {
    // (undocumented)
    customerId?: string;
    // (undocumented)
    sharedKey?: string;
}

// @public
export interface Login {
    allowedExternalRedirectUrls?: string[];
    cookieExpiration?: CookieExpiration;
    nonce?: Nonce;
    preserveUrlFragmentsForLogins?: boolean;
    routes?: LoginRoutes;
    tokenStore?: TokenStore;
}

// @public
export interface LoginRoutes {
    logoutEndpoint?: string;
}

// @public
export interface LoginScopes {
    scopes?: string[];
}

// @public
export type LogLevel = "Off" | "Verbose" | "Information" | "Warning" | "Error";

// @public
export interface LogSpecification {
    // (undocumented)
    blobDuration?: string;
    // (undocumented)
    displayName?: string;
    // (undocumented)
    logFilterPattern?: string;
    // (undocumented)
    name?: string;
}

// @public
export type ManagedPipelineMode = "Integrated" | "Classic";

// @public
export interface ManagedServiceIdentity {
    readonly principalId?: string;
    readonly tenantId?: string;
    type?: ManagedServiceIdentityType;
    userAssignedIdentities?: {
        [propertyName: string]: UserAssignedIdentity;
    };
}

// @public
export type ManagedServiceIdentityType = "SystemAssigned" | "UserAssigned" | "SystemAssigned, UserAssigned" | "None";

// @public
export interface MetricAvailability {
    // (undocumented)
    blobDuration?: string;
    // (undocumented)
    timeGrain?: string;
}

// @public
export interface MetricSpecification {
    // (undocumented)
    aggregationType?: string;
    // (undocumented)
    availabilities?: MetricAvailability[];
    // (undocumented)
    category?: string;
    // (undocumented)
    dimensions?: Dimension[];
    // (undocumented)
    displayDescription?: string;
    // (undocumented)
    displayName?: string;
    // (undocumented)
    enableRegionalMdmAccount?: boolean;
    // (undocumented)
    fillGapWithZero?: boolean;
    // (undocumented)
    isInternal?: boolean;
    // (undocumented)
    metricFilterPattern?: string;
    // (undocumented)
    name?: string;
    // (undocumented)
    sourceMdmAccount?: string;
    // (undocumented)
    sourceMdmNamespace?: string;
    // (undocumented)
    supportedAggregationTypes?: string[];
    // (undocumented)
    supportedTimeGrainTypes?: string[];
    // (undocumented)
    supportsInstanceLevelAggregation?: boolean;
    // (undocumented)
    unit?: string;
}

// @public
export interface MigrateMySqlRequest extends ProxyOnlyResource {
    connectionString?: string;
    migrationType?: MySqlMigrationType;
}

// @public
export interface MigrateMySqlStatus extends ProxyOnlyResource {
    readonly localMySqlEnabled?: boolean;
    readonly migrationOperationStatus?: OperationStatus;
    readonly operationId?: string;
}

// @public
export interface MoveOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface MSDeploy extends ProxyOnlyResource {
    appOffline?: boolean;
    connectionString?: string;
    dbType?: string;
    packageUri?: string;
    setParameters?: {
        [propertyName: string]: string;
    };
    setParametersXmlFileUri?: string;
    skipAppData?: boolean;
}

// @public
export interface MSDeployLog extends ProxyOnlyResource {
    readonly entries?: MSDeployLogEntry[];
}

// @public
export interface MSDeployLogEntry {
    readonly message?: string;
    readonly time?: Date;
    readonly type?: MSDeployLogEntryType;
}

// @public
export type MSDeployLogEntryType = "Message" | "Warning" | "Error";

// @public
export type MSDeployProvisioningState = "accepted" | "running" | "succeeded" | "failed" | "canceled";

// @public
export interface MSDeployStatus extends ProxyOnlyResource {
    readonly complete?: boolean;
    readonly deployer?: string;
    readonly endTime?: Date;
    readonly provisioningState?: MSDeployProvisioningState;
    readonly startTime?: Date;
}

// @public
export type MySqlMigrationType = "LocalToRemote" | "RemoteToLocal";

// @public
export interface NameIdentifier {
    name?: string;
}

// @public
export interface NameIdentifierCollection {
    readonly nextLink?: string;
    value: NameIdentifier[];
}

// @public
export interface NameValuePair {
    name?: string;
    value?: string;
}

// @public
export interface NetworkFeatures extends ProxyOnlyResource {
    readonly hybridConnections?: RelayServiceConnectionEntity[];
    readonly hybridConnectionsV2?: HybridConnection[];
    readonly virtualNetworkConnection?: VnetInfo;
    readonly virtualNetworkName?: string;
}

// @public
export interface NetworkTrace {
    message?: string;
    path?: string;
    status?: string;
}

// @public
export interface Nonce {
    nonceExpirationInterval?: string;
    validateNonce?: boolean;
}

// @public
export type NotificationLevel = "Critical" | "Warning" | "Information" | "NonUrgentSuggestion";

// @public
export interface OpenAuthenticationAccessPolicies {
    policies?: {
        [propertyName: string]: OpenAuthenticationAccessPolicy;
    };
}

// @public
export interface OpenAuthenticationAccessPolicy {
    claims?: OpenAuthenticationPolicyClaim[];
    type?: OpenAuthenticationProviderType;
}

// @public
export interface OpenAuthenticationPolicyClaim {
    name?: string;
    value?: string;
}

// @public
export type OpenAuthenticationProviderType = string;

// @public
export interface OpenIdConnectClientCredential {
    clientSecretSettingName?: string;
    method?: "ClientSecretPost";
}

// @public
export interface OpenIdConnectConfig {
    authorizationEndpoint?: string;
    certificationUri?: string;
    issuer?: string;
    tokenEndpoint?: string;
    wellKnownOpenIdConfiguration?: string;
}

// @public
export interface OpenIdConnectLogin {
    nameClaimType?: string;
    scopes?: string[];
}

// @public
export interface OpenIdConnectRegistration {
    clientCredential?: OpenIdConnectClientCredential;
    clientId?: string;
    openIdConnectConfiguration?: OpenIdConnectConfig;
}

// @public
export interface Operation {
    createdTime?: Date;
    errors?: ErrorEntity[];
    expirationTime?: Date;
    geoMasterOperationId?: string;
    id?: string;
    modifiedTime?: Date;
    name?: string;
    status?: OperationStatus;
}

// @public
export interface OperationResult extends OperationResultProperties {
    readonly inputs?: Record<string, unknown>;
    readonly inputsLink?: ContentLink;
    // (undocumented)
    iterationCount?: number;
    readonly outputs?: Record<string, unknown>;
    readonly outputsLink?: ContentLink;
    retryHistory?: RetryHistory[];
    readonly trackedProperties?: Record<string, unknown>;
    readonly trackingId?: string;
}

// @public
export interface OperationResultProperties {
    code?: string;
    correlation?: RunActionCorrelation;
    endTime?: Date;
    error?: any;
    startTime?: Date;
    status?: WorkflowStatus;
}

// @public
export type OperationStatus = "InProgress" | "Failed" | "Succeeded" | "TimedOut" | "Created";

// @public
export interface OutboundEnvironmentEndpoint {
    category?: string;
    endpoints?: EndpointDependency[];
}

// @public
export interface OutboundEnvironmentEndpointCollection {
    readonly nextLink?: string;
    value: OutboundEnvironmentEndpoint[];
}

// @public
export type ParameterType = string;

// @public
export interface PerfMonCounterCollection {
    readonly nextLink?: string;
    value: PerfMonResponse[];
}

// @public
export interface PerfMonResponse {
    code?: string;
    data?: PerfMonSet;
    message?: string;
}

// @public
export interface PerfMonSample {
    instanceName?: string;
    time?: Date;
    value?: number;
}

// @public
export interface PerfMonSet {
    endTime?: Date;
    name?: string;
    startTime?: Date;
    timeGrain?: string;
    values?: PerfMonSample[];
}

// @public
export interface PremierAddOn extends Resource {
    marketplaceOffer?: string;
    marketplacePublisher?: string;
    product?: string;
    sku?: string;
    vendor?: string;
}

// @public
export interface PremierAddOnOffer extends ProxyOnlyResource {
    legalTermsUrl?: string;
    marketplaceOffer?: string;
    marketplacePublisher?: string;
    privacyPolicyUrl?: string;
    product?: string;
    promoCodeRequired?: boolean;
    quota?: number;
    sku?: string;
    vendor?: string;
    webHostingPlanRestrictions?: AppServicePlanRestrictions;
}

// @public
export interface PremierAddOnOfferCollection {
    readonly nextLink?: string;
    value: PremierAddOnOffer[];
}

// @public
export interface PremierAddOnPatchResource extends ProxyOnlyResource {
    marketplaceOffer?: string;
    marketplacePublisher?: string;
    product?: string;
    sku?: string;
    vendor?: string;
}

// @public
export interface PrivateAccess extends ProxyOnlyResource {
    enabled?: boolean;
    virtualNetworks?: PrivateAccessVirtualNetwork[];
}

// @public
export interface PrivateAccessSubnet {
    key?: number;
    name?: string;
}

// @public
export interface PrivateAccessVirtualNetwork {
    key?: number;
    name?: string;
    resourceId?: string;
    subnets?: PrivateAccessSubnet[];
}

// @public (undocumented)
export interface PrivateEndpointConnectionCollection {
    readonly nextLink?: string;
    value: RemotePrivateEndpointConnectionARMResource[];
}

// @public
export interface PrivateLinkConnectionApprovalRequestResource extends ProxyOnlyResource {
    privateLinkServiceConnectionState?: PrivateLinkConnectionState;
}

// @public
export interface PrivateLinkConnectionState {
    actionsRequired?: string;
    description?: string;
    status?: string;
}

// @public
export interface PrivateLinkResource {
    // (undocumented)
    id: string;
    name: string;
    properties: PrivateLinkResourceProperties;
    // (undocumented)
    type: string;
}

// @public
export interface PrivateLinkResourceProperties {
    readonly groupId?: string;
    readonly requiredMembers?: string[];
    readonly requiredZoneNames?: string[];
}

// @public
export interface PrivateLinkResourcesWrapper {
    // (undocumented)
    value: PrivateLinkResource[];
}

// @public
export interface ProcessInfo extends ProxyOnlyResource {
    children?: string[];
    commandLine?: string;
    deploymentName?: string;
    description?: string;
    environmentVariables?: {
        [propertyName: string]: string;
    };
    fileName?: string;
    handleCount?: number;
    href?: string;
    readonly identifier?: number;
    iisProfileTimeoutInSeconds?: number;
    isIisProfileRunning?: boolean;
    isProfileRunning?: boolean;
    isScmSite?: boolean;
    isWebjob?: boolean;
    minidump?: string;
    moduleCount?: number;
    modules?: ProcessModuleInfo[];
    nonPagedSystemMemory?: number;
    openFileHandles?: string[];
    pagedMemory?: number;
    pagedSystemMemory?: number;
    parent?: string;
    peakPagedMemory?: number;
    peakVirtualMemory?: number;
    peakWorkingSet?: number;
    privateMemory?: number;
    privilegedCpuTime?: string;
    startTime?: Date;
    threadCount?: number;
    threads?: ProcessThreadInfo[];
    timeStamp?: Date;
    totalCpuTime?: string;
    userCpuTime?: string;
    userName?: string;
    virtualMemory?: number;
    workingSet?: number;
}

// @public
export interface ProcessInfoCollection {
    readonly nextLink?: string;
    value: ProcessInfo[];
}

// @public
export interface ProcessModuleInfo extends ProxyOnlyResource {
    baseAddress?: string;
    fileDescription?: string;
    fileName?: string;
    filePath?: string;
    fileVersion?: string;
    href?: string;
    isDebug?: boolean;
    language?: string;
    moduleMemorySize?: number;
    product?: string;
    productVersion?: string;
}

// @public
export interface ProcessModuleInfoCollection {
    readonly nextLink?: string;
    value: ProcessModuleInfo[];
}

// @public
export interface ProcessThreadInfo extends ProxyOnlyResource {
    basePriority?: number;
    currentPriority?: number;
    href?: string;
    readonly identifier?: number;
    priorityLevel?: string;
    process?: string;
    startAddress?: string;
    startTime?: Date;
    state?: string;
    totalProcessorTime?: string;
    userProcessorTime?: string;
    waitReason?: string;
}

// @public
export interface ProcessThreadInfoCollection {
    readonly nextLink?: string;
    value: ProcessThreadInfo[];
}

// @public
export interface Provider {
    listAvailableStacks(options?: ProviderGetAvailableStacksOptionalParams): PagedAsyncIterableIterator<ApplicationStackResource>;
    listAvailableStacksOnPrem(options?: ProviderGetAvailableStacksOnPremOptionalParams): PagedAsyncIterableIterator<ApplicationStackResource>;
    listFunctionAppStacks(options?: ProviderGetFunctionAppStacksOptionalParams): PagedAsyncIterableIterator<FunctionAppStack>;
    listFunctionAppStacksForLocation(location: string, options?: ProviderGetFunctionAppStacksForLocationOptionalParams): PagedAsyncIterableIterator<FunctionAppStack>;
    listOperations(options?: ProviderListOperationsOptionalParams): PagedAsyncIterableIterator<CsmOperationDescription>;
    listWebAppStacks(options?: ProviderGetWebAppStacksOptionalParams): PagedAsyncIterableIterator<WebAppStack>;
    listWebAppStacksForLocation(location: string, options?: ProviderGetWebAppStacksForLocationOptionalParams): PagedAsyncIterableIterator<WebAppStack>;
}

// @public
export interface ProviderGetAvailableStacksNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderGetAvailableStacksNextResponse = ApplicationStackCollection;

// @public
export interface ProviderGetAvailableStacksOnPremNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderGetAvailableStacksOnPremNextResponse = ApplicationStackCollection;

// @public
export interface ProviderGetAvailableStacksOnPremOptionalParams extends coreClient.OperationOptions {
    // (undocumented)
    osTypeSelected?: ProviderOsTypeSelected;
}

// @public
export type ProviderGetAvailableStacksOnPremResponse = ApplicationStackCollection;

// @public
export interface ProviderGetAvailableStacksOptionalParams extends coreClient.OperationOptions {
    // (undocumented)
    osTypeSelected?: ProviderOsTypeSelected;
}

// @public
export type ProviderGetAvailableStacksResponse = ApplicationStackCollection;

// @public
export interface ProviderGetFunctionAppStacksForLocationNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderGetFunctionAppStacksForLocationNextResponse = FunctionAppStackCollection;

// @public
export interface ProviderGetFunctionAppStacksForLocationOptionalParams extends coreClient.OperationOptions {
    stackOsType?: ProviderStackOsType;
}

// @public
export type ProviderGetFunctionAppStacksForLocationResponse = FunctionAppStackCollection;

// @public
export interface ProviderGetFunctionAppStacksNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderGetFunctionAppStacksNextResponse = FunctionAppStackCollection;

// @public
export interface ProviderGetFunctionAppStacksOptionalParams extends coreClient.OperationOptions {
    stackOsType?: ProviderStackOsType;
}

// @public
export type ProviderGetFunctionAppStacksResponse = FunctionAppStackCollection;

// @public
export interface ProviderGetWebAppStacksForLocationNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderGetWebAppStacksForLocationNextResponse = WebAppStackCollection;

// @public
export interface ProviderGetWebAppStacksForLocationOptionalParams extends coreClient.OperationOptions {
    stackOsType?: ProviderStackOsType;
}

// @public
export type ProviderGetWebAppStacksForLocationResponse = WebAppStackCollection;

// @public
export interface ProviderGetWebAppStacksNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderGetWebAppStacksNextResponse = WebAppStackCollection;

// @public
export interface ProviderGetWebAppStacksOptionalParams extends coreClient.OperationOptions {
    stackOsType?: ProviderStackOsType;
}

// @public
export type ProviderGetWebAppStacksResponse = WebAppStackCollection;

// @public
export interface ProviderListOperationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderListOperationsNextResponse = CsmOperationCollection;

// @public
export interface ProviderListOperationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProviderListOperationsResponse = CsmOperationCollection;

// @public
export type ProviderOsTypeSelected = string;

// @public
export type ProviderStackOsType = string;

// @public
export type ProvisioningState = "Succeeded" | "Failed" | "Canceled" | "InProgress" | "Deleting";

// @public
export interface ProxyOnlyResource {
    readonly id?: string;
    kind?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export interface PublicCertificate extends ProxyOnlyResource {
    blob?: Uint8Array;
    publicCertificateLocation?: PublicCertificateLocation;
    readonly thumbprint?: string;
}

// @public
export interface PublicCertificateCollection {
    readonly nextLink?: string;
    value: PublicCertificate[];
}

// @public
export type PublicCertificateLocation = "CurrentUserMy" | "LocalMachineMy" | "Unknown";

// @public
export interface PublishingCredentialsPoliciesCollection {
    readonly nextLink?: string;
    value: CsmPublishingCredentialsPoliciesEntity[];
}

// @public
export type PublishingProfileFormat = string;

// @public
export interface PushSettings extends ProxyOnlyResource {
    dynamicTagsJson?: string;
    isPushEnabled?: boolean;
    tagsRequiringAuth?: string;
    tagWhitelistJson?: string;
}

// @public
export interface QueryUtterancesResult {
    sampleUtterance?: SampleUtterance;
    score?: number;
}

// @public
export interface QueryUtterancesResults {
    query?: string;
    results?: QueryUtterancesResult[];
}

// @public
export interface QueueScaleRule {
    auth?: ScaleRuleAuth[];
    queueLength?: number;
    queueName?: string;
}

// @public
export interface RampUpRule {
    actionHostName?: string;
    changeDecisionCallbackUrl?: string;
    changeIntervalInMinutes?: number;
    changeStep?: number;
    maxReroutePercentage?: number;
    minReroutePercentage?: number;
    name?: string;
    reroutePercentage?: number;
}

// @public
export interface Recommendation extends ProxyOnlyResource {
    actionName?: string;
    bladeName?: string;
    readonly categoryTags?: string[];
    channels?: Channels;
    creationTime?: Date;
    displayName?: string;
    enabled?: number;
    endTime?: Date;
    extensionName?: string;
    forwardLink?: string;
    isDynamic?: boolean;
    level?: NotificationLevel;
    message?: string;
    nextNotificationTime?: Date;
    notificationExpirationTime?: Date;
    notifiedTime?: Date;
    recommendationId?: string;
    resourceId?: string;
    resourceScope?: ResourceScopeType;
    ruleName?: string;
    score?: number;
    startTime?: Date;
    states?: string[];
}

// @public
export interface RecommendationCollection {
    readonly nextLink?: string;
    value: Recommendation[];
}

// @public
export interface RecommendationRule extends ProxyOnlyResource {
    actionName?: string;
    bladeName?: string;
    readonly categoryTags?: string[];
    channels?: Channels;
    description?: string;
    displayName?: string;
    extensionName?: string;
    forwardLink?: string;
    isDynamic?: boolean;
    level?: NotificationLevel;
    message?: string;
    recommendationId?: string;
    recommendationName?: string;
}

// @public
export interface Recommendations {
    disableAllForHostingEnvironment(resourceGroupName: string, environmentName: string, hostingEnvironmentName: string, options?: RecommendationsDisableAllForHostingEnvironmentOptionalParams): Promise<void>;
    disableAllForWebApp(resourceGroupName: string, siteName: string, options?: RecommendationsDisableAllForWebAppOptionalParams): Promise<void>;
    disableRecommendationForHostingEnvironment(resourceGroupName: string, environmentName: string, name: string, hostingEnvironmentName: string, options?: RecommendationsDisableRecommendationForHostingEnvironmentOptionalParams): Promise<void>;
    disableRecommendationForSite(resourceGroupName: string, siteName: string, name: string, options?: RecommendationsDisableRecommendationForSiteOptionalParams): Promise<void>;
    disableRecommendationForSubscription(name: string, options?: RecommendationsDisableRecommendationForSubscriptionOptionalParams): Promise<void>;
    getRuleDetailsByHostingEnvironment(resourceGroupName: string, hostingEnvironmentName: string, name: string, options?: RecommendationsGetRuleDetailsByHostingEnvironmentOptionalParams): Promise<RecommendationsGetRuleDetailsByHostingEnvironmentResponse>;
    getRuleDetailsByWebApp(resourceGroupName: string, siteName: string, name: string, options?: RecommendationsGetRuleDetailsByWebAppOptionalParams): Promise<RecommendationsGetRuleDetailsByWebAppResponse>;
    list(options?: RecommendationsListOptionalParams): PagedAsyncIterableIterator<Recommendation>;
    listHistoryForHostingEnvironment(resourceGroupName: string, hostingEnvironmentName: string, options?: RecommendationsListHistoryForHostingEnvironmentOptionalParams): PagedAsyncIterableIterator<Recommendation>;
    listHistoryForWebApp(resourceGroupName: string, siteName: string, options?: RecommendationsListHistoryForWebAppOptionalParams): PagedAsyncIterableIterator<Recommendation>;
    listRecommendedRulesForHostingEnvironment(resourceGroupName: string, hostingEnvironmentName: string, options?: RecommendationsListRecommendedRulesForHostingEnvironmentOptionalParams): PagedAsyncIterableIterator<Recommendation>;
    listRecommendedRulesForWebApp(resourceGroupName: string, siteName: string, options?: RecommendationsListRecommendedRulesForWebAppOptionalParams): PagedAsyncIterableIterator<Recommendation>;
    resetAllFilters(options?: RecommendationsResetAllFiltersOptionalParams): Promise<void>;
    resetAllFiltersForHostingEnvironment(resourceGroupName: string, environmentName: string, hostingEnvironmentName: string, options?: RecommendationsResetAllFiltersForHostingEnvironmentOptionalParams): Promise<void>;
    resetAllFiltersForWebApp(resourceGroupName: string, siteName: string, options?: RecommendationsResetAllFiltersForWebAppOptionalParams): Promise<void>;
}

// @public
export interface RecommendationsDisableAllForHostingEnvironmentOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsDisableAllForWebAppOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsDisableRecommendationForHostingEnvironmentOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsDisableRecommendationForSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsDisableRecommendationForSubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsGetRuleDetailsByHostingEnvironmentOptionalParams extends coreClient.OperationOptions {
    recommendationId?: string;
    updateSeen?: boolean;
}

// @public
export type RecommendationsGetRuleDetailsByHostingEnvironmentResponse = RecommendationRule;

// @public
export interface RecommendationsGetRuleDetailsByWebAppOptionalParams extends coreClient.OperationOptions {
    recommendationId?: string;
    updateSeen?: boolean;
}

// @public
export type RecommendationsGetRuleDetailsByWebAppResponse = RecommendationRule;

// @public
export interface RecommendationsListHistoryForHostingEnvironmentNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecommendationsListHistoryForHostingEnvironmentNextResponse = RecommendationCollection;

// @public
export interface RecommendationsListHistoryForHostingEnvironmentOptionalParams extends coreClient.OperationOptions {
    expiredOnly?: boolean;
    filter?: string;
}

// @public
export type RecommendationsListHistoryForHostingEnvironmentResponse = RecommendationCollection;

// @public
export interface RecommendationsListHistoryForWebAppNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecommendationsListHistoryForWebAppNextResponse = RecommendationCollection;

// @public
export interface RecommendationsListHistoryForWebAppOptionalParams extends coreClient.OperationOptions {
    expiredOnly?: boolean;
    filter?: string;
}

// @public
export type RecommendationsListHistoryForWebAppResponse = RecommendationCollection;

// @public
export interface RecommendationsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecommendationsListNextResponse = RecommendationCollection;

// @public
export interface RecommendationsListOptionalParams extends coreClient.OperationOptions {
    featured?: boolean;
    filter?: string;
}

// @public
export interface RecommendationsListRecommendedRulesForHostingEnvironmentNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecommendationsListRecommendedRulesForHostingEnvironmentNextResponse = RecommendationCollection;

// @public
export interface RecommendationsListRecommendedRulesForHostingEnvironmentOptionalParams extends coreClient.OperationOptions {
    featured?: boolean;
    filter?: string;
}

// @public
export type RecommendationsListRecommendedRulesForHostingEnvironmentResponse = RecommendationCollection;

// @public
export interface RecommendationsListRecommendedRulesForWebAppNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecommendationsListRecommendedRulesForWebAppNextResponse = RecommendationCollection;

// @public
export interface RecommendationsListRecommendedRulesForWebAppOptionalParams extends coreClient.OperationOptions {
    featured?: boolean;
    filter?: string;
}

// @public
export type RecommendationsListRecommendedRulesForWebAppResponse = RecommendationCollection;

// @public
export type RecommendationsListResponse = RecommendationCollection;

// @public
export interface RecommendationsResetAllFiltersForHostingEnvironmentOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsResetAllFiltersForWebAppOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RecommendationsResetAllFiltersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecurrenceFrequency = string;

// @public
export interface RecurrenceSchedule {
    hours?: number[];
    minutes?: number[];
    monthDays?: number[];
    monthlyOccurrences?: RecurrenceScheduleOccurrence[];
    weekDays?: DaysOfWeek[];
}

// @public
export interface RecurrenceScheduleOccurrence {
    day?: DayOfWeek;
    occurrence?: number;
}

// @public
export type RedundancyMode = "None" | "Manual" | "Failover" | "ActiveActive" | "GeoRedundant";

// @public
export interface RegenerateActionParameter {
    keyType?: KeyType_2;
}

// @public
export interface RegistryCredentials {
    passwordSecretRef?: string;
    server?: string;
    username?: string;
}

// @public
export interface ReissueCertificateOrderRequest extends ProxyOnlyResource {
    csr?: string;
    delayExistingRevokeInHours?: number;
    isPrivateKeyExternal?: boolean;
    keySize?: number;
}

// @public
export interface RelayServiceConnectionEntity extends ProxyOnlyResource {
    // (undocumented)
    biztalkUri?: string;
    // (undocumented)
    entityConnectionString?: string;
    // (undocumented)
    entityName?: string;
    // (undocumented)
    hostname?: string;
    // (undocumented)
    port?: number;
    // (undocumented)
    resourceConnectionString?: string;
    // (undocumented)
    resourceType?: string;
}

// @public
export interface RemotePrivateEndpointConnection extends ProxyOnlyResource {
    ipAddresses?: string[];
    privateEndpoint?: ArmIdWrapper;
    privateLinkServiceConnectionState?: PrivateLinkConnectionState;
    readonly provisioningState?: string;
}

// @public
export interface RemotePrivateEndpointConnectionARMResource extends ProxyOnlyResource {
    ipAddresses?: string[];
    privateEndpoint?: ArmIdWrapper;
    privateLinkServiceConnectionState?: PrivateLinkConnectionState;
    readonly provisioningState?: string;
}

// @public
export interface Rendering {
    description?: string;
    title?: string;
    type?: RenderingType;
}

// @public
export type RenderingType = "NoGraph" | "Table" | "TimeSeries" | "TimeSeriesPerInstance" | "PieChart" | "DataSummary" | "Email" | "Insights" | "DynamicInsight" | "Markdown" | "Detector" | "DropDown" | "Card" | "Solution" | "Guage" | "Form" | "ChangeSets" | "ChangeAnalysisOnboarding" | "ChangesView" | "AppInsight" | "DependencyGraph" | "DownTime" | "SummaryCard" | "SearchComponent" | "AppInsightEnablement";

// @public
export interface RenewCertificateOrderRequest extends ProxyOnlyResource {
    csr?: string;
    isPrivateKeyExternal?: boolean;
    keySize?: number;
}

// @public
export interface RepetitionIndex {
    itemIndex: number;
    scopeName?: string;
}

// @public
interface Request_2 {
    headers?: Record<string, unknown>;
    method?: string;
    uri?: string;
}
export { Request_2 as Request }

// @public
export interface RequestHistory extends WorkflowResource {
    properties?: RequestHistoryProperties;
}

// @public
export interface RequestHistoryListResult {
    nextLink?: string;
    value?: RequestHistory[];
}

// @public
export interface RequestHistoryProperties {
    endTime?: Date;
    request?: Request_2;
    response?: Response_2;
    startTime?: Date;
}

// @public
export interface RequestsBasedTrigger {
    count?: number;
    timeInterval?: string;
}

// @public
export type ResolveStatus = "Initialized" | "Resolved" | "InvalidSyntax" | "MSINotEnabled" | "VaultNotFound" | "SecretNotFound" | "SecretVersionNotFound" | "AccessToKeyVaultDenied" | "OtherReasons" | "FetchTimedOut" | "UnauthorizedClient";

// @public
export interface Resource {
    readonly id?: string;
    kind?: string;
    location: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface ResourceCollection {
    readonly nextLink?: string;
    value: string[];
}

// @public
export interface ResourceConfig {
    cpu?: number;
    memory?: string;
}

// @public
export interface ResourceHealthMetadata extends ProxyOnlyResource {
    category?: string;
    signalAvailability?: boolean;
}

// @public
export interface ResourceHealthMetadataCollection {
    readonly nextLink?: string;
    value: ResourceHealthMetadata[];
}

// @public
export interface ResourceHealthMetadataGetBySiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataGetBySiteResponse = ResourceHealthMetadata;

// @public
export interface ResourceHealthMetadataGetBySiteSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataGetBySiteSlotResponse = ResourceHealthMetadata;

// @public
export interface ResourceHealthMetadataListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListByResourceGroupNextResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListByResourceGroupResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListBySiteNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListBySiteNextResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListBySiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListBySiteResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListBySiteSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListBySiteSlotNextResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListBySiteSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListBySiteSlotResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListNextResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ResourceHealthMetadataListResponse = ResourceHealthMetadataCollection;

// @public
export interface ResourceHealthMetadataOperations {
    getBySite(resourceGroupName: string, name: string, options?: ResourceHealthMetadataGetBySiteOptionalParams): Promise<ResourceHealthMetadataGetBySiteResponse>;
    getBySiteSlot(resourceGroupName: string, name: string, slot: string, options?: ResourceHealthMetadataGetBySiteSlotOptionalParams): Promise<ResourceHealthMetadataGetBySiteSlotResponse>;
    list(options?: ResourceHealthMetadataListOptionalParams): PagedAsyncIterableIterator<ResourceHealthMetadata>;
    listByResourceGroup(resourceGroupName: string, options?: ResourceHealthMetadataListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ResourceHealthMetadata>;
    listBySite(resourceGroupName: string, name: string, options?: ResourceHealthMetadataListBySiteOptionalParams): PagedAsyncIterableIterator<ResourceHealthMetadata>;
    listBySiteSlot(resourceGroupName: string, name: string, slot: string, options?: ResourceHealthMetadataListBySiteSlotOptionalParams): PagedAsyncIterableIterator<ResourceHealthMetadata>;
}

// @public
export interface ResourceMetricAvailability {
    readonly retention?: string;
    readonly timeGrain?: string;
}

// @public
export interface ResourceMetricDefinition extends ProxyOnlyResource {
    readonly metricAvailabilities?: ResourceMetricAvailability[];
    readonly primaryAggregationType?: string;
    readonly properties?: {
        [propertyName: string]: string;
    };
    readonly resourceUri?: string;
    readonly unit?: string;
}

// @public
export interface ResourceMetricDefinitionCollection {
    readonly nextLink?: string;
    value: ResourceMetricDefinition[];
}

// @public
export interface ResourceNameAvailability {
    message?: string;
    nameAvailable?: boolean;
    reason?: InAvailabilityReasonType;
}

// @public
export interface ResourceNameAvailabilityRequest {
    environmentId?: string;
    isFqdn?: boolean;
    name: string;
    type: CheckNameResourceTypes;
}

// @public
export type ResourceNotRenewableReason = string;

// @public
export interface ResourceReference {
    id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export type ResourceScopeType = string;

// @public
interface Response_2 {
    bodyLink?: ContentLink;
    headers?: Record<string, unknown>;
    statusCode?: number;
}
export { Response_2 as Response }

// @public
export interface ResponseMessageEnvelopeRemotePrivateEndpointConnection {
    error?: ErrorEntity;
    id?: string;
    identity?: ManagedServiceIdentity;
    location?: string;
    name?: string;
    plan?: ArmPlan;
    properties?: RemotePrivateEndpointConnection;
    sku?: SkuDescription;
    status?: string;
    tags?: {
        [propertyName: string]: string;
    };
    type?: string;
    zones?: string[];
}

// @public (undocumented)
export interface ResponseMetaData {
    dataSource?: DataSource;
}

// @public
export interface RestoreRequest extends ProxyOnlyResource {
    adjustConnectionStrings?: boolean;
    appServicePlan?: string;
    blobName?: string;
    databases?: DatabaseBackupSetting[];
    hostingEnvironment?: string;
    ignoreConflictingHostNames?: boolean;
    ignoreDatabases?: boolean;
    operationType?: BackupRestoreOperationType;
    overwrite?: boolean;
    siteName?: string;
    storageAccountUrl?: string;
}

// @public
export interface RetryHistory {
    clientRequestId?: string;
    code?: string;
    endTime?: Date;
    error?: ErrorResponse;
    serviceRequestId?: string;
    startTime?: Date;
}

// @public
export interface Revision extends Resource {
    readonly active?: boolean;
    readonly createdTime?: Date;
    readonly fqdn?: string;
    readonly healthState?: RevisionHealthState;
    readonly provisioningError?: string;
    readonly provisioningState?: RevisionProvisioningState;
    readonly replicas?: number;
    readonly template?: Template;
    readonly trafficWeight?: number;
}

// @public
export interface RevisionCollection {
    readonly nextLink?: string;
    value: Revision[];
}

// @public
export type RevisionHealthState = string;

// @public
export type RevisionProvisioningState = string;

// @public
export type RouteType = string;

// @public
export interface RunActionCorrelation extends RunCorrelation {
    actionTrackingId?: string;
}

// @public
export interface RunCorrelation {
    clientKeywords?: string[];
    clientTrackingId?: string;
}

// @public
export type RuntimeName = string;

// @public
export interface SampleUtterance {
    links?: string[];
    qid?: string;
    text?: string;
}

// @public
export interface Scale {
    maxReplicas?: number;
    minReplicas?: number;
    rules?: ScaleRule[];
}

// @public
export interface ScaleRule {
    azureQueue?: QueueScaleRule;
    custom?: CustomScaleRule;
    http?: HttpScaleRule;
    name?: string;
}

// @public
export interface ScaleRuleAuth {
    secretRef?: string;
    triggerParameter?: string;
}

// @public
export type ScmType = string;

// @public
export interface Secret {
    name?: string;
    value?: string;
}

// @public
export interface SecretsCollection {
    value: ContainerAppSecret[];
}

// @public
export interface ServiceSpecification {
    // (undocumented)
    logSpecifications?: LogSpecification[];
    // (undocumented)
    metricSpecifications?: MetricSpecification[];
}

// @public
export interface Site extends Resource {
    readonly availabilityState?: SiteAvailabilityState;
    clientAffinityEnabled?: boolean;
    clientCertEnabled?: boolean;
    clientCertExclusionPaths?: string;
    clientCertMode?: ClientCertMode;
    cloningInfo?: CloningInfo;
    containerSize?: number;
    customDomainVerificationId?: string;
    dailyMemoryTimeQuota?: number;
    daprConfig?: DaprConfig;
    readonly defaultHostName?: string;
    dnsConfiguration?: SiteDnsConfig;
    enabled?: boolean;
    readonly enabledHostNames?: string[];
    extendedLocation?: ExtendedLocation;
    functionAppConfig?: FunctionAppConfig;
    hostingEnvironmentProfile?: HostingEnvironmentProfile;
    readonly hostNames?: string[];
    hostNamesDisabled?: boolean;
    hostNameSslStates?: HostNameSslState[];
    httpsOnly?: boolean;
    hyperV?: boolean;
    identity?: ManagedServiceIdentity;
    readonly inProgressOperationId?: string;
    readonly isDefaultContainer?: boolean;
    isXenon?: boolean;
    keyVaultReferenceIdentity?: string;
    readonly lastModifiedTimeUtc?: Date;
    managedEnvironmentId?: string;
    readonly maxNumberOfWorkers?: number;
    readonly outboundIpAddresses?: string;
    readonly possibleOutboundIpAddresses?: string;
    publicNetworkAccess?: string;
    redundancyMode?: RedundancyMode;
    readonly repositorySiteName?: string;
    reserved?: boolean;
    resourceConfig?: ResourceConfig;
    readonly resourceGroup?: string;
    scmSiteAlsoStopped?: boolean;
    serverFarmId?: string;
    siteConfig?: SiteConfig;
    readonly slotSwapStatus?: SlotSwapStatus;
    readonly state?: string;
    storageAccountRequired?: boolean;
    readonly suspendedTill?: Date;
    readonly targetSwapSlot?: string;
    readonly trafficManagerHostNames?: string[];
    readonly usageState?: UsageState;
    virtualNetworkSubnetId?: string;
    vnetBackupRestoreEnabled?: boolean;
    vnetContentShareEnabled?: boolean;
    vnetImagePullEnabled?: boolean;
    vnetRouteAllEnabled?: boolean;
    workloadProfileName?: string;
}

// @public
export interface SiteAuthSettings extends ProxyOnlyResource {
    aadClaimsAuthorization?: string;
    additionalLoginParams?: string[];
    allowedAudiences?: string[];
    allowedExternalRedirectUrls?: string[];
    authFilePath?: string;
    clientId?: string;
    clientSecret?: string;
    clientSecretCertificateThumbprint?: string;
    clientSecretSettingName?: string;
    configVersion?: string;
    defaultProvider?: BuiltInAuthenticationProvider;
    enabled?: boolean;
    facebookAppId?: string;
    facebookAppSecret?: string;
    facebookAppSecretSettingName?: string;
    facebookOAuthScopes?: string[];
    gitHubClientId?: string;
    gitHubClientSecret?: string;
    gitHubClientSecretSettingName?: string;
    gitHubOAuthScopes?: string[];
    googleClientId?: string;
    googleClientSecret?: string;
    googleClientSecretSettingName?: string;
    googleOAuthScopes?: string[];
    isAuthFromFile?: string;
    issuer?: string;
    microsoftAccountClientId?: string;
    microsoftAccountClientSecret?: string;
    microsoftAccountClientSecretSettingName?: string;
    microsoftAccountOAuthScopes?: string[];
    runtimeVersion?: string;
    tokenRefreshExtensionHours?: number;
    tokenStoreEnabled?: boolean;
    twitterConsumerKey?: string;
    twitterConsumerSecret?: string;
    twitterConsumerSecretSettingName?: string;
    unauthenticatedClientAction?: UnauthenticatedClientAction;
    validateIssuer?: boolean;
}

// @public
export interface SiteAuthSettingsV2 extends ProxyOnlyResource {
    globalValidation?: GlobalValidation;
    httpSettings?: HttpSettings;
    identityProviders?: IdentityProviders;
    login?: Login;
    platform?: AuthPlatform;
}

// @public
export type SiteAvailabilityState = "Normal" | "Limited" | "DisasterRecoveryMode";

// @public
export interface SiteCloneability {
    blockingCharacteristics?: SiteCloneabilityCriterion[];
    blockingFeatures?: SiteCloneabilityCriterion[];
    result?: CloneAbilityResult;
    unsupportedFeatures?: SiteCloneabilityCriterion[];
}

// @public
export interface SiteCloneabilityCriterion {
    description?: string;
    name?: string;
}

// @public
export interface SiteConfig {
    acrUseManagedIdentityCreds?: boolean;
    acrUserManagedIdentityID?: string;
    alwaysOn?: boolean;
    apiDefinition?: ApiDefinitionInfo;
    apiManagementConfig?: ApiManagementConfig;
    appCommandLine?: string;
    appSettings?: NameValuePair[];
    autoHealEnabled?: boolean;
    autoHealRules?: AutoHealRules;
    autoSwapSlotName?: string;
    azureStorageAccounts?: {
        [propertyName: string]: AzureStorageInfoValue;
    };
    connectionStrings?: ConnStringInfo[];
    cors?: CorsSettings;
    defaultDocuments?: string[];
    detailedErrorLoggingEnabled?: boolean;
    documentRoot?: string;
    elasticWebAppScaleLimit?: number;
    experiments?: Experiments;
    ftpsState?: FtpsState;
    functionAppScaleLimit?: number;
    functionsRuntimeScaleMonitoringEnabled?: boolean;
    handlerMappings?: HandlerMapping[];
    healthCheckPath?: string;
    http20Enabled?: boolean;
    httpLoggingEnabled?: boolean;
    ipSecurityRestrictions?: IpSecurityRestriction[];
    ipSecurityRestrictionsDefaultAction?: DefaultAction;
    javaContainer?: string;
    javaContainerVersion?: string;
    javaVersion?: string;
    keyVaultReferenceIdentity?: string;
    limits?: SiteLimits;
    linuxFxVersion?: string;
    loadBalancing?: SiteLoadBalancing;
    localMySqlEnabled?: boolean;
    logsDirectorySizeLimit?: number;
    readonly machineKey?: SiteMachineKey;
    managedPipelineMode?: ManagedPipelineMode;
    managedServiceIdentityId?: number;
    metadata?: NameValuePair[];
    minimumElasticInstanceCount?: number;
    minTlsCipherSuite?: TlsCipherSuites;
    minTlsVersion?: SupportedTlsVersions;
    netFrameworkVersion?: string;
    nodeVersion?: string;
    numberOfWorkers?: number;
    phpVersion?: string;
    powerShellVersion?: string;
    preWarmedInstanceCount?: number;
    publicNetworkAccess?: string;
    publishingUsername?: string;
    push?: PushSettings;
    pythonVersion?: string;
    remoteDebuggingEnabled?: boolean;
    remoteDebuggingVersion?: string;
    requestTracingEnabled?: boolean;
    requestTracingExpirationTime?: Date;
    scmIpSecurityRestrictions?: IpSecurityRestriction[];
    scmIpSecurityRestrictionsDefaultAction?: DefaultAction;
    scmIpSecurityRestrictionsUseMain?: boolean;
    scmMinTlsVersion?: SupportedTlsVersions;
    scmType?: ScmType;
    tracingOptions?: string;
    use32BitWorkerProcess?: boolean;
    virtualApplications?: VirtualApplication[];
    vnetName?: string;
    vnetPrivatePortsCount?: number;
    vnetRouteAllEnabled?: boolean;
    websiteTimeZone?: string;
    webSocketsEnabled?: boolean;
    windowsFxVersion?: string;
    xManagedServiceIdentityId?: number;
}

// @public
export interface SiteConfigPropertiesDictionary {
    readonly javaVersion?: string;
    readonly linuxFxVersion?: string;
    readonly powerShellVersion?: string;
    readonly use32BitWorkerProcess?: boolean;
}

// @public
export interface SiteConfigResource extends ProxyOnlyResource {
    acrUseManagedIdentityCreds?: boolean;
    acrUserManagedIdentityID?: string;
    alwaysOn?: boolean;
    apiDefinition?: ApiDefinitionInfo;
    apiManagementConfig?: ApiManagementConfig;
    appCommandLine?: string;
    appSettings?: NameValuePair[];
    autoHealEnabled?: boolean;
    autoHealRules?: AutoHealRules;
    autoSwapSlotName?: string;
    azureStorageAccounts?: {
        [propertyName: string]: AzureStorageInfoValue;
    };
    connectionStrings?: ConnStringInfo[];
    cors?: CorsSettings;
    defaultDocuments?: string[];
    detailedErrorLoggingEnabled?: boolean;
    documentRoot?: string;
    elasticWebAppScaleLimit?: number;
    experiments?: Experiments;
    ftpsState?: FtpsState;
    functionAppScaleLimit?: number;
    functionsRuntimeScaleMonitoringEnabled?: boolean;
    handlerMappings?: HandlerMapping[];
    healthCheckPath?: string;
    http20Enabled?: boolean;
    httpLoggingEnabled?: boolean;
    ipSecurityRestrictions?: IpSecurityRestriction[];
    ipSecurityRestrictionsDefaultAction?: DefaultAction;
    javaContainer?: string;
    javaContainerVersion?: string;
    javaVersion?: string;
    keyVaultReferenceIdentity?: string;
    limits?: SiteLimits;
    linuxFxVersion?: string;
    loadBalancing?: SiteLoadBalancing;
    localMySqlEnabled?: boolean;
    logsDirectorySizeLimit?: number;
    readonly machineKey?: SiteMachineKey;
    managedPipelineMode?: ManagedPipelineMode;
    managedServiceIdentityId?: number;
    metadata?: NameValuePair[];
    minimumElasticInstanceCount?: number;
    minTlsCipherSuite?: TlsCipherSuites;
    minTlsVersion?: SupportedTlsVersions;
    netFrameworkVersion?: string;
    nodeVersion?: string;
    numberOfWorkers?: number;
    phpVersion?: string;
    powerShellVersion?: string;
    preWarmedInstanceCount?: number;
    publicNetworkAccess?: string;
    publishingUsername?: string;
    push?: PushSettings;
    pythonVersion?: string;
    remoteDebuggingEnabled?: boolean;
    remoteDebuggingVersion?: string;
    requestTracingEnabled?: boolean;
    requestTracingExpirationTime?: Date;
    scmIpSecurityRestrictions?: IpSecurityRestriction[];
    scmIpSecurityRestrictionsDefaultAction?: DefaultAction;
    scmIpSecurityRestrictionsUseMain?: boolean;
    scmMinTlsVersion?: SupportedTlsVersions;
    scmType?: ScmType;
    tracingOptions?: string;
    use32BitWorkerProcess?: boolean;
    virtualApplications?: VirtualApplication[];
    vnetName?: string;
    vnetPrivatePortsCount?: number;
    vnetRouteAllEnabled?: boolean;
    websiteTimeZone?: string;
    webSocketsEnabled?: boolean;
    windowsFxVersion?: string;
    xManagedServiceIdentityId?: number;
}

// @public
export interface SiteConfigResourceCollection {
    readonly nextLink?: string;
    value: SiteConfigResource[];
}

// @public
export interface SiteConfigurationSnapshotInfo extends ProxyOnlyResource {
    readonly snapshotId?: number;
    readonly time?: Date;
}

// @public
export interface SiteConfigurationSnapshotInfoCollection {
    readonly nextLink?: string;
    value: SiteConfigurationSnapshotInfo[];
}

// @public
export interface SiteContainer extends ProxyOnlyResource {
    authType?: AuthType;
    readonly createdTime?: Date;
    environmentVariables?: EnvironmentVariable[];
    image?: string;
    isMain?: boolean;
    readonly lastModifiedTime?: Date;
    passwordSecret?: string;
    startUpCommand?: string;
    targetPort?: string;
    userManagedIdentityClientId?: string;
    userName?: string;
    volumeMounts?: VolumeMount[];
}

// @public
export interface SiteContainerCollection {
    readonly nextLink?: string;
    value: SiteContainer[];
}

// @public (undocumented)
export interface SiteDnsConfig {
    dnsAltServer?: string;
    readonly dnsLegacySortOrder?: boolean;
    dnsMaxCacheTimeout?: number;
    dnsRetryAttemptCount?: number;
    dnsRetryAttemptTimeout?: number;
    dnsServers?: string[];
}

// @public
export interface SiteExtensionInfo extends ProxyOnlyResource {
    authors?: string[];
    comment?: string;
    description?: string;
    downloadCount?: number;
    extensionId?: string;
    extensionType?: SiteExtensionType;
    extensionUrl?: string;
    feedUrl?: string;
    iconUrl?: string;
    installedDateTime?: Date;
    installerCommandLineParams?: string;
    licenseUrl?: string;
    localIsLatestVersion?: boolean;
    localPath?: string;
    projectUrl?: string;
    provisioningState?: string;
    publishedDateTime?: Date;
    summary?: string;
    // (undocumented)
    title?: string;
    version?: string;
}

// @public
export interface SiteExtensionInfoCollection {
    readonly nextLink?: string;
    value: SiteExtensionInfo[];
}

// @public
export type SiteExtensionType = "Gallery" | "WebRoot";

// @public
export interface SiteLimits {
    maxDiskSizeInMb?: number;
    maxMemoryInMb?: number;
    maxPercentageCpu?: number;
}

// @public
export type SiteLoadBalancing = "WeightedRoundRobin" | "LeastRequests" | "LeastResponseTime" | "WeightedTotalTraffic" | "RequestHash" | "PerSiteRoundRobin";

// @public
export interface SiteLogsConfig extends ProxyOnlyResource {
    applicationLogs?: ApplicationLogsConfig;
    detailedErrorMessages?: EnabledConfig;
    failedRequestsTracing?: EnabledConfig;
    httpLogs?: HttpLogsConfig;
}

// @public
export interface SiteMachineKey {
    decryption?: string;
    decryptionKey?: string;
    validation?: string;
    validationKey?: string;
}

// @public
export interface SitePatchResource extends ProxyOnlyResource {
    readonly availabilityState?: SiteAvailabilityState;
    clientAffinityEnabled?: boolean;
    clientCertEnabled?: boolean;
    clientCertExclusionPaths?: string;
    clientCertMode?: ClientCertMode;
    cloningInfo?: CloningInfo;
    containerSize?: number;
    customDomainVerificationId?: string;
    dailyMemoryTimeQuota?: number;
    readonly defaultHostName?: string;
    dnsConfiguration?: SiteDnsConfig;
    enabled?: boolean;
    readonly enabledHostNames?: string[];
    hostingEnvironmentProfile?: HostingEnvironmentProfile;
    readonly hostNames?: string[];
    hostNamesDisabled?: boolean;
    hostNameSslStates?: HostNameSslState[];
    httpsOnly?: boolean;
    hyperV?: boolean;
    identity?: ManagedServiceIdentity;
    readonly inProgressOperationId?: string;
    readonly isDefaultContainer?: boolean;
    isXenon?: boolean;
    keyVaultReferenceIdentity?: string;
    readonly lastModifiedTimeUtc?: Date;
    readonly maxNumberOfWorkers?: number;
    readonly outboundIpAddresses?: string;
    readonly possibleOutboundIpAddresses?: string;
    redundancyMode?: RedundancyMode;
    readonly repositorySiteName?: string;
    reserved?: boolean;
    readonly resourceGroup?: string;
    scmSiteAlsoStopped?: boolean;
    serverFarmId?: string;
    siteConfig?: SiteConfig;
    readonly slotSwapStatus?: SlotSwapStatus;
    readonly state?: string;
    storageAccountRequired?: boolean;
    readonly suspendedTill?: Date;
    readonly targetSwapSlot?: string;
    readonly trafficManagerHostNames?: string[];
    readonly usageState?: UsageState;
    virtualNetworkSubnetId?: string;
}

// @public
export interface SitePhpErrorLogFlag extends ProxyOnlyResource {
    localLogErrors?: string;
    localLogErrorsMaxLength?: string;
    masterLogErrors?: string;
    masterLogErrorsMaxLength?: string;
}

// @public
export type SiteRuntimeState = "READY" | "STOPPED" | "UNKNOWN";

// @public
export interface SiteSeal {
    html: string;
}

// @public
export interface SiteSealRequest {
    lightTheme?: boolean;
    locale?: string;
}

// @public
export interface SiteSourceControl extends ProxyOnlyResource {
    branch?: string;
    deploymentRollbackEnabled?: boolean;
    gitHubActionConfiguration?: GitHubActionConfiguration;
    isGitHubAction?: boolean;
    isManualIntegration?: boolean;
    isMercurial?: boolean;
    repoUrl?: string;
}

// @public
export interface SkuCapacity {
    default?: number;
    elasticMaximum?: number;
    maximum?: number;
    minimum?: number;
    scaleType?: string;
}

// @public
export interface SkuDescription {
    capabilities?: Capability[];
    capacity?: number;
    family?: string;
    locations?: string[];
    name?: string;
    size?: string;
    skuCapacity?: SkuCapacity;
    tier?: string;
}

// @public
export interface SkuInfo {
    capacity?: SkuCapacity;
    resourceType?: string;
    sku?: SkuDescription;
}

// @public
export interface SkuInfoCollection {
    readonly nextLink?: string;
    value: SkuInfo[];
}

// @public
export interface SkuInfos {
    resourceType?: string;
    skus?: GlobalCsmSkuDescription[];
}

// @public
export type SkuName = string;

// @public
export interface SlotConfigNamesResource extends ProxyOnlyResource {
    appSettingNames?: string[];
    azureStorageConfigNames?: string[];
    connectionStringNames?: string[];
}

// @public
export interface SlotDifference extends ProxyOnlyResource {
    readonly description?: string;
    readonly diffRule?: string;
    readonly level?: string;
    readonly settingName?: string;
    readonly settingType?: string;
    readonly valueInCurrentSlot?: string;
    readonly valueInTargetSlot?: string;
}

// @public
export interface SlotDifferenceCollection {
    readonly nextLink?: string;
    value: SlotDifference[];
}

// @public
export interface SlotSwapStatus {
    readonly destinationSlotName?: string;
    readonly sourceSlotName?: string;
    readonly timestampUtc?: Date;
}

// @public
export interface SlowRequestsBasedTrigger {
    count?: number;
    path?: string;
    timeInterval?: string;
    timeTaken?: string;
}

// @public
export interface Snapshot extends ProxyOnlyResource {
    readonly time?: string;
}

// @public
export interface SnapshotCollection {
    readonly nextLink?: string;
    value: Snapshot[];
}

// @public
export interface SnapshotRecoverySource {
    id?: string;
    location?: string;
}

// @public
export interface SnapshotRestoreRequest extends ProxyOnlyResource {
    ignoreConflictingHostNames?: boolean;
    overwrite?: boolean;
    recoverConfiguration?: boolean;
    recoverySource?: SnapshotRecoverySource;
    snapshotTime?: string;
    useDRSecondary?: boolean;
}

// @public
export interface Solution {
    data?: NameValuePair[][];
    description?: string;
    displayName?: string;
    id?: number;
    metadata?: NameValuePair[][];
    order?: number;
    type?: SolutionType;
}

// @public
export type SolutionType = "QuickSolution" | "DeepInvestigation" | "BestPractices";

// @public
export interface SourceControl extends ProxyOnlyResource {
    expirationTime?: Date;
    refreshToken?: string;
    token?: string;
    tokenSecret?: string;
}

// @public
export interface SourceControlCollection {
    readonly nextLink?: string;
    value: SourceControl[];
}

// @public
export type SslState = "Disabled" | "SniEnabled" | "IpBasedEnabled";

// @public
export interface StackMajorVersion {
    applicationInsights?: boolean;
    appSettingsDictionary?: {
        [propertyName: string]: Record<string, unknown>;
    };
    displayVersion?: string;
    isDefault?: boolean;
    isDeprecated?: boolean;
    isHidden?: boolean;
    isPreview?: boolean;
    minorVersions?: StackMinorVersion[];
    runtimeVersion?: string;
    siteConfigPropertiesDictionary?: {
        [propertyName: string]: Record<string, unknown>;
    };
}

// @public
export interface StackMinorVersion {
    displayVersion?: string;
    isDefault?: boolean;
    isRemoteDebuggingEnabled?: boolean;
    runtimeVersion?: string;
}

// @public
export type StackPreferredOs = "Windows" | "Linux";

// @public
export type StagingEnvironmentPolicy = "Enabled" | "Disabled";

// @public
export interface StampCapacity {
    availableCapacity?: number;
    computeMode?: ComputeModeOptions;
    excludeFromCapacityAllocation?: boolean;
    isApplicableForAllComputeModes?: boolean;
    isLinux?: boolean;
    name?: string;
    siteMode?: string;
    totalCapacity?: number;
    unit?: string;
    workerSize?: WorkerSizeOptions;
    workerSizeId?: number;
}

// @public
export interface StampCapacityCollection {
    readonly nextLink?: string;
    value: StampCapacity[];
}

// @public
export interface StaticSiteARMResource extends Resource {
    allowConfigFileUpdates?: boolean;
    branch?: string;
    buildProperties?: StaticSiteBuildProperties;
    readonly contentDistributionEndpoint?: string;
    readonly customDomains?: string[];
    readonly databaseConnections?: DatabaseConnectionOverview[];
    readonly defaultHostname?: string;
    enterpriseGradeCdnStatus?: EnterpriseGradeCdnStatus;
    identity?: ManagedServiceIdentity;
    readonly keyVaultReferenceIdentity?: string;
    readonly linkedBackends?: StaticSiteLinkedBackend[];
    readonly privateEndpointConnections?: ResponseMessageEnvelopeRemotePrivateEndpointConnection[];
    provider?: string;
    publicNetworkAccess?: string;
    repositoryToken?: string;
    repositoryUrl?: string;
    sku?: SkuDescription;
    stagingEnvironmentPolicy?: StagingEnvironmentPolicy;
    templateProperties?: StaticSiteTemplateOptions;
    readonly userProvidedFunctionApps?: StaticSiteUserProvidedFunctionApp[];
}

// @public
export interface StaticSiteBasicAuthPropertiesARMResource extends ProxyOnlyResource {
    applicableEnvironmentsMode?: string;
    environments?: string[];
    password?: string;
    readonly secretState?: string;
    secretUrl?: string;
}

// @public
export interface StaticSiteBasicAuthPropertiesCollection {
    readonly nextLink?: string;
    value: StaticSiteBasicAuthPropertiesARMResource[];
}

// @public
export interface StaticSiteBuildARMResource extends ProxyOnlyResource {
    readonly buildId?: string;
    readonly createdTimeUtc?: Date;
    readonly databaseConnections?: DatabaseConnectionOverview[];
    readonly hostname?: string;
    readonly lastUpdatedOn?: Date;
    readonly linkedBackends?: StaticSiteLinkedBackend[];
    readonly pullRequestTitle?: string;
    readonly sourceBranch?: string;
    readonly status?: BuildStatus;
    readonly userProvidedFunctionApps?: StaticSiteUserProvidedFunctionApp[];
}

// @public
export interface StaticSiteBuildCollection {
    readonly nextLink?: string;
    value: StaticSiteBuildARMResource[];
}

// @public
export interface StaticSiteBuildProperties {
    apiBuildCommand?: string;
    apiLocation?: string;
    appArtifactLocation?: string;
    appBuildCommand?: string;
    appLocation?: string;
    githubActionSecretNameOverride?: string;
    outputLocation?: string;
    skipGithubActionWorkflowGeneration?: boolean;
}

// @public
export interface StaticSiteCollection {
    readonly nextLink?: string;
    value: StaticSiteARMResource[];
}

// @public
export interface StaticSiteCustomDomainOverviewARMResource extends ProxyOnlyResource {
    readonly createdOn?: Date;
    readonly domainName?: string;
    readonly errorMessage?: string;
    readonly status?: CustomDomainStatus;
    readonly validationToken?: string;
}

// @public
export interface StaticSiteCustomDomainOverviewCollection {
    readonly nextLink?: string;
    value: StaticSiteCustomDomainOverviewARMResource[];
}

// @public
export interface StaticSiteCustomDomainRequestPropertiesARMResource extends ProxyOnlyResource {
    validationMethod?: string;
}

// @public
export interface StaticSiteDatabaseConnectionConfigurationFileOverview {
    readonly contents?: string;
    readonly fileName?: string;
    readonly type?: string;
}

// @public
export interface StaticSiteFunctionOverviewARMResource extends ProxyOnlyResource {
    readonly functionName?: string;
    readonly triggerType?: TriggerTypes;
}

// @public
export interface StaticSiteFunctionOverviewCollection {
    readonly nextLink?: string;
    value: StaticSiteFunctionOverviewARMResource[];
}

// @public
export interface StaticSiteLinkedBackend {
    backendResourceId?: string;
    readonly createdOn?: Date;
    readonly provisioningState?: string;
    region?: string;
}

// @public
export interface StaticSiteLinkedBackendARMResource extends ProxyOnlyResource {
    backendResourceId?: string;
    readonly createdOn?: Date;
    readonly provisioningState?: string;
    region?: string;
}

// @public
export interface StaticSiteLinkedBackendsCollection {
    readonly nextLink?: string;
    value: StaticSiteLinkedBackendARMResource[];
}

// @public
export interface StaticSitePatchResource extends ProxyOnlyResource {
    allowConfigFileUpdates?: boolean;
    branch?: string;
    buildProperties?: StaticSiteBuildProperties;
    readonly contentDistributionEndpoint?: string;
    readonly customDomains?: string[];
    readonly databaseConnections?: DatabaseConnectionOverview[];
    readonly defaultHostname?: string;
    enterpriseGradeCdnStatus?: EnterpriseGradeCdnStatus;
    readonly keyVaultReferenceIdentity?: string;
    readonly linkedBackends?: StaticSiteLinkedBackend[];
    readonly privateEndpointConnections?: ResponseMessageEnvelopeRemotePrivateEndpointConnection[];
    provider?: string;
    publicNetworkAccess?: string;
    repositoryToken?: string;
    repositoryUrl?: string;
    stagingEnvironmentPolicy?: StagingEnvironmentPolicy;
    templateProperties?: StaticSiteTemplateOptions;
    readonly userProvidedFunctionApps?: StaticSiteUserProvidedFunctionApp[];
}

// @public
export interface StaticSiteResetPropertiesARMResource extends ProxyOnlyResource {
    repositoryToken?: string;
    shouldUpdateRepository?: boolean;
}

// @public
export interface StaticSites {
    beginApproveOrRejectPrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: StaticSitesApproveOrRejectPrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesApproveOrRejectPrivateEndpointConnectionResponse>, StaticSitesApproveOrRejectPrivateEndpointConnectionResponse>>;
    beginApproveOrRejectPrivateEndpointConnectionAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: StaticSitesApproveOrRejectPrivateEndpointConnectionOptionalParams): Promise<StaticSitesApproveOrRejectPrivateEndpointConnectionResponse>;
    beginCreateOrUpdateStaticSite(resourceGroupName: string, name: string, staticSiteEnvelope: StaticSiteARMResource, options?: StaticSitesCreateOrUpdateStaticSiteOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesCreateOrUpdateStaticSiteResponse>, StaticSitesCreateOrUpdateStaticSiteResponse>>;
    beginCreateOrUpdateStaticSiteAndWait(resourceGroupName: string, name: string, staticSiteEnvelope: StaticSiteARMResource, options?: StaticSitesCreateOrUpdateStaticSiteOptionalParams): Promise<StaticSitesCreateOrUpdateStaticSiteResponse>;
    beginCreateOrUpdateStaticSiteCustomDomain(resourceGroupName: string, name: string, domainName: string, staticSiteCustomDomainRequestPropertiesEnvelope: StaticSiteCustomDomainRequestPropertiesARMResource, options?: StaticSitesCreateOrUpdateStaticSiteCustomDomainOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesCreateOrUpdateStaticSiteCustomDomainResponse>, StaticSitesCreateOrUpdateStaticSiteCustomDomainResponse>>;
    beginCreateOrUpdateStaticSiteCustomDomainAndWait(resourceGroupName: string, name: string, domainName: string, staticSiteCustomDomainRequestPropertiesEnvelope: StaticSiteCustomDomainRequestPropertiesARMResource, options?: StaticSitesCreateOrUpdateStaticSiteCustomDomainOptionalParams): Promise<StaticSitesCreateOrUpdateStaticSiteCustomDomainResponse>;
    beginCreateZipDeploymentForStaticSite(resourceGroupName: string, name: string, staticSiteZipDeploymentEnvelope: StaticSiteZipDeploymentARMResource, options?: StaticSitesCreateZipDeploymentForStaticSiteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginCreateZipDeploymentForStaticSiteAndWait(resourceGroupName: string, name: string, staticSiteZipDeploymentEnvelope: StaticSiteZipDeploymentARMResource, options?: StaticSitesCreateZipDeploymentForStaticSiteOptionalParams): Promise<void>;
    beginCreateZipDeploymentForStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, staticSiteZipDeploymentEnvelope: StaticSiteZipDeploymentARMResource, options?: StaticSitesCreateZipDeploymentForStaticSiteBuildOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginCreateZipDeploymentForStaticSiteBuildAndWait(resourceGroupName: string, name: string, environmentName: string, staticSiteZipDeploymentEnvelope: StaticSiteZipDeploymentARMResource, options?: StaticSitesCreateZipDeploymentForStaticSiteBuildOptionalParams): Promise<void>;
    beginDeletePrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: StaticSitesDeletePrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesDeletePrivateEndpointConnectionResponse>, StaticSitesDeletePrivateEndpointConnectionResponse>>;
    beginDeletePrivateEndpointConnectionAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: StaticSitesDeletePrivateEndpointConnectionOptionalParams): Promise<StaticSitesDeletePrivateEndpointConnectionResponse>;
    beginDeleteStaticSite(resourceGroupName: string, name: string, options?: StaticSitesDeleteStaticSiteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteStaticSiteAndWait(resourceGroupName: string, name: string, options?: StaticSitesDeleteStaticSiteOptionalParams): Promise<void>;
    beginDeleteStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesDeleteStaticSiteBuildOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteStaticSiteBuildAndWait(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesDeleteStaticSiteBuildOptionalParams): Promise<void>;
    beginDeleteStaticSiteCustomDomain(resourceGroupName: string, name: string, domainName: string, options?: StaticSitesDeleteStaticSiteCustomDomainOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteStaticSiteCustomDomainAndWait(resourceGroupName: string, name: string, domainName: string, options?: StaticSitesDeleteStaticSiteCustomDomainOptionalParams): Promise<void>;
    beginDetachStaticSite(resourceGroupName: string, name: string, options?: StaticSitesDetachStaticSiteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDetachStaticSiteAndWait(resourceGroupName: string, name: string, options?: StaticSitesDetachStaticSiteOptionalParams): Promise<void>;
    beginLinkBackend(resourceGroupName: string, name: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesLinkBackendOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesLinkBackendResponse>, StaticSitesLinkBackendResponse>>;
    beginLinkBackendAndWait(resourceGroupName: string, name: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesLinkBackendOptionalParams): Promise<StaticSitesLinkBackendResponse>;
    beginLinkBackendToBuild(resourceGroupName: string, name: string, environmentName: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesLinkBackendToBuildOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesLinkBackendToBuildResponse>, StaticSitesLinkBackendToBuildResponse>>;
    beginLinkBackendToBuildAndWait(resourceGroupName: string, name: string, environmentName: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesLinkBackendToBuildOptionalParams): Promise<StaticSitesLinkBackendToBuildResponse>;
    beginRegisterUserProvidedFunctionAppWithStaticSite(resourceGroupName: string, name: string, functionAppName: string, staticSiteUserProvidedFunctionEnvelope: StaticSiteUserProvidedFunctionAppARMResource, options?: StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteResponse>, StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteResponse>>;
    beginRegisterUserProvidedFunctionAppWithStaticSiteAndWait(resourceGroupName: string, name: string, functionAppName: string, staticSiteUserProvidedFunctionEnvelope: StaticSiteUserProvidedFunctionAppARMResource, options?: StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteOptionalParams): Promise<StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteResponse>;
    beginRegisterUserProvidedFunctionAppWithStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, functionAppName: string, staticSiteUserProvidedFunctionEnvelope: StaticSiteUserProvidedFunctionAppARMResource, options?: StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildOptionalParams): Promise<SimplePollerLike<OperationState<StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildResponse>, StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildResponse>>;
    beginRegisterUserProvidedFunctionAppWithStaticSiteBuildAndWait(resourceGroupName: string, name: string, environmentName: string, functionAppName: string, staticSiteUserProvidedFunctionEnvelope: StaticSiteUserProvidedFunctionAppARMResource, options?: StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildOptionalParams): Promise<StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildResponse>;
    beginValidateBackend(resourceGroupName: string, name: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesValidateBackendOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginValidateBackendAndWait(resourceGroupName: string, name: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesValidateBackendOptionalParams): Promise<void>;
    beginValidateBackendForBuild(resourceGroupName: string, name: string, environmentName: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesValidateBackendForBuildOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginValidateBackendForBuildAndWait(resourceGroupName: string, name: string, environmentName: string, linkedBackendName: string, staticSiteLinkedBackendEnvelope: StaticSiteLinkedBackendARMResource, options?: StaticSitesValidateBackendForBuildOptionalParams): Promise<void>;
    beginValidateCustomDomainCanBeAddedToStaticSite(resourceGroupName: string, name: string, domainName: string, staticSiteCustomDomainRequestPropertiesEnvelope: StaticSiteCustomDomainRequestPropertiesARMResource, options?: StaticSitesValidateCustomDomainCanBeAddedToStaticSiteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginValidateCustomDomainCanBeAddedToStaticSiteAndWait(resourceGroupName: string, name: string, domainName: string, staticSiteCustomDomainRequestPropertiesEnvelope: StaticSiteCustomDomainRequestPropertiesARMResource, options?: StaticSitesValidateCustomDomainCanBeAddedToStaticSiteOptionalParams): Promise<void>;
    createOrUpdateBasicAuth(resourceGroupName: string, name: string, basicAuthName: BasicAuthName, basicAuthEnvelope: StaticSiteBasicAuthPropertiesARMResource, options?: StaticSitesCreateOrUpdateBasicAuthOptionalParams): Promise<StaticSitesCreateOrUpdateBasicAuthResponse>;
    createOrUpdateBuildDatabaseConnection(resourceGroupName: string, name: string, environmentName: string, databaseConnectionName: string, databaseConnectionRequestEnvelope: DatabaseConnection, options?: StaticSitesCreateOrUpdateBuildDatabaseConnectionOptionalParams): Promise<StaticSitesCreateOrUpdateBuildDatabaseConnectionResponse>;
    createOrUpdateDatabaseConnection(resourceGroupName: string, name: string, databaseConnectionName: string, databaseConnectionRequestEnvelope: DatabaseConnection, options?: StaticSitesCreateOrUpdateDatabaseConnectionOptionalParams): Promise<StaticSitesCreateOrUpdateDatabaseConnectionResponse>;
    createOrUpdateStaticSiteAppSettings(resourceGroupName: string, name: string, appSettings: StringDictionary, options?: StaticSitesCreateOrUpdateStaticSiteAppSettingsOptionalParams): Promise<StaticSitesCreateOrUpdateStaticSiteAppSettingsResponse>;
    createOrUpdateStaticSiteBuildAppSettings(resourceGroupName: string, name: string, environmentName: string, appSettings: StringDictionary, options?: StaticSitesCreateOrUpdateStaticSiteBuildAppSettingsOptionalParams): Promise<StaticSitesCreateOrUpdateStaticSiteBuildAppSettingsResponse>;
    createOrUpdateStaticSiteBuildFunctionAppSettings(resourceGroupName: string, name: string, environmentName: string, appSettings: StringDictionary, options?: StaticSitesCreateOrUpdateStaticSiteBuildFunctionAppSettingsOptionalParams): Promise<StaticSitesCreateOrUpdateStaticSiteBuildFunctionAppSettingsResponse>;
    createOrUpdateStaticSiteFunctionAppSettings(resourceGroupName: string, name: string, appSettings: StringDictionary, options?: StaticSitesCreateOrUpdateStaticSiteFunctionAppSettingsOptionalParams): Promise<StaticSitesCreateOrUpdateStaticSiteFunctionAppSettingsResponse>;
    createUserRolesInvitationLink(resourceGroupName: string, name: string, staticSiteUserRolesInvitationEnvelope: StaticSiteUserInvitationRequestResource, options?: StaticSitesCreateUserRolesInvitationLinkOptionalParams): Promise<StaticSitesCreateUserRolesInvitationLinkResponse>;
    deleteBuildDatabaseConnection(resourceGroupName: string, name: string, environmentName: string, databaseConnectionName: string, options?: StaticSitesDeleteBuildDatabaseConnectionOptionalParams): Promise<void>;
    deleteDatabaseConnection(resourceGroupName: string, name: string, databaseConnectionName: string, options?: StaticSitesDeleteDatabaseConnectionOptionalParams): Promise<void>;
    deleteStaticSiteUser(resourceGroupName: string, name: string, authprovider: string, userid: string, options?: StaticSitesDeleteStaticSiteUserOptionalParams): Promise<void>;
    detachUserProvidedFunctionAppFromStaticSite(resourceGroupName: string, name: string, functionAppName: string, options?: StaticSitesDetachUserProvidedFunctionAppFromStaticSiteOptionalParams): Promise<void>;
    detachUserProvidedFunctionAppFromStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, functionAppName: string, options?: StaticSitesDetachUserProvidedFunctionAppFromStaticSiteBuildOptionalParams): Promise<void>;
    getBasicAuth(resourceGroupName: string, name: string, basicAuthName: BasicAuthName, options?: StaticSitesGetBasicAuthOptionalParams): Promise<StaticSitesGetBasicAuthResponse>;
    getBuildDatabaseConnection(resourceGroupName: string, name: string, environmentName: string, databaseConnectionName: string, options?: StaticSitesGetBuildDatabaseConnectionOptionalParams): Promise<StaticSitesGetBuildDatabaseConnectionResponse>;
    getBuildDatabaseConnectionWithDetails(resourceGroupName: string, name: string, environmentName: string, databaseConnectionName: string, options?: StaticSitesGetBuildDatabaseConnectionWithDetailsOptionalParams): Promise<StaticSitesGetBuildDatabaseConnectionWithDetailsResponse>;
    getDatabaseConnection(resourceGroupName: string, name: string, databaseConnectionName: string, options?: StaticSitesGetDatabaseConnectionOptionalParams): Promise<StaticSitesGetDatabaseConnectionResponse>;
    getDatabaseConnectionWithDetails(resourceGroupName: string, name: string, databaseConnectionName: string, options?: StaticSitesGetDatabaseConnectionWithDetailsOptionalParams): Promise<StaticSitesGetDatabaseConnectionWithDetailsResponse>;
    getLinkedBackend(resourceGroupName: string, name: string, linkedBackendName: string, options?: StaticSitesGetLinkedBackendOptionalParams): Promise<StaticSitesGetLinkedBackendResponse>;
    getLinkedBackendForBuild(resourceGroupName: string, name: string, environmentName: string, linkedBackendName: string, options?: StaticSitesGetLinkedBackendForBuildOptionalParams): Promise<StaticSitesGetLinkedBackendForBuildResponse>;
    getPrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: StaticSitesGetPrivateEndpointConnectionOptionalParams): Promise<StaticSitesGetPrivateEndpointConnectionResponse>;
    getPrivateLinkResources(resourceGroupName: string, name: string, options?: StaticSitesGetPrivateLinkResourcesOptionalParams): Promise<StaticSitesGetPrivateLinkResourcesResponse>;
    getStaticSite(resourceGroupName: string, name: string, options?: StaticSitesGetStaticSiteOptionalParams): Promise<StaticSitesGetStaticSiteResponse>;
    getStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesGetStaticSiteBuildOptionalParams): Promise<StaticSitesGetStaticSiteBuildResponse>;
    getStaticSiteCustomDomain(resourceGroupName: string, name: string, domainName: string, options?: StaticSitesGetStaticSiteCustomDomainOptionalParams): Promise<StaticSitesGetStaticSiteCustomDomainResponse>;
    getUserProvidedFunctionAppForStaticSite(resourceGroupName: string, name: string, functionAppName: string, options?: StaticSitesGetUserProvidedFunctionAppForStaticSiteOptionalParams): Promise<StaticSitesGetUserProvidedFunctionAppForStaticSiteResponse>;
    getUserProvidedFunctionAppForStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, functionAppName: string, options?: StaticSitesGetUserProvidedFunctionAppForStaticSiteBuildOptionalParams): Promise<StaticSitesGetUserProvidedFunctionAppForStaticSiteBuildResponse>;
    list(options?: StaticSitesListOptionalParams): PagedAsyncIterableIterator<StaticSiteARMResource>;
    listBasicAuth(resourceGroupName: string, name: string, options?: StaticSitesListBasicAuthOptionalParams): PagedAsyncIterableIterator<StaticSiteBasicAuthPropertiesARMResource>;
    listBuildDatabaseConnections(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesGetBuildDatabaseConnectionsOptionalParams): PagedAsyncIterableIterator<DatabaseConnection>;
    listBuildDatabaseConnectionsWithDetails(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesGetBuildDatabaseConnectionsWithDetailsOptionalParams): PagedAsyncIterableIterator<DatabaseConnection>;
    listDatabaseConnections(resourceGroupName: string, name: string, options?: StaticSitesGetDatabaseConnectionsOptionalParams): PagedAsyncIterableIterator<DatabaseConnection>;
    listDatabaseConnectionsWithDetails(resourceGroupName: string, name: string, options?: StaticSitesGetDatabaseConnectionsWithDetailsOptionalParams): PagedAsyncIterableIterator<DatabaseConnection>;
    listLinkedBackends(resourceGroupName: string, name: string, options?: StaticSitesGetLinkedBackendsOptionalParams): PagedAsyncIterableIterator<StaticSiteLinkedBackendARMResource>;
    listLinkedBackendsForBuild(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesGetLinkedBackendsForBuildOptionalParams): PagedAsyncIterableIterator<StaticSiteLinkedBackendARMResource>;
    listPrivateEndpointConnectionList(resourceGroupName: string, name: string, options?: StaticSitesGetPrivateEndpointConnectionListOptionalParams): PagedAsyncIterableIterator<RemotePrivateEndpointConnectionARMResource>;
    listStaticSiteAppSettings(resourceGroupName: string, name: string, options?: StaticSitesListStaticSiteAppSettingsOptionalParams): Promise<StaticSitesListStaticSiteAppSettingsResponse>;
    listStaticSiteBuildAppSettings(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesListStaticSiteBuildAppSettingsOptionalParams): Promise<StaticSitesListStaticSiteBuildAppSettingsResponse>;
    listStaticSiteBuildFunctionAppSettings(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesListStaticSiteBuildFunctionAppSettingsOptionalParams): Promise<StaticSitesListStaticSiteBuildFunctionAppSettingsResponse>;
    listStaticSiteBuildFunctions(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesListStaticSiteBuildFunctionsOptionalParams): PagedAsyncIterableIterator<StaticSiteFunctionOverviewARMResource>;
    listStaticSiteBuilds(resourceGroupName: string, name: string, options?: StaticSitesGetStaticSiteBuildsOptionalParams): PagedAsyncIterableIterator<StaticSiteBuildARMResource>;
    listStaticSiteConfiguredRoles(resourceGroupName: string, name: string, options?: StaticSitesListStaticSiteConfiguredRolesOptionalParams): Promise<StaticSitesListStaticSiteConfiguredRolesResponse>;
    listStaticSiteCustomDomains(resourceGroupName: string, name: string, options?: StaticSitesListStaticSiteCustomDomainsOptionalParams): PagedAsyncIterableIterator<StaticSiteCustomDomainOverviewARMResource>;
    listStaticSiteFunctionAppSettings(resourceGroupName: string, name: string, options?: StaticSitesListStaticSiteFunctionAppSettingsOptionalParams): Promise<StaticSitesListStaticSiteFunctionAppSettingsResponse>;
    listStaticSiteFunctions(resourceGroupName: string, name: string, options?: StaticSitesListStaticSiteFunctionsOptionalParams): PagedAsyncIterableIterator<StaticSiteFunctionOverviewARMResource>;
    listStaticSitesByResourceGroup(resourceGroupName: string, options?: StaticSitesGetStaticSitesByResourceGroupOptionalParams): PagedAsyncIterableIterator<StaticSiteARMResource>;
    listStaticSiteSecrets(resourceGroupName: string, name: string, options?: StaticSitesListStaticSiteSecretsOptionalParams): Promise<StaticSitesListStaticSiteSecretsResponse>;
    listStaticSiteUsers(resourceGroupName: string, name: string, authprovider: string, options?: StaticSitesListStaticSiteUsersOptionalParams): PagedAsyncIterableIterator<StaticSiteUserARMResource>;
    listUserProvidedFunctionAppsForStaticSite(resourceGroupName: string, name: string, options?: StaticSitesGetUserProvidedFunctionAppsForStaticSiteOptionalParams): PagedAsyncIterableIterator<StaticSiteUserProvidedFunctionAppARMResource>;
    listUserProvidedFunctionAppsForStaticSiteBuild(resourceGroupName: string, name: string, environmentName: string, options?: StaticSitesGetUserProvidedFunctionAppsForStaticSiteBuildOptionalParams): PagedAsyncIterableIterator<StaticSiteUserProvidedFunctionAppARMResource>;
    previewWorkflow(location: string, staticSitesWorkflowPreviewRequest: StaticSitesWorkflowPreviewRequest, options?: StaticSitesPreviewWorkflowOptionalParams): Promise<StaticSitesPreviewWorkflowResponse>;
    resetStaticSiteApiKey(resourceGroupName: string, name: string, resetPropertiesEnvelope: StaticSiteResetPropertiesARMResource, options?: StaticSitesResetStaticSiteApiKeyOptionalParams): Promise<void>;
    unlinkBackend(resourceGroupName: string, name: string, linkedBackendName: string, options?: StaticSitesUnlinkBackendOptionalParams): Promise<void>;
    unlinkBackendFromBuild(resourceGroupName: string, name: string, environmentName: string, linkedBackendName: string, options?: StaticSitesUnlinkBackendFromBuildOptionalParams): Promise<void>;
    updateBuildDatabaseConnection(resourceGroupName: string, name: string, environmentName: string, databaseConnectionName: string, databaseConnectionRequestEnvelope: DatabaseConnectionPatchRequest, options?: StaticSitesUpdateBuildDatabaseConnectionOptionalParams): Promise<StaticSitesUpdateBuildDatabaseConnectionResponse>;
    updateDatabaseConnection(resourceGroupName: string, name: string, databaseConnectionName: string, databaseConnectionRequestEnvelope: DatabaseConnectionPatchRequest, options?: StaticSitesUpdateDatabaseConnectionOptionalParams): Promise<StaticSitesUpdateDatabaseConnectionResponse>;
    updateStaticSite(resourceGroupName: string, name: string, staticSiteEnvelope: StaticSitePatchResource, options?: StaticSitesUpdateStaticSiteOptionalParams): Promise<StaticSitesUpdateStaticSiteResponse>;
    updateStaticSiteUser(resourceGroupName: string, name: string, authprovider: string, userid: string, staticSiteUserEnvelope: StaticSiteUserARMResource, options?: StaticSitesUpdateStaticSiteUserOptionalParams): Promise<StaticSitesUpdateStaticSiteUserResponse>;
}

// @public
export interface StaticSitesApproveOrRejectPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesApproveOrRejectPrivateEndpointConnectionResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface StaticSitesCreateOrUpdateBasicAuthOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateBasicAuthResponse = StaticSiteBasicAuthPropertiesARMResource;

// @public
export interface StaticSitesCreateOrUpdateBuildDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateBuildDatabaseConnectionResponse = DatabaseConnection;

// @public
export interface StaticSitesCreateOrUpdateDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateDatabaseConnectionResponse = DatabaseConnection;

// @public
export interface StaticSitesCreateOrUpdateStaticSiteAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateStaticSiteAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesCreateOrUpdateStaticSiteBuildAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateStaticSiteBuildAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesCreateOrUpdateStaticSiteBuildFunctionAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateStaticSiteBuildFunctionAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesCreateOrUpdateStaticSiteCustomDomainOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesCreateOrUpdateStaticSiteCustomDomainResponse = StaticSiteCustomDomainOverviewARMResource;

// @public
export interface StaticSitesCreateOrUpdateStaticSiteFunctionAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateOrUpdateStaticSiteFunctionAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesCreateOrUpdateStaticSiteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesCreateOrUpdateStaticSiteResponse = StaticSiteARMResource;

// @public
export interface StaticSitesCreateUserRolesInvitationLinkOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesCreateUserRolesInvitationLinkResponse = StaticSiteUserInvitationResponseResource;

// @public
export interface StaticSitesCreateZipDeploymentForStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesCreateZipDeploymentForStaticSiteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesDeleteBuildDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface StaticSitesDeleteDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface StaticSitesDeletePrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesDeletePrivateEndpointConnectionResponse = Record<string, unknown>;

// @public
export interface StaticSitesDeleteStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesDeleteStaticSiteCustomDomainOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesDeleteStaticSiteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesDeleteStaticSiteUserOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface StaticSitesDetachStaticSiteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesDetachUserProvidedFunctionAppFromStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface StaticSitesDetachUserProvidedFunctionAppFromStaticSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface StaticSitesGetBasicAuthOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBasicAuthResponse = StaticSiteBasicAuthPropertiesARMResource;

// @public
export interface StaticSitesGetBuildDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBuildDatabaseConnectionResponse = DatabaseConnection;

// @public
export interface StaticSitesGetBuildDatabaseConnectionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBuildDatabaseConnectionsNextResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetBuildDatabaseConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBuildDatabaseConnectionsResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetBuildDatabaseConnectionsWithDetailsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBuildDatabaseConnectionsWithDetailsNextResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetBuildDatabaseConnectionsWithDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBuildDatabaseConnectionsWithDetailsResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetBuildDatabaseConnectionWithDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetBuildDatabaseConnectionWithDetailsResponse = DatabaseConnection;

// @public
export interface StaticSitesGetDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetDatabaseConnectionResponse = DatabaseConnection;

// @public
export interface StaticSitesGetDatabaseConnectionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetDatabaseConnectionsNextResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetDatabaseConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetDatabaseConnectionsResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetDatabaseConnectionsWithDetailsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetDatabaseConnectionsWithDetailsNextResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetDatabaseConnectionsWithDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetDatabaseConnectionsWithDetailsResponse = DatabaseConnectionCollection;

// @public
export interface StaticSitesGetDatabaseConnectionWithDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetDatabaseConnectionWithDetailsResponse = DatabaseConnection;

// @public
export interface StaticSitesGetLinkedBackendForBuildOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetLinkedBackendForBuildResponse = StaticSiteLinkedBackendARMResource;

// @public
export interface StaticSitesGetLinkedBackendOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetLinkedBackendResponse = StaticSiteLinkedBackendARMResource;

// @public
export interface StaticSitesGetLinkedBackendsForBuildNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetLinkedBackendsForBuildNextResponse = StaticSiteLinkedBackendsCollection;

// @public
export interface StaticSitesGetLinkedBackendsForBuildOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetLinkedBackendsForBuildResponse = StaticSiteLinkedBackendsCollection;

// @public
export interface StaticSitesGetLinkedBackendsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetLinkedBackendsNextResponse = StaticSiteLinkedBackendsCollection;

// @public
export interface StaticSitesGetLinkedBackendsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetLinkedBackendsResponse = StaticSiteLinkedBackendsCollection;

// @public
export interface StaticSitesGetPrivateEndpointConnectionListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetPrivateEndpointConnectionListNextResponse = PrivateEndpointConnectionCollection;

// @public
export interface StaticSitesGetPrivateEndpointConnectionListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetPrivateEndpointConnectionListResponse = PrivateEndpointConnectionCollection;

// @public
export interface StaticSitesGetPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetPrivateEndpointConnectionResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface StaticSitesGetPrivateLinkResourcesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetPrivateLinkResourcesResponse = PrivateLinkResourcesWrapper;

// @public
export interface StaticSitesGetStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSiteBuildResponse = StaticSiteBuildARMResource;

// @public
export interface StaticSitesGetStaticSiteBuildsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSiteBuildsNextResponse = StaticSiteBuildCollection;

// @public
export interface StaticSitesGetStaticSiteBuildsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSiteBuildsResponse = StaticSiteBuildCollection;

// @public
export interface StaticSitesGetStaticSiteCustomDomainOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSiteCustomDomainResponse = StaticSiteCustomDomainOverviewARMResource;

// @public
export interface StaticSitesGetStaticSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSiteResponse = StaticSiteARMResource;

// @public
export interface StaticSitesGetStaticSitesByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSitesByResourceGroupNextResponse = StaticSiteCollection;

// @public
export interface StaticSitesGetStaticSitesByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetStaticSitesByResourceGroupResponse = StaticSiteCollection;

// @public
export interface StaticSitesGetUserProvidedFunctionAppForStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetUserProvidedFunctionAppForStaticSiteBuildResponse = StaticSiteUserProvidedFunctionAppARMResource;

// @public
export interface StaticSitesGetUserProvidedFunctionAppForStaticSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetUserProvidedFunctionAppForStaticSiteResponse = StaticSiteUserProvidedFunctionAppARMResource;

// @public
export interface StaticSitesGetUserProvidedFunctionAppsForStaticSiteBuildNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetUserProvidedFunctionAppsForStaticSiteBuildNextResponse = StaticSiteUserProvidedFunctionAppsCollection;

// @public
export interface StaticSitesGetUserProvidedFunctionAppsForStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetUserProvidedFunctionAppsForStaticSiteBuildResponse = StaticSiteUserProvidedFunctionAppsCollection;

// @public
export interface StaticSitesGetUserProvidedFunctionAppsForStaticSiteNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetUserProvidedFunctionAppsForStaticSiteNextResponse = StaticSiteUserProvidedFunctionAppsCollection;

// @public
export interface StaticSitesGetUserProvidedFunctionAppsForStaticSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesGetUserProvidedFunctionAppsForStaticSiteResponse = StaticSiteUserProvidedFunctionAppsCollection;

// @public
export interface StaticSitesLinkBackendOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesLinkBackendResponse = StaticSiteLinkedBackendARMResource;

// @public
export interface StaticSitesLinkBackendToBuildOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesLinkBackendToBuildResponse = StaticSiteLinkedBackendARMResource;

// @public
export interface StaticSitesListBasicAuthNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListBasicAuthNextResponse = StaticSiteBasicAuthPropertiesCollection;

// @public
export interface StaticSitesListBasicAuthOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListBasicAuthResponse = StaticSiteBasicAuthPropertiesCollection;

// @public
export interface StaticSitesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListNextResponse = StaticSiteCollection;

// @public
export interface StaticSitesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListResponse = StaticSiteCollection;

// @public
export interface StaticSitesListStaticSiteAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesListStaticSiteBuildAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteBuildAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesListStaticSiteBuildFunctionAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteBuildFunctionAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesListStaticSiteBuildFunctionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteBuildFunctionsNextResponse = StaticSiteFunctionOverviewCollection;

// @public
export interface StaticSitesListStaticSiteBuildFunctionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteBuildFunctionsResponse = StaticSiteFunctionOverviewCollection;

// @public
export interface StaticSitesListStaticSiteConfiguredRolesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteConfiguredRolesResponse = StringList;

// @public
export interface StaticSitesListStaticSiteCustomDomainsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteCustomDomainsNextResponse = StaticSiteCustomDomainOverviewCollection;

// @public
export interface StaticSitesListStaticSiteCustomDomainsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteCustomDomainsResponse = StaticSiteCustomDomainOverviewCollection;

// @public
export interface StaticSitesListStaticSiteFunctionAppSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteFunctionAppSettingsResponse = StringDictionary;

// @public
export interface StaticSitesListStaticSiteFunctionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteFunctionsNextResponse = StaticSiteFunctionOverviewCollection;

// @public
export interface StaticSitesListStaticSiteFunctionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteFunctionsResponse = StaticSiteFunctionOverviewCollection;

// @public
export interface StaticSitesListStaticSiteSecretsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteSecretsResponse = StringDictionary;

// @public
export interface StaticSitesListStaticSiteUsersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteUsersNextResponse = StaticSiteUserCollection;

// @public
export interface StaticSitesListStaticSiteUsersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesListStaticSiteUsersResponse = StaticSiteUserCollection;

// @public
export interface StaticSitesPreviewWorkflowOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesPreviewWorkflowResponse = StaticSitesWorkflowPreview;

// @public
export interface StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildOptionalParams extends coreClient.OperationOptions {
    isForced?: boolean;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildResponse = StaticSiteUserProvidedFunctionAppARMResource;

// @public
export interface StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteOptionalParams extends coreClient.OperationOptions {
    isForced?: boolean;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteResponse = StaticSiteUserProvidedFunctionAppARMResource;

// @public
export interface StaticSitesResetStaticSiteApiKeyOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface StaticSitesUnlinkBackendFromBuildOptionalParams extends coreClient.OperationOptions {
    isCleaningAuthConfig?: boolean;
}

// @public
export interface StaticSitesUnlinkBackendOptionalParams extends coreClient.OperationOptions {
    isCleaningAuthConfig?: boolean;
}

// @public
export interface StaticSitesUpdateBuildDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesUpdateBuildDatabaseConnectionResponse = DatabaseConnection;

// @public
export interface StaticSitesUpdateDatabaseConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesUpdateDatabaseConnectionResponse = DatabaseConnection;

// @public
export interface StaticSitesUpdateStaticSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesUpdateStaticSiteResponse = StaticSiteARMResource;

// @public
export interface StaticSitesUpdateStaticSiteUserOptionalParams extends coreClient.OperationOptions {
}

// @public
export type StaticSitesUpdateStaticSiteUserResponse = StaticSiteUserARMResource;

// @public
export interface StaticSitesValidateBackendForBuildOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesValidateBackendOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesValidateCustomDomainCanBeAddedToStaticSiteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface StaticSitesWorkflowPreview extends ProxyOnlyResource {
    readonly contents?: string;
    readonly path?: string;
}

// @public
export interface StaticSitesWorkflowPreviewRequest extends ProxyOnlyResource {
    branch?: string;
    buildProperties?: StaticSiteBuildProperties;
    repositoryUrl?: string;
}

// @public
export interface StaticSiteTemplateOptions {
    description?: string;
    isPrivate?: boolean;
    owner?: string;
    repositoryName?: string;
    templateRepositoryUrl?: string;
}

// @public
export interface StaticSiteUserARMResource extends ProxyOnlyResource {
    readonly displayName?: string;
    readonly provider?: string;
    roles?: string;
    readonly userId?: string;
}

// @public
export interface StaticSiteUserCollection {
    readonly nextLink?: string;
    value: StaticSiteUserARMResource[];
}

// @public
export interface StaticSiteUserInvitationRequestResource extends ProxyOnlyResource {
    domain?: string;
    numHoursToExpiration?: number;
    provider?: string;
    roles?: string;
    userDetails?: string;
}

// @public
export interface StaticSiteUserInvitationResponseResource extends ProxyOnlyResource {
    readonly expiresOn?: Date;
    readonly invitationUrl?: string;
}

// @public
export interface StaticSiteUserProvidedFunctionApp extends ProxyOnlyResource {
    readonly createdOn?: Date;
    functionAppRegion?: string;
    functionAppResourceId?: string;
}

// @public
export interface StaticSiteUserProvidedFunctionAppARMResource extends ProxyOnlyResource {
    readonly createdOn?: Date;
    functionAppRegion?: string;
    functionAppResourceId?: string;
}

// @public
export interface StaticSiteUserProvidedFunctionAppsCollection {
    readonly nextLink?: string;
    value: StaticSiteUserProvidedFunctionAppARMResource[];
}

// @public
export interface StaticSiteZipDeploymentARMResource extends ProxyOnlyResource {
    apiZipUrl?: string;
    appZipUrl?: string;
    deploymentTitle?: string;
    functionLanguage?: string;
    provider?: string;
}

// @public
export interface Status {
    message?: string;
    statusId?: InsightStatus;
}

// @public
export interface StatusCodesBasedTrigger {
    count?: number;
    path?: string;
    status?: number;
    subStatus?: number;
    timeInterval?: string;
    win32Status?: number;
}

// @public
export interface StatusCodesRangeBasedTrigger {
    count?: number;
    // (undocumented)
    path?: string;
    statusCodes?: string;
    timeInterval?: string;
}

// @public
export type StatusOptions = "Ready" | "Pending" | "Creating";

// @public
export interface StorageMigrationOptions extends ProxyOnlyResource {
    azurefilesConnectionString?: string;
    azurefilesShare?: string;
    blockWriteAccessToSite?: boolean;
    switchSiteAfterMigration?: boolean;
}

// @public
export interface StorageMigrationResponse extends ProxyOnlyResource {
    readonly operationId?: string;
}

// @public
export type StorageType = "LocalNode" | "NetworkFileSystem";

// @public
export interface StringDictionary extends ProxyOnlyResource {
    properties?: {
        [propertyName: string]: string;
    };
}

// @public
export interface StringList extends ProxyOnlyResource {
    properties?: string[];
}

// @public
export interface SubResource {
    readonly id?: string;
}

// @public
export type SupportedTlsVersions = string;

// @public
export interface SupportTopic {
    readonly id?: string;
    readonly pesId?: string;
}

// @public
export interface SwiftVirtualNetwork extends ProxyOnlyResource {
    subnetResourceId?: string;
    swiftSupported?: boolean;
}

// @public
export interface Template {
    containers?: Container[];
    dapr?: Dapr;
    revisionSuffix?: string;
    scale?: Scale;
}

// @public
export interface TldLegalAgreement {
    agreementKey: string;
    content: string;
    title: string;
    url?: string;
}

// @public
export interface TldLegalAgreementCollection {
    readonly nextLink?: string;
    value: TldLegalAgreement[];
}

// @public
export type TlsCipherSuites = string;

// @public
export interface TokenStore {
    azureBlobStorage?: BlobStorageTokenStore;
    enabled?: boolean;
    fileSystem?: FileSystemTokenStore;
    tokenRefreshExtensionHours?: number;
}

// @public
export interface TopLevelDomain extends ProxyOnlyResource {
    privacy?: boolean;
}

// @public
export interface TopLevelDomainAgreementOption {
    forTransfer?: boolean;
    includePrivacy?: boolean;
}

// @public
export interface TopLevelDomainCollection {
    readonly nextLink?: string;
    value: TopLevelDomain[];
}

// @public
export interface TopLevelDomains {
    get(name: string, options?: TopLevelDomainsGetOptionalParams): Promise<TopLevelDomainsGetResponse>;
    list(options?: TopLevelDomainsListOptionalParams): PagedAsyncIterableIterator<TopLevelDomain>;
    listAgreements(name: string, agreementOption: TopLevelDomainAgreementOption, options?: TopLevelDomainsListAgreementsOptionalParams): PagedAsyncIterableIterator<TldLegalAgreement>;
}

// @public
export interface TopLevelDomainsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TopLevelDomainsGetResponse = TopLevelDomain;

// @public
export interface TopLevelDomainsListAgreementsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TopLevelDomainsListAgreementsNextResponse = TldLegalAgreementCollection;

// @public
export interface TopLevelDomainsListAgreementsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TopLevelDomainsListAgreementsResponse = TldLegalAgreementCollection;

// @public
export interface TopLevelDomainsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TopLevelDomainsListNextResponse = TopLevelDomainCollection;

// @public
export interface TopLevelDomainsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TopLevelDomainsListResponse = TopLevelDomainCollection;

// @public
export interface TrafficWeight {
    latestRevision?: boolean;
    revisionName?: string;
    weight?: number;
}

// @public
export interface TriggeredJobHistory extends ProxyOnlyResource {
    runs?: TriggeredJobRun[];
}

// @public
export interface TriggeredJobHistoryCollection {
    readonly nextLink?: string;
    value: TriggeredJobHistory[];
}

// @public
export interface TriggeredJobRun {
    duration?: string;
    endTime?: Date;
    errorUrl?: string;
    jobName?: string;
    outputUrl?: string;
    startTime?: Date;
    status?: TriggeredWebJobStatus;
    trigger?: string;
    url?: string;
    webJobId?: string;
    webJobName?: string;
}

// @public
export interface TriggeredWebJob extends ProxyOnlyResource {
    error?: string;
    extraInfoUrl?: string;
    historyUrl?: string;
    latestRun?: TriggeredJobRun;
    publicNetworkAccess?: string;
    runCommand?: string;
    schedulerLogsUrl?: string;
    settings?: {
        [propertyName: string]: Record<string, unknown>;
    };
    storageAccountRequired?: boolean;
    url?: string;
    usingSdk?: boolean;
    webJobType?: WebJobType;
}

// @public
export interface TriggeredWebJobCollection {
    readonly nextLink?: string;
    value: TriggeredWebJob[];
}

// @public
export type TriggeredWebJobStatus = "Success" | "Failed" | "Error";

// @public
export type TriggerTypes = string;

// @public
export interface Twitter {
    enabled?: boolean;
    registration?: TwitterRegistration;
}

// @public
export interface TwitterRegistration {
    consumerKey?: string;
    consumerSecretSettingName?: string;
}

// @public
export type UnauthenticatedClientAction = "RedirectToLoginPage" | "AllowAnonymous";

// @public
export type UnauthenticatedClientActionV2 = "RedirectToLoginPage" | "AllowAnonymous" | "Return401" | "Return403";

// @public
export interface UpdatePublishingUserOptionalParams extends coreClient.OperationOptions {
}

// @public
export type UpdatePublishingUserResponse = User;

// @public
export interface UpdateSourceControlOptionalParams extends coreClient.OperationOptions {
}

// @public
export type UpdateSourceControlResponse = SourceControl;

// @public
export type UpgradeAvailability = string;

// @public
export type UpgradePreference = string;

// @public
export interface Usage extends ProxyOnlyResource {
    readonly computeMode?: ComputeModeOptions;
    readonly currentValue?: number;
    readonly displayName?: string;
    readonly limit?: number;
    readonly nextResetTime?: Date;
    readonly resourceName?: string;
    readonly siteMode?: string;
    readonly unit?: string;
}

// @public
export interface UsageCollection {
    readonly nextLink?: string;
    value: Usage[];
}

// @public
export type UsageState = "Normal" | "Exceeded";

// @public
export interface User extends ProxyOnlyResource {
    publishingPassword?: string;
    publishingPasswordHash?: string;
    publishingPasswordHashSalt?: string;
    publishingUserName?: string;
    scmUri?: string;
}

// @public
export interface UserAssignedIdentity {
    readonly clientId?: string;
    readonly principalId?: string;
}

// @public
export interface ValidateMoveOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ValidateOperationResponse = ValidateResponse;

// @public
export interface ValidateOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ValidateRequest {
    appServiceEnvironment?: AppServiceEnvironment;
    capacity?: number;
    containerImagePlatform?: string;
    containerImageRepository?: string;
    containerImageTag?: string;
    containerRegistryBaseUrl?: string;
    containerRegistryPassword?: string;
    containerRegistryUsername?: string;
    hostingEnvironment?: string;
    isSpot?: boolean;
    isXenon?: boolean;
    location: string;
    name: string;
    needLinuxWorkers?: boolean;
    serverFarmId?: string;
    skuName?: string;
    type: ValidateResourceTypes;
}

// @public
export type ValidateResourceTypes = string;

// @public
export interface ValidateResponse {
    error?: ValidateResponseError;
    status?: string;
}

// @public
export interface ValidateResponseError {
    code?: string;
    message?: string;
}

// @public
export interface VerifyHostingEnvironmentVnetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VerifyHostingEnvironmentVnetResponse = VnetValidationFailureDetails;

// @public
export interface VirtualApplication {
    physicalPath?: string;
    preloadEnabled?: boolean;
    virtualDirectories?: VirtualDirectory[];
    virtualPath?: string;
}

// @public
export interface VirtualDirectory {
    physicalPath?: string;
    virtualPath?: string;
}

// @public
export interface VirtualIPMapping {
    internalHttpPort?: number;
    internalHttpsPort?: number;
    inUse?: boolean;
    serviceName?: string;
    virtualIP?: string;
}

// @public
export interface VirtualNetworkProfile {
    id: string;
    readonly name?: string;
    subnet?: string;
    readonly type?: string;
}

// @public
export interface VnetGateway extends ProxyOnlyResource {
    vnetName?: string;
    vpnPackageUri?: string;
}

// @public
export interface VnetInfo {
    certBlob?: string;
    readonly certThumbprint?: string;
    dnsServers?: string;
    isSwift?: boolean;
    readonly resyncRequired?: boolean;
    readonly routes?: VnetRoute[];
    vnetResourceId?: string;
}

// @public
export interface VnetInfoResource extends ProxyOnlyResource {
    certBlob?: string;
    readonly certThumbprint?: string;
    dnsServers?: string;
    isSwift?: boolean;
    readonly resyncRequired?: boolean;
    readonly routes?: VnetRoute[];
    vnetResourceId?: string;
}

// @public
export interface VnetParameters extends ProxyOnlyResource {
    subnetResourceId?: string;
    vnetName?: string;
    vnetResourceGroup?: string;
    vnetSubnetName?: string;
}

// @public
export interface VnetRoute extends ProxyOnlyResource {
    endAddress?: string;
    routeType?: RouteType;
    startAddress?: string;
}

// @public
export interface VnetValidationFailureDetails extends ProxyOnlyResource {
    failed?: boolean;
    failedTests?: VnetValidationTestFailure[];
    message?: string;
    warnings?: VnetValidationTestFailure[];
}

// @public
export interface VnetValidationTestFailure extends ProxyOnlyResource {
    details?: string;
    testName?: string;
}

// @public (undocumented)
export interface VolumeMount {
    containerMountPath: string;
    data?: string;
    readOnly?: boolean;
    volumeSubPath: string;
}

// @public
export interface WebAppCollection {
    readonly nextLink?: string;
    value: Site[];
}

// @public
export interface WebAppInstanceStatusCollection {
    readonly nextLink?: string;
    value: WebSiteInstanceStatus[];
}

// @public
export interface WebAppMajorVersion {
    readonly displayText?: string;
    readonly minorVersions?: WebAppMinorVersion[];
    readonly value?: string;
}

// @public
export interface WebAppMinorVersion {
    readonly displayText?: string;
    readonly stackSettings?: WebAppRuntimes;
    readonly value?: string;
}

// @public
export interface WebAppRuntimes {
    readonly linuxContainerSettings?: LinuxJavaContainerSettings;
    readonly linuxRuntimeSettings?: WebAppRuntimeSettings;
    readonly windowsContainerSettings?: WindowsJavaContainerSettings;
    readonly windowsRuntimeSettings?: WebAppRuntimeSettings;
}

// @public
export interface WebAppRuntimeSettings {
    readonly appInsightsSettings?: AppInsightsWebAppStackSettings;
    readonly endOfLifeDate?: Date;
    readonly gitHubActionSettings?: GitHubActionWebAppStackSettings;
    readonly isAutoUpdate?: boolean;
    readonly isDeprecated?: boolean;
    readonly isEarlyAccess?: boolean;
    readonly isHidden?: boolean;
    readonly isPreview?: boolean;
    readonly remoteDebuggingSupported?: boolean;
    readonly runtimeVersion?: string;
}

// @public
export interface WebApps {
    addPremierAddOn(resourceGroupName: string, name: string, premierAddOnName: string, premierAddOn: PremierAddOn, options?: WebAppsAddPremierAddOnOptionalParams): Promise<WebAppsAddPremierAddOnResponse>;
    addPremierAddOnSlot(resourceGroupName: string, name: string, premierAddOnName: string, slot: string, premierAddOn: PremierAddOn, options?: WebAppsAddPremierAddOnSlotOptionalParams): Promise<WebAppsAddPremierAddOnSlotResponse>;
    analyzeCustomHostname(resourceGroupName: string, name: string, options?: WebAppsAnalyzeCustomHostnameOptionalParams): Promise<WebAppsAnalyzeCustomHostnameResponse>;
    analyzeCustomHostnameSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsAnalyzeCustomHostnameSlotOptionalParams): Promise<WebAppsAnalyzeCustomHostnameSlotResponse>;
    applySlotConfigToProduction(resourceGroupName: string, name: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsApplySlotConfigToProductionOptionalParams): Promise<void>;
    applySlotConfigurationSlot(resourceGroupName: string, name: string, slot: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsApplySlotConfigurationSlotOptionalParams): Promise<void>;
    backup(resourceGroupName: string, name: string, request: BackupRequest, options?: WebAppsBackupOptionalParams): Promise<WebAppsBackupResponse>;
    backupSlot(resourceGroupName: string, name: string, slot: string, request: BackupRequest, options?: WebAppsBackupSlotOptionalParams): Promise<WebAppsBackupSlotResponse>;
    beginApproveOrRejectPrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: WebAppsApproveOrRejectPrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsApproveOrRejectPrivateEndpointConnectionResponse>, WebAppsApproveOrRejectPrivateEndpointConnectionResponse>>;
    beginApproveOrRejectPrivateEndpointConnectionAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: WebAppsApproveOrRejectPrivateEndpointConnectionOptionalParams): Promise<WebAppsApproveOrRejectPrivateEndpointConnectionResponse>;
    beginApproveOrRejectPrivateEndpointConnectionSlot(resourceGroupName: string, name: string, privateEndpointConnectionName: string, slot: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: WebAppsApproveOrRejectPrivateEndpointConnectionSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsApproveOrRejectPrivateEndpointConnectionSlotResponse>, WebAppsApproveOrRejectPrivateEndpointConnectionSlotResponse>>;
    beginApproveOrRejectPrivateEndpointConnectionSlotAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, slot: string, privateEndpointWrapper: RemotePrivateEndpointConnectionARMResource, options?: WebAppsApproveOrRejectPrivateEndpointConnectionSlotOptionalParams): Promise<WebAppsApproveOrRejectPrivateEndpointConnectionSlotResponse>;
    beginCreateFunction(resourceGroupName: string, name: string, functionName: string, functionEnvelope: FunctionEnvelope, options?: WebAppsCreateFunctionOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateFunctionResponse>, WebAppsCreateFunctionResponse>>;
    beginCreateFunctionAndWait(resourceGroupName: string, name: string, functionName: string, functionEnvelope: FunctionEnvelope, options?: WebAppsCreateFunctionOptionalParams): Promise<WebAppsCreateFunctionResponse>;
    beginCreateInstanceFunctionSlot(resourceGroupName: string, name: string, functionName: string, slot: string, functionEnvelope: FunctionEnvelope, options?: WebAppsCreateInstanceFunctionSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateInstanceFunctionSlotResponse>, WebAppsCreateInstanceFunctionSlotResponse>>;
    beginCreateInstanceFunctionSlotAndWait(resourceGroupName: string, name: string, functionName: string, slot: string, functionEnvelope: FunctionEnvelope, options?: WebAppsCreateInstanceFunctionSlotOptionalParams): Promise<WebAppsCreateInstanceFunctionSlotResponse>;
    beginCreateInstanceMSDeployOperation(resourceGroupName: string, name: string, instanceId: string, mSDeploy: MSDeploy, options?: WebAppsCreateInstanceMSDeployOperationOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateInstanceMSDeployOperationResponse>, WebAppsCreateInstanceMSDeployOperationResponse>>;
    beginCreateInstanceMSDeployOperationAndWait(resourceGroupName: string, name: string, instanceId: string, mSDeploy: MSDeploy, options?: WebAppsCreateInstanceMSDeployOperationOptionalParams): Promise<WebAppsCreateInstanceMSDeployOperationResponse>;
    beginCreateInstanceMSDeployOperationSlot(resourceGroupName: string, name: string, slot: string, instanceId: string, mSDeploy: MSDeploy, options?: WebAppsCreateInstanceMSDeployOperationSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateInstanceMSDeployOperationSlotResponse>, WebAppsCreateInstanceMSDeployOperationSlotResponse>>;
    beginCreateInstanceMSDeployOperationSlotAndWait(resourceGroupName: string, name: string, slot: string, instanceId: string, mSDeploy: MSDeploy, options?: WebAppsCreateInstanceMSDeployOperationSlotOptionalParams): Promise<WebAppsCreateInstanceMSDeployOperationSlotResponse>;
    beginCreateMSDeployOperation(resourceGroupName: string, name: string, mSDeploy: MSDeploy, options?: WebAppsCreateMSDeployOperationOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateMSDeployOperationResponse>, WebAppsCreateMSDeployOperationResponse>>;
    beginCreateMSDeployOperationAndWait(resourceGroupName: string, name: string, mSDeploy: MSDeploy, options?: WebAppsCreateMSDeployOperationOptionalParams): Promise<WebAppsCreateMSDeployOperationResponse>;
    beginCreateMSDeployOperationSlot(resourceGroupName: string, name: string, slot: string, mSDeploy: MSDeploy, options?: WebAppsCreateMSDeployOperationSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateMSDeployOperationSlotResponse>, WebAppsCreateMSDeployOperationSlotResponse>>;
    beginCreateMSDeployOperationSlotAndWait(resourceGroupName: string, name: string, slot: string, mSDeploy: MSDeploy, options?: WebAppsCreateMSDeployOperationSlotOptionalParams): Promise<WebAppsCreateMSDeployOperationSlotResponse>;
    beginCreateOrUpdate(resourceGroupName: string, name: string, siteEnvelope: Site, options?: WebAppsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateOrUpdateResponse>, WebAppsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, name: string, siteEnvelope: Site, options?: WebAppsCreateOrUpdateOptionalParams): Promise<WebAppsCreateOrUpdateResponse>;
    beginCreateOrUpdateSlot(resourceGroupName: string, name: string, slot: string, siteEnvelope: Site, options?: WebAppsCreateOrUpdateSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateOrUpdateSlotResponse>, WebAppsCreateOrUpdateSlotResponse>>;
    beginCreateOrUpdateSlotAndWait(resourceGroupName: string, name: string, slot: string, siteEnvelope: Site, options?: WebAppsCreateOrUpdateSlotOptionalParams): Promise<WebAppsCreateOrUpdateSlotResponse>;
    beginCreateOrUpdateSourceControl(resourceGroupName: string, name: string, siteSourceControl: SiteSourceControl, options?: WebAppsCreateOrUpdateSourceControlOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateOrUpdateSourceControlResponse>, WebAppsCreateOrUpdateSourceControlResponse>>;
    beginCreateOrUpdateSourceControlAndWait(resourceGroupName: string, name: string, siteSourceControl: SiteSourceControl, options?: WebAppsCreateOrUpdateSourceControlOptionalParams): Promise<WebAppsCreateOrUpdateSourceControlResponse>;
    beginCreateOrUpdateSourceControlSlot(resourceGroupName: string, name: string, slot: string, siteSourceControl: SiteSourceControl, options?: WebAppsCreateOrUpdateSourceControlSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsCreateOrUpdateSourceControlSlotResponse>, WebAppsCreateOrUpdateSourceControlSlotResponse>>;
    beginCreateOrUpdateSourceControlSlotAndWait(resourceGroupName: string, name: string, slot: string, siteSourceControl: SiteSourceControl, options?: WebAppsCreateOrUpdateSourceControlSlotOptionalParams): Promise<WebAppsCreateOrUpdateSourceControlSlotResponse>;
    beginDeletePrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: WebAppsDeletePrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsDeletePrivateEndpointConnectionResponse>, WebAppsDeletePrivateEndpointConnectionResponse>>;
    beginDeletePrivateEndpointConnectionAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: WebAppsDeletePrivateEndpointConnectionOptionalParams): Promise<WebAppsDeletePrivateEndpointConnectionResponse>;
    beginDeletePrivateEndpointConnectionSlot(resourceGroupName: string, name: string, privateEndpointConnectionName: string, slot: string, options?: WebAppsDeletePrivateEndpointConnectionSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsDeletePrivateEndpointConnectionSlotResponse>, WebAppsDeletePrivateEndpointConnectionSlotResponse>>;
    beginDeletePrivateEndpointConnectionSlotAndWait(resourceGroupName: string, name: string, privateEndpointConnectionName: string, slot: string, options?: WebAppsDeletePrivateEndpointConnectionSlotOptionalParams): Promise<WebAppsDeletePrivateEndpointConnectionSlotResponse>;
    beginGetProductionSiteDeploymentStatus(resourceGroupName: string, name: string, deploymentStatusId: string, options?: WebAppsGetProductionSiteDeploymentStatusOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsGetProductionSiteDeploymentStatusResponse>, WebAppsGetProductionSiteDeploymentStatusResponse>>;
    beginGetProductionSiteDeploymentStatusAndWait(resourceGroupName: string, name: string, deploymentStatusId: string, options?: WebAppsGetProductionSiteDeploymentStatusOptionalParams): Promise<WebAppsGetProductionSiteDeploymentStatusResponse>;
    beginGetSlotSiteDeploymentStatusSlot(resourceGroupName: string, name: string, slot: string, deploymentStatusId: string, options?: WebAppsGetSlotSiteDeploymentStatusSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsGetSlotSiteDeploymentStatusSlotResponse>, WebAppsGetSlotSiteDeploymentStatusSlotResponse>>;
    beginGetSlotSiteDeploymentStatusSlotAndWait(resourceGroupName: string, name: string, slot: string, deploymentStatusId: string, options?: WebAppsGetSlotSiteDeploymentStatusSlotOptionalParams): Promise<WebAppsGetSlotSiteDeploymentStatusSlotResponse>;
    beginInstallSiteExtension(resourceGroupName: string, name: string, siteExtensionId: string, options?: WebAppsInstallSiteExtensionOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsInstallSiteExtensionResponse>, WebAppsInstallSiteExtensionResponse>>;
    beginInstallSiteExtensionAndWait(resourceGroupName: string, name: string, siteExtensionId: string, options?: WebAppsInstallSiteExtensionOptionalParams): Promise<WebAppsInstallSiteExtensionResponse>;
    beginInstallSiteExtensionSlot(resourceGroupName: string, name: string, siteExtensionId: string, slot: string, options?: WebAppsInstallSiteExtensionSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsInstallSiteExtensionSlotResponse>, WebAppsInstallSiteExtensionSlotResponse>>;
    beginInstallSiteExtensionSlotAndWait(resourceGroupName: string, name: string, siteExtensionId: string, slot: string, options?: WebAppsInstallSiteExtensionSlotOptionalParams): Promise<WebAppsInstallSiteExtensionSlotResponse>;
    beginListPublishingCredentials(resourceGroupName: string, name: string, options?: WebAppsListPublishingCredentialsOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsListPublishingCredentialsResponse>, WebAppsListPublishingCredentialsResponse>>;
    beginListPublishingCredentialsAndWait(resourceGroupName: string, name: string, options?: WebAppsListPublishingCredentialsOptionalParams): Promise<WebAppsListPublishingCredentialsResponse>;
    beginListPublishingCredentialsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListPublishingCredentialsSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsListPublishingCredentialsSlotResponse>, WebAppsListPublishingCredentialsSlotResponse>>;
    beginListPublishingCredentialsSlotAndWait(resourceGroupName: string, name: string, slot: string, options?: WebAppsListPublishingCredentialsSlotOptionalParams): Promise<WebAppsListPublishingCredentialsSlotResponse>;
    beginMigrateMySql(resourceGroupName: string, name: string, migrationRequestEnvelope: MigrateMySqlRequest, options?: WebAppsMigrateMySqlOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsMigrateMySqlResponse>, WebAppsMigrateMySqlResponse>>;
    beginMigrateMySqlAndWait(resourceGroupName: string, name: string, migrationRequestEnvelope: MigrateMySqlRequest, options?: WebAppsMigrateMySqlOptionalParams): Promise<WebAppsMigrateMySqlResponse>;
    beginMigrateStorage(subscriptionName: string, resourceGroupName: string, name: string, migrationOptions: StorageMigrationOptions, options?: WebAppsMigrateStorageOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsMigrateStorageResponse>, WebAppsMigrateStorageResponse>>;
    beginMigrateStorageAndWait(subscriptionName: string, resourceGroupName: string, name: string, migrationOptions: StorageMigrationOptions, options?: WebAppsMigrateStorageOptionalParams): Promise<WebAppsMigrateStorageResponse>;
    beginRestore(resourceGroupName: string, name: string, backupId: string, request: RestoreRequest, options?: WebAppsRestoreOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreAndWait(resourceGroupName: string, name: string, backupId: string, request: RestoreRequest, options?: WebAppsRestoreOptionalParams): Promise<void>;
    beginRestoreFromBackupBlob(resourceGroupName: string, name: string, request: RestoreRequest, options?: WebAppsRestoreFromBackupBlobOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreFromBackupBlobAndWait(resourceGroupName: string, name: string, request: RestoreRequest, options?: WebAppsRestoreFromBackupBlobOptionalParams): Promise<void>;
    beginRestoreFromBackupBlobSlot(resourceGroupName: string, name: string, slot: string, request: RestoreRequest, options?: WebAppsRestoreFromBackupBlobSlotOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreFromBackupBlobSlotAndWait(resourceGroupName: string, name: string, slot: string, request: RestoreRequest, options?: WebAppsRestoreFromBackupBlobSlotOptionalParams): Promise<void>;
    beginRestoreFromDeletedApp(resourceGroupName: string, name: string, restoreRequest: DeletedAppRestoreRequest, options?: WebAppsRestoreFromDeletedAppOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreFromDeletedAppAndWait(resourceGroupName: string, name: string, restoreRequest: DeletedAppRestoreRequest, options?: WebAppsRestoreFromDeletedAppOptionalParams): Promise<void>;
    beginRestoreFromDeletedAppSlot(resourceGroupName: string, name: string, slot: string, restoreRequest: DeletedAppRestoreRequest, options?: WebAppsRestoreFromDeletedAppSlotOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreFromDeletedAppSlotAndWait(resourceGroupName: string, name: string, slot: string, restoreRequest: DeletedAppRestoreRequest, options?: WebAppsRestoreFromDeletedAppSlotOptionalParams): Promise<void>;
    beginRestoreSlot(resourceGroupName: string, name: string, backupId: string, slot: string, request: RestoreRequest, options?: WebAppsRestoreSlotOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreSlotAndWait(resourceGroupName: string, name: string, backupId: string, slot: string, request: RestoreRequest, options?: WebAppsRestoreSlotOptionalParams): Promise<void>;
    beginRestoreSnapshot(resourceGroupName: string, name: string, restoreRequest: SnapshotRestoreRequest, options?: WebAppsRestoreSnapshotOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreSnapshotAndWait(resourceGroupName: string, name: string, restoreRequest: SnapshotRestoreRequest, options?: WebAppsRestoreSnapshotOptionalParams): Promise<void>;
    beginRestoreSnapshotSlot(resourceGroupName: string, name: string, slot: string, restoreRequest: SnapshotRestoreRequest, options?: WebAppsRestoreSnapshotSlotOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRestoreSnapshotSlotAndWait(resourceGroupName: string, name: string, slot: string, restoreRequest: SnapshotRestoreRequest, options?: WebAppsRestoreSnapshotSlotOptionalParams): Promise<void>;
    beginStartNetworkTrace(resourceGroupName: string, name: string, options?: WebAppsStartNetworkTraceOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsStartNetworkTraceResponse>, WebAppsStartNetworkTraceResponse>>;
    beginStartNetworkTraceAndWait(resourceGroupName: string, name: string, options?: WebAppsStartNetworkTraceOptionalParams): Promise<WebAppsStartNetworkTraceResponse>;
    beginStartNetworkTraceSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStartNetworkTraceSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsStartNetworkTraceSlotResponse>, WebAppsStartNetworkTraceSlotResponse>>;
    beginStartNetworkTraceSlotAndWait(resourceGroupName: string, name: string, slot: string, options?: WebAppsStartNetworkTraceSlotOptionalParams): Promise<WebAppsStartNetworkTraceSlotResponse>;
    beginStartWebSiteNetworkTraceOperation(resourceGroupName: string, name: string, options?: WebAppsStartWebSiteNetworkTraceOperationOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsStartWebSiteNetworkTraceOperationResponse>, WebAppsStartWebSiteNetworkTraceOperationResponse>>;
    beginStartWebSiteNetworkTraceOperationAndWait(resourceGroupName: string, name: string, options?: WebAppsStartWebSiteNetworkTraceOperationOptionalParams): Promise<WebAppsStartWebSiteNetworkTraceOperationResponse>;
    beginStartWebSiteNetworkTraceOperationSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStartWebSiteNetworkTraceOperationSlotOptionalParams): Promise<SimplePollerLike<OperationState<WebAppsStartWebSiteNetworkTraceOperationSlotResponse>, WebAppsStartWebSiteNetworkTraceOperationSlotResponse>>;
    beginStartWebSiteNetworkTraceOperationSlotAndWait(resourceGroupName: string, name: string, slot: string, options?: WebAppsStartWebSiteNetworkTraceOperationSlotOptionalParams): Promise<WebAppsStartWebSiteNetworkTraceOperationSlotResponse>;
    beginSwapSlot(resourceGroupName: string, name: string, slot: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsSwapSlotOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginSwapSlotAndWait(resourceGroupName: string, name: string, slot: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsSwapSlotOptionalParams): Promise<void>;
    beginSwapSlotWithProduction(resourceGroupName: string, name: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsSwapSlotWithProductionOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginSwapSlotWithProductionAndWait(resourceGroupName: string, name: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsSwapSlotWithProductionOptionalParams): Promise<void>;
    createDeployment(resourceGroupName: string, name: string, id: string, deployment: Deployment, options?: WebAppsCreateDeploymentOptionalParams): Promise<WebAppsCreateDeploymentResponse>;
    createDeploymentSlot(resourceGroupName: string, name: string, id: string, slot: string, deployment: Deployment, options?: WebAppsCreateDeploymentSlotOptionalParams): Promise<WebAppsCreateDeploymentSlotResponse>;
    createOneDeployOperation(resourceGroupName: string, name: string, options?: WebAppsCreateOneDeployOperationOptionalParams): Promise<WebAppsCreateOneDeployOperationResponse>;
    createOrUpdateConfiguration(resourceGroupName: string, name: string, siteConfig: SiteConfigResource, options?: WebAppsCreateOrUpdateConfigurationOptionalParams): Promise<WebAppsCreateOrUpdateConfigurationResponse>;
    createOrUpdateConfigurationSlot(resourceGroupName: string, name: string, slot: string, siteConfig: SiteConfigResource, options?: WebAppsCreateOrUpdateConfigurationSlotOptionalParams): Promise<WebAppsCreateOrUpdateConfigurationSlotResponse>;
    createOrUpdateDomainOwnershipIdentifier(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, domainOwnershipIdentifier: Identifier, options?: WebAppsCreateOrUpdateDomainOwnershipIdentifierOptionalParams): Promise<WebAppsCreateOrUpdateDomainOwnershipIdentifierResponse>;
    createOrUpdateDomainOwnershipIdentifierSlot(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, slot: string, domainOwnershipIdentifier: Identifier, options?: WebAppsCreateOrUpdateDomainOwnershipIdentifierSlotOptionalParams): Promise<WebAppsCreateOrUpdateDomainOwnershipIdentifierSlotResponse>;
    createOrUpdateFunctionSecret(resourceGroupName: string, name: string, functionName: string, keyName: string, key: KeyInfo, options?: WebAppsCreateOrUpdateFunctionSecretOptionalParams): Promise<WebAppsCreateOrUpdateFunctionSecretResponse>;
    createOrUpdateFunctionSecretSlot(resourceGroupName: string, name: string, functionName: string, keyName: string, slot: string, key: KeyInfo, options?: WebAppsCreateOrUpdateFunctionSecretSlotOptionalParams): Promise<WebAppsCreateOrUpdateFunctionSecretSlotResponse>;
    createOrUpdateHostNameBinding(resourceGroupName: string, name: string, hostName: string, hostNameBinding: HostNameBinding, options?: WebAppsCreateOrUpdateHostNameBindingOptionalParams): Promise<WebAppsCreateOrUpdateHostNameBindingResponse>;
    createOrUpdateHostNameBindingSlot(resourceGroupName: string, name: string, hostName: string, slot: string, hostNameBinding: HostNameBinding, options?: WebAppsCreateOrUpdateHostNameBindingSlotOptionalParams): Promise<WebAppsCreateOrUpdateHostNameBindingSlotResponse>;
    createOrUpdateHostSecret(resourceGroupName: string, name: string, keyType: string, keyName: string, key: KeyInfo, options?: WebAppsCreateOrUpdateHostSecretOptionalParams): Promise<WebAppsCreateOrUpdateHostSecretResponse>;
    createOrUpdateHostSecretSlot(resourceGroupName: string, name: string, keyType: string, keyName: string, slot: string, key: KeyInfo, options?: WebAppsCreateOrUpdateHostSecretSlotOptionalParams): Promise<WebAppsCreateOrUpdateHostSecretSlotResponse>;
    createOrUpdateHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, connectionEnvelope: HybridConnection, options?: WebAppsCreateOrUpdateHybridConnectionOptionalParams): Promise<WebAppsCreateOrUpdateHybridConnectionResponse>;
    createOrUpdateHybridConnectionSlot(resourceGroupName: string, name: string, namespaceName: string, relayName: string, slot: string, connectionEnvelope: HybridConnection, options?: WebAppsCreateOrUpdateHybridConnectionSlotOptionalParams): Promise<WebAppsCreateOrUpdateHybridConnectionSlotResponse>;
    createOrUpdatePublicCertificate(resourceGroupName: string, name: string, publicCertificateName: string, publicCertificate: PublicCertificate, options?: WebAppsCreateOrUpdatePublicCertificateOptionalParams): Promise<WebAppsCreateOrUpdatePublicCertificateResponse>;
    createOrUpdatePublicCertificateSlot(resourceGroupName: string, name: string, publicCertificateName: string, slot: string, publicCertificate: PublicCertificate, options?: WebAppsCreateOrUpdatePublicCertificateSlotOptionalParams): Promise<WebAppsCreateOrUpdatePublicCertificateSlotResponse>;
    createOrUpdateRelayServiceConnection(resourceGroupName: string, name: string, entityName: string, connectionEnvelope: RelayServiceConnectionEntity, options?: WebAppsCreateOrUpdateRelayServiceConnectionOptionalParams): Promise<WebAppsCreateOrUpdateRelayServiceConnectionResponse>;
    createOrUpdateRelayServiceConnectionSlot(resourceGroupName: string, name: string, entityName: string, slot: string, connectionEnvelope: RelayServiceConnectionEntity, options?: WebAppsCreateOrUpdateRelayServiceConnectionSlotOptionalParams): Promise<WebAppsCreateOrUpdateRelayServiceConnectionSlotResponse>;
    createOrUpdateSiteContainer(resourceGroupName: string, name: string, containerName: string, request: SiteContainer, options?: WebAppsCreateOrUpdateSiteContainerOptionalParams): Promise<WebAppsCreateOrUpdateSiteContainerResponse>;
    createOrUpdateSiteContainerSlot(resourceGroupName: string, name: string, slot: string, containerName: string, request: SiteContainer, options?: WebAppsCreateOrUpdateSiteContainerSlotOptionalParams): Promise<WebAppsCreateOrUpdateSiteContainerSlotResponse>;
    createOrUpdateSwiftVirtualNetworkConnectionWithCheck(resourceGroupName: string, name: string, connectionEnvelope: SwiftVirtualNetwork, options?: WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckOptionalParams): Promise<WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckResponse>;
    createOrUpdateSwiftVirtualNetworkConnectionWithCheckSlot(resourceGroupName: string, name: string, slot: string, connectionEnvelope: SwiftVirtualNetwork, options?: WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckSlotOptionalParams): Promise<WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckSlotResponse>;
    createOrUpdateVnetConnection(resourceGroupName: string, name: string, vnetName: string, connectionEnvelope: VnetInfoResource, options?: WebAppsCreateOrUpdateVnetConnectionOptionalParams): Promise<WebAppsCreateOrUpdateVnetConnectionResponse>;
    createOrUpdateVnetConnectionGateway(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, connectionEnvelope: VnetGateway, options?: WebAppsCreateOrUpdateVnetConnectionGatewayOptionalParams): Promise<WebAppsCreateOrUpdateVnetConnectionGatewayResponse>;
    createOrUpdateVnetConnectionGatewaySlot(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, slot: string, connectionEnvelope: VnetGateway, options?: WebAppsCreateOrUpdateVnetConnectionGatewaySlotOptionalParams): Promise<WebAppsCreateOrUpdateVnetConnectionGatewaySlotResponse>;
    createOrUpdateVnetConnectionSlot(resourceGroupName: string, name: string, vnetName: string, slot: string, connectionEnvelope: VnetInfoResource, options?: WebAppsCreateOrUpdateVnetConnectionSlotOptionalParams): Promise<WebAppsCreateOrUpdateVnetConnectionSlotResponse>;
    delete(resourceGroupName: string, name: string, options?: WebAppsDeleteOptionalParams): Promise<void>;
    deleteBackup(resourceGroupName: string, name: string, backupId: string, options?: WebAppsDeleteBackupOptionalParams): Promise<void>;
    deleteBackupConfiguration(resourceGroupName: string, name: string, options?: WebAppsDeleteBackupConfigurationOptionalParams): Promise<void>;
    deleteBackupConfigurationSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsDeleteBackupConfigurationSlotOptionalParams): Promise<void>;
    deleteBackupSlot(resourceGroupName: string, name: string, backupId: string, slot: string, options?: WebAppsDeleteBackupSlotOptionalParams): Promise<void>;
    deleteContinuousWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsDeleteContinuousWebJobOptionalParams): Promise<void>;
    deleteContinuousWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsDeleteContinuousWebJobSlotOptionalParams): Promise<void>;
    deleteDeployment(resourceGroupName: string, name: string, id: string, options?: WebAppsDeleteDeploymentOptionalParams): Promise<void>;
    deleteDeploymentSlot(resourceGroupName: string, name: string, id: string, slot: string, options?: WebAppsDeleteDeploymentSlotOptionalParams): Promise<void>;
    deleteDomainOwnershipIdentifier(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, options?: WebAppsDeleteDomainOwnershipIdentifierOptionalParams): Promise<void>;
    deleteDomainOwnershipIdentifierSlot(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, slot: string, options?: WebAppsDeleteDomainOwnershipIdentifierSlotOptionalParams): Promise<void>;
    deleteFunction(resourceGroupName: string, name: string, functionName: string, options?: WebAppsDeleteFunctionOptionalParams): Promise<void>;
    deleteFunctionSecret(resourceGroupName: string, name: string, functionName: string, keyName: string, options?: WebAppsDeleteFunctionSecretOptionalParams): Promise<void>;
    deleteFunctionSecretSlot(resourceGroupName: string, name: string, functionName: string, keyName: string, slot: string, options?: WebAppsDeleteFunctionSecretSlotOptionalParams): Promise<void>;
    deleteHostNameBinding(resourceGroupName: string, name: string, hostName: string, options?: WebAppsDeleteHostNameBindingOptionalParams): Promise<void>;
    deleteHostNameBindingSlot(resourceGroupName: string, name: string, slot: string, hostName: string, options?: WebAppsDeleteHostNameBindingSlotOptionalParams): Promise<void>;
    deleteHostSecret(resourceGroupName: string, name: string, keyType: string, keyName: string, options?: WebAppsDeleteHostSecretOptionalParams): Promise<void>;
    deleteHostSecretSlot(resourceGroupName: string, name: string, keyType: string, keyName: string, slot: string, options?: WebAppsDeleteHostSecretSlotOptionalParams): Promise<void>;
    deleteHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, options?: WebAppsDeleteHybridConnectionOptionalParams): Promise<void>;
    deleteHybridConnectionSlot(resourceGroupName: string, name: string, namespaceName: string, relayName: string, slot: string, options?: WebAppsDeleteHybridConnectionSlotOptionalParams): Promise<void>;
    deleteInstanceFunctionSlot(resourceGroupName: string, name: string, functionName: string, slot: string, options?: WebAppsDeleteInstanceFunctionSlotOptionalParams): Promise<void>;
    deleteInstanceProcess(resourceGroupName: string, name: string, processId: string, instanceId: string, options?: WebAppsDeleteInstanceProcessOptionalParams): Promise<void>;
    deleteInstanceProcessSlot(resourceGroupName: string, name: string, processId: string, slot: string, instanceId: string, options?: WebAppsDeleteInstanceProcessSlotOptionalParams): Promise<void>;
    deletePremierAddOn(resourceGroupName: string, name: string, premierAddOnName: string, options?: WebAppsDeletePremierAddOnOptionalParams): Promise<void>;
    deletePremierAddOnSlot(resourceGroupName: string, name: string, premierAddOnName: string, slot: string, options?: WebAppsDeletePremierAddOnSlotOptionalParams): Promise<void>;
    deleteProcess(resourceGroupName: string, name: string, processId: string, options?: WebAppsDeleteProcessOptionalParams): Promise<void>;
    deleteProcessSlot(resourceGroupName: string, name: string, processId: string, slot: string, options?: WebAppsDeleteProcessSlotOptionalParams): Promise<void>;
    deletePublicCertificate(resourceGroupName: string, name: string, publicCertificateName: string, options?: WebAppsDeletePublicCertificateOptionalParams): Promise<void>;
    deletePublicCertificateSlot(resourceGroupName: string, name: string, slot: string, publicCertificateName: string, options?: WebAppsDeletePublicCertificateSlotOptionalParams): Promise<void>;
    deleteRelayServiceConnection(resourceGroupName: string, name: string, entityName: string, options?: WebAppsDeleteRelayServiceConnectionOptionalParams): Promise<void>;
    deleteRelayServiceConnectionSlot(resourceGroupName: string, name: string, entityName: string, slot: string, options?: WebAppsDeleteRelayServiceConnectionSlotOptionalParams): Promise<void>;
    deleteSiteContainer(resourceGroupName: string, name: string, containerName: string, options?: WebAppsDeleteSiteContainerOptionalParams): Promise<void>;
    deleteSiteContainerSlot(resourceGroupName: string, name: string, slot: string, containerName: string, options?: WebAppsDeleteSiteContainerSlotOptionalParams): Promise<void>;
    deleteSiteExtension(resourceGroupName: string, name: string, siteExtensionId: string, options?: WebAppsDeleteSiteExtensionOptionalParams): Promise<void>;
    deleteSiteExtensionSlot(resourceGroupName: string, name: string, siteExtensionId: string, slot: string, options?: WebAppsDeleteSiteExtensionSlotOptionalParams): Promise<void>;
    deleteSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsDeleteSlotOptionalParams): Promise<void>;
    deleteSourceControl(resourceGroupName: string, name: string, options?: WebAppsDeleteSourceControlOptionalParams): Promise<void>;
    deleteSourceControlSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsDeleteSourceControlSlotOptionalParams): Promise<void>;
    deleteSwiftVirtualNetwork(resourceGroupName: string, name: string, options?: WebAppsDeleteSwiftVirtualNetworkOptionalParams): Promise<void>;
    deleteSwiftVirtualNetworkSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsDeleteSwiftVirtualNetworkSlotOptionalParams): Promise<void>;
    deleteTriggeredWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsDeleteTriggeredWebJobOptionalParams): Promise<void>;
    deleteTriggeredWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsDeleteTriggeredWebJobSlotOptionalParams): Promise<void>;
    deleteVnetConnection(resourceGroupName: string, name: string, vnetName: string, options?: WebAppsDeleteVnetConnectionOptionalParams): Promise<void>;
    deleteVnetConnectionSlot(resourceGroupName: string, name: string, vnetName: string, slot: string, options?: WebAppsDeleteVnetConnectionSlotOptionalParams): Promise<void>;
    deployWorkflowArtifacts(resourceGroupName: string, name: string, options?: WebAppsDeployWorkflowArtifactsOptionalParams): Promise<void>;
    deployWorkflowArtifactsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsDeployWorkflowArtifactsSlotOptionalParams): Promise<void>;
    discoverBackup(resourceGroupName: string, name: string, request: RestoreRequest, options?: WebAppsDiscoverBackupOptionalParams): Promise<WebAppsDiscoverBackupResponse>;
    discoverBackupSlot(resourceGroupName: string, name: string, slot: string, request: RestoreRequest, options?: WebAppsDiscoverBackupSlotOptionalParams): Promise<WebAppsDiscoverBackupSlotResponse>;
    generateNewSitePublishingPassword(resourceGroupName: string, name: string, options?: WebAppsGenerateNewSitePublishingPasswordOptionalParams): Promise<void>;
    generateNewSitePublishingPasswordSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGenerateNewSitePublishingPasswordSlotOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, options?: WebAppsGetOptionalParams): Promise<WebAppsGetResponse>;
    getAppSettingKeyVaultReference(resourceGroupName: string, name: string, appSettingKey: string, options?: WebAppsGetAppSettingKeyVaultReferenceOptionalParams): Promise<WebAppsGetAppSettingKeyVaultReferenceResponse>;
    getAppSettingKeyVaultReferenceSlot(resourceGroupName: string, name: string, appSettingKey: string, slot: string, options?: WebAppsGetAppSettingKeyVaultReferenceSlotOptionalParams): Promise<WebAppsGetAppSettingKeyVaultReferenceSlotResponse>;
    getAuthSettings(resourceGroupName: string, name: string, options?: WebAppsGetAuthSettingsOptionalParams): Promise<WebAppsGetAuthSettingsResponse>;
    getAuthSettingsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetAuthSettingsSlotOptionalParams): Promise<WebAppsGetAuthSettingsSlotResponse>;
    getAuthSettingsV2(resourceGroupName: string, name: string, options?: WebAppsGetAuthSettingsV2OptionalParams): Promise<WebAppsGetAuthSettingsV2Response>;
    getAuthSettingsV2Slot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetAuthSettingsV2SlotOptionalParams): Promise<WebAppsGetAuthSettingsV2SlotResponse>;
    getAuthSettingsV2WithoutSecrets(resourceGroupName: string, name: string, options?: WebAppsGetAuthSettingsV2WithoutSecretsOptionalParams): Promise<WebAppsGetAuthSettingsV2WithoutSecretsResponse>;
    getAuthSettingsV2WithoutSecretsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetAuthSettingsV2WithoutSecretsSlotOptionalParams): Promise<WebAppsGetAuthSettingsV2WithoutSecretsSlotResponse>;
    getBackupConfiguration(resourceGroupName: string, name: string, options?: WebAppsGetBackupConfigurationOptionalParams): Promise<WebAppsGetBackupConfigurationResponse>;
    getBackupConfigurationSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetBackupConfigurationSlotOptionalParams): Promise<WebAppsGetBackupConfigurationSlotResponse>;
    getBackupStatus(resourceGroupName: string, name: string, backupId: string, options?: WebAppsGetBackupStatusOptionalParams): Promise<WebAppsGetBackupStatusResponse>;
    getBackupStatusSlot(resourceGroupName: string, name: string, backupId: string, slot: string, options?: WebAppsGetBackupStatusSlotOptionalParams): Promise<WebAppsGetBackupStatusSlotResponse>;
    getConfiguration(resourceGroupName: string, name: string, options?: WebAppsGetConfigurationOptionalParams): Promise<WebAppsGetConfigurationResponse>;
    getConfigurationSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetConfigurationSlotOptionalParams): Promise<WebAppsGetConfigurationSlotResponse>;
    getConfigurationSnapshot(resourceGroupName: string, name: string, snapshotId: string, options?: WebAppsGetConfigurationSnapshotOptionalParams): Promise<WebAppsGetConfigurationSnapshotResponse>;
    getConfigurationSnapshotSlot(resourceGroupName: string, name: string, snapshotId: string, slot: string, options?: WebAppsGetConfigurationSnapshotSlotOptionalParams): Promise<WebAppsGetConfigurationSnapshotSlotResponse>;
    getContainerLogsZip(resourceGroupName: string, name: string, options?: WebAppsGetContainerLogsZipOptionalParams): Promise<WebAppsGetContainerLogsZipResponse>;
    getContainerLogsZipSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetContainerLogsZipSlotOptionalParams): Promise<WebAppsGetContainerLogsZipSlotResponse>;
    getContinuousWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsGetContinuousWebJobOptionalParams): Promise<WebAppsGetContinuousWebJobResponse>;
    getContinuousWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsGetContinuousWebJobSlotOptionalParams): Promise<WebAppsGetContinuousWebJobSlotResponse>;
    getDeployment(resourceGroupName: string, name: string, id: string, options?: WebAppsGetDeploymentOptionalParams): Promise<WebAppsGetDeploymentResponse>;
    getDeploymentSlot(resourceGroupName: string, name: string, id: string, slot: string, options?: WebAppsGetDeploymentSlotOptionalParams): Promise<WebAppsGetDeploymentSlotResponse>;
    getDiagnosticLogsConfiguration(resourceGroupName: string, name: string, options?: WebAppsGetDiagnosticLogsConfigurationOptionalParams): Promise<WebAppsGetDiagnosticLogsConfigurationResponse>;
    getDiagnosticLogsConfigurationSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetDiagnosticLogsConfigurationSlotOptionalParams): Promise<WebAppsGetDiagnosticLogsConfigurationSlotResponse>;
    getDomainOwnershipIdentifier(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, options?: WebAppsGetDomainOwnershipIdentifierOptionalParams): Promise<WebAppsGetDomainOwnershipIdentifierResponse>;
    getDomainOwnershipIdentifierSlot(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, slot: string, options?: WebAppsGetDomainOwnershipIdentifierSlotOptionalParams): Promise<WebAppsGetDomainOwnershipIdentifierSlotResponse>;
    getFtpAllowed(resourceGroupName: string, name: string, options?: WebAppsGetFtpAllowedOptionalParams): Promise<WebAppsGetFtpAllowedResponse>;
    getFtpAllowedSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetFtpAllowedSlotOptionalParams): Promise<WebAppsGetFtpAllowedSlotResponse>;
    getFunction(resourceGroupName: string, name: string, functionName: string, options?: WebAppsGetFunctionOptionalParams): Promise<WebAppsGetFunctionResponse>;
    getFunctionsAdminToken(resourceGroupName: string, name: string, options?: WebAppsGetFunctionsAdminTokenOptionalParams): Promise<WebAppsGetFunctionsAdminTokenResponse>;
    getFunctionsAdminTokenSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetFunctionsAdminTokenSlotOptionalParams): Promise<WebAppsGetFunctionsAdminTokenSlotResponse>;
    getHostNameBinding(resourceGroupName: string, name: string, hostName: string, options?: WebAppsGetHostNameBindingOptionalParams): Promise<WebAppsGetHostNameBindingResponse>;
    getHostNameBindingSlot(resourceGroupName: string, name: string, slot: string, hostName: string, options?: WebAppsGetHostNameBindingSlotOptionalParams): Promise<WebAppsGetHostNameBindingSlotResponse>;
    getHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, options?: WebAppsGetHybridConnectionOptionalParams): Promise<WebAppsGetHybridConnectionResponse>;
    getHybridConnectionSlot(resourceGroupName: string, name: string, namespaceName: string, relayName: string, slot: string, options?: WebAppsGetHybridConnectionSlotOptionalParams): Promise<WebAppsGetHybridConnectionSlotResponse>;
    getInstanceFunctionSlot(resourceGroupName: string, name: string, functionName: string, slot: string, options?: WebAppsGetInstanceFunctionSlotOptionalParams): Promise<WebAppsGetInstanceFunctionSlotResponse>;
    getInstanceInfo(resourceGroupName: string, name: string, instanceId: string, options?: WebAppsGetInstanceInfoOptionalParams): Promise<WebAppsGetInstanceInfoResponse>;
    getInstanceInfoSlot(resourceGroupName: string, name: string, instanceId: string, slot: string, options?: WebAppsGetInstanceInfoSlotOptionalParams): Promise<WebAppsGetInstanceInfoSlotResponse>;
    getInstanceMSDeployLog(resourceGroupName: string, name: string, instanceId: string, options?: WebAppsGetInstanceMSDeployLogOptionalParams): Promise<WebAppsGetInstanceMSDeployLogResponse>;
    getInstanceMSDeployLogSlot(resourceGroupName: string, name: string, slot: string, instanceId: string, options?: WebAppsGetInstanceMSDeployLogSlotOptionalParams): Promise<WebAppsGetInstanceMSDeployLogSlotResponse>;
    getInstanceMsDeployStatus(resourceGroupName: string, name: string, instanceId: string, options?: WebAppsGetInstanceMsDeployStatusOptionalParams): Promise<WebAppsGetInstanceMsDeployStatusResponse>;
    getInstanceMsDeployStatusSlot(resourceGroupName: string, name: string, slot: string, instanceId: string, options?: WebAppsGetInstanceMsDeployStatusSlotOptionalParams): Promise<WebAppsGetInstanceMsDeployStatusSlotResponse>;
    getInstanceProcess(resourceGroupName: string, name: string, processId: string, instanceId: string, options?: WebAppsGetInstanceProcessOptionalParams): Promise<WebAppsGetInstanceProcessResponse>;
    getInstanceProcessDump(resourceGroupName: string, name: string, processId: string, instanceId: string, options?: WebAppsGetInstanceProcessDumpOptionalParams): Promise<WebAppsGetInstanceProcessDumpResponse>;
    getInstanceProcessDumpSlot(resourceGroupName: string, name: string, processId: string, slot: string, instanceId: string, options?: WebAppsGetInstanceProcessDumpSlotOptionalParams): Promise<WebAppsGetInstanceProcessDumpSlotResponse>;
    getInstanceProcessModule(resourceGroupName: string, name: string, processId: string, baseAddress: string, instanceId: string, options?: WebAppsGetInstanceProcessModuleOptionalParams): Promise<WebAppsGetInstanceProcessModuleResponse>;
    getInstanceProcessModuleSlot(resourceGroupName: string, name: string, processId: string, baseAddress: string, slot: string, instanceId: string, options?: WebAppsGetInstanceProcessModuleSlotOptionalParams): Promise<WebAppsGetInstanceProcessModuleSlotResponse>;
    getInstanceProcessSlot(resourceGroupName: string, name: string, processId: string, slot: string, instanceId: string, options?: WebAppsGetInstanceProcessSlotOptionalParams): Promise<WebAppsGetInstanceProcessSlotResponse>;
    getInstanceWorkflowSlot(resourceGroupName: string, name: string, slot: string, workflowName: string, options?: WebAppsGetInstanceWorkflowSlotOptionalParams): Promise<WebAppsGetInstanceWorkflowSlotResponse>;
    getMigrateMySqlStatus(resourceGroupName: string, name: string, options?: WebAppsGetMigrateMySqlStatusOptionalParams): Promise<WebAppsGetMigrateMySqlStatusResponse>;
    getMigrateMySqlStatusSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetMigrateMySqlStatusSlotOptionalParams): Promise<WebAppsGetMigrateMySqlStatusSlotResponse>;
    getMSDeployLog(resourceGroupName: string, name: string, options?: WebAppsGetMSDeployLogOptionalParams): Promise<WebAppsGetMSDeployLogResponse>;
    getMSDeployLogSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetMSDeployLogSlotOptionalParams): Promise<WebAppsGetMSDeployLogSlotResponse>;
    getMSDeployStatus(resourceGroupName: string, name: string, options?: WebAppsGetMSDeployStatusOptionalParams): Promise<WebAppsGetMSDeployStatusResponse>;
    getMSDeployStatusSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetMSDeployStatusSlotOptionalParams): Promise<WebAppsGetMSDeployStatusSlotResponse>;
    getNetworkTraceOperation(resourceGroupName: string, name: string, operationId: string, options?: WebAppsGetNetworkTraceOperationOptionalParams): Promise<WebAppsGetNetworkTraceOperationResponse>;
    getNetworkTraceOperationSlot(resourceGroupName: string, name: string, operationId: string, slot: string, options?: WebAppsGetNetworkTraceOperationSlotOptionalParams): Promise<WebAppsGetNetworkTraceOperationSlotResponse>;
    getNetworkTraceOperationSlotV2(resourceGroupName: string, name: string, operationId: string, slot: string, options?: WebAppsGetNetworkTraceOperationSlotV2OptionalParams): Promise<WebAppsGetNetworkTraceOperationSlotV2Response>;
    getNetworkTraceOperationV2(resourceGroupName: string, name: string, operationId: string, options?: WebAppsGetNetworkTraceOperationV2OptionalParams): Promise<WebAppsGetNetworkTraceOperationV2Response>;
    getNetworkTraces(resourceGroupName: string, name: string, operationId: string, options?: WebAppsGetNetworkTracesOptionalParams): Promise<WebAppsGetNetworkTracesResponse>;
    getNetworkTracesSlot(resourceGroupName: string, name: string, operationId: string, slot: string, options?: WebAppsGetNetworkTracesSlotOptionalParams): Promise<WebAppsGetNetworkTracesSlotResponse>;
    getNetworkTracesSlotV2(resourceGroupName: string, name: string, operationId: string, slot: string, options?: WebAppsGetNetworkTracesSlotV2OptionalParams): Promise<WebAppsGetNetworkTracesSlotV2Response>;
    getNetworkTracesV2(resourceGroupName: string, name: string, operationId: string, options?: WebAppsGetNetworkTracesV2OptionalParams): Promise<WebAppsGetNetworkTracesV2Response>;
    getOneDeployStatus(resourceGroupName: string, name: string, options?: WebAppsGetOneDeployStatusOptionalParams): Promise<WebAppsGetOneDeployStatusResponse>;
    getPremierAddOn(resourceGroupName: string, name: string, premierAddOnName: string, options?: WebAppsGetPremierAddOnOptionalParams): Promise<WebAppsGetPremierAddOnResponse>;
    getPremierAddOnSlot(resourceGroupName: string, name: string, premierAddOnName: string, slot: string, options?: WebAppsGetPremierAddOnSlotOptionalParams): Promise<WebAppsGetPremierAddOnSlotResponse>;
    getPrivateAccess(resourceGroupName: string, name: string, options?: WebAppsGetPrivateAccessOptionalParams): Promise<WebAppsGetPrivateAccessResponse>;
    getPrivateAccessSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetPrivateAccessSlotOptionalParams): Promise<WebAppsGetPrivateAccessSlotResponse>;
    getPrivateEndpointConnection(resourceGroupName: string, name: string, privateEndpointConnectionName: string, options?: WebAppsGetPrivateEndpointConnectionOptionalParams): Promise<WebAppsGetPrivateEndpointConnectionResponse>;
    getPrivateEndpointConnectionSlot(resourceGroupName: string, name: string, privateEndpointConnectionName: string, slot: string, options?: WebAppsGetPrivateEndpointConnectionSlotOptionalParams): Promise<WebAppsGetPrivateEndpointConnectionSlotResponse>;
    getPrivateLinkResources(resourceGroupName: string, name: string, options?: WebAppsGetPrivateLinkResourcesOptionalParams): Promise<WebAppsGetPrivateLinkResourcesResponse>;
    getPrivateLinkResourcesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetPrivateLinkResourcesSlotOptionalParams): Promise<WebAppsGetPrivateLinkResourcesSlotResponse>;
    getProcess(resourceGroupName: string, name: string, processId: string, options?: WebAppsGetProcessOptionalParams): Promise<WebAppsGetProcessResponse>;
    getProcessDump(resourceGroupName: string, name: string, processId: string, options?: WebAppsGetProcessDumpOptionalParams): Promise<WebAppsGetProcessDumpResponse>;
    getProcessDumpSlot(resourceGroupName: string, name: string, processId: string, slot: string, options?: WebAppsGetProcessDumpSlotOptionalParams): Promise<WebAppsGetProcessDumpSlotResponse>;
    getProcessModule(resourceGroupName: string, name: string, processId: string, baseAddress: string, options?: WebAppsGetProcessModuleOptionalParams): Promise<WebAppsGetProcessModuleResponse>;
    getProcessModuleSlot(resourceGroupName: string, name: string, processId: string, baseAddress: string, slot: string, options?: WebAppsGetProcessModuleSlotOptionalParams): Promise<WebAppsGetProcessModuleSlotResponse>;
    getProcessSlot(resourceGroupName: string, name: string, processId: string, slot: string, options?: WebAppsGetProcessSlotOptionalParams): Promise<WebAppsGetProcessSlotResponse>;
    getPublicCertificate(resourceGroupName: string, name: string, publicCertificateName: string, options?: WebAppsGetPublicCertificateOptionalParams): Promise<WebAppsGetPublicCertificateResponse>;
    getPublicCertificateSlot(resourceGroupName: string, name: string, slot: string, publicCertificateName: string, options?: WebAppsGetPublicCertificateSlotOptionalParams): Promise<WebAppsGetPublicCertificateSlotResponse>;
    getRelayServiceConnection(resourceGroupName: string, name: string, entityName: string, options?: WebAppsGetRelayServiceConnectionOptionalParams): Promise<WebAppsGetRelayServiceConnectionResponse>;
    getRelayServiceConnectionSlot(resourceGroupName: string, name: string, entityName: string, slot: string, options?: WebAppsGetRelayServiceConnectionSlotOptionalParams): Promise<WebAppsGetRelayServiceConnectionSlotResponse>;
    getScmAllowed(resourceGroupName: string, name: string, options?: WebAppsGetScmAllowedOptionalParams): Promise<WebAppsGetScmAllowedResponse>;
    getScmAllowedSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetScmAllowedSlotOptionalParams): Promise<WebAppsGetScmAllowedSlotResponse>;
    getSiteConnectionStringKeyVaultReference(resourceGroupName: string, name: string, connectionStringKey: string, options?: WebAppsGetSiteConnectionStringKeyVaultReferenceOptionalParams): Promise<WebAppsGetSiteConnectionStringKeyVaultReferenceResponse>;
    getSiteConnectionStringKeyVaultReferenceSlot(resourceGroupName: string, name: string, connectionStringKey: string, slot: string, options?: WebAppsGetSiteConnectionStringKeyVaultReferenceSlotOptionalParams): Promise<WebAppsGetSiteConnectionStringKeyVaultReferenceSlotResponse>;
    getSiteContainer(resourceGroupName: string, name: string, containerName: string, options?: WebAppsGetSiteContainerOptionalParams): Promise<WebAppsGetSiteContainerResponse>;
    getSiteContainerSlot(resourceGroupName: string, name: string, slot: string, containerName: string, options?: WebAppsGetSiteContainerSlotOptionalParams): Promise<WebAppsGetSiteContainerSlotResponse>;
    getSiteExtension(resourceGroupName: string, name: string, siteExtensionId: string, options?: WebAppsGetSiteExtensionOptionalParams): Promise<WebAppsGetSiteExtensionResponse>;
    getSiteExtensionSlot(resourceGroupName: string, name: string, siteExtensionId: string, slot: string, options?: WebAppsGetSiteExtensionSlotOptionalParams): Promise<WebAppsGetSiteExtensionSlotResponse>;
    getSitePhpErrorLogFlag(resourceGroupName: string, name: string, options?: WebAppsGetSitePhpErrorLogFlagOptionalParams): Promise<WebAppsGetSitePhpErrorLogFlagResponse>;
    getSitePhpErrorLogFlagSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetSitePhpErrorLogFlagSlotOptionalParams): Promise<WebAppsGetSitePhpErrorLogFlagSlotResponse>;
    getSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetSlotOptionalParams): Promise<WebAppsGetSlotResponse>;
    getSourceControl(resourceGroupName: string, name: string, options?: WebAppsGetSourceControlOptionalParams): Promise<WebAppsGetSourceControlResponse>;
    getSourceControlSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetSourceControlSlotOptionalParams): Promise<WebAppsGetSourceControlSlotResponse>;
    getSwiftVirtualNetworkConnection(resourceGroupName: string, name: string, options?: WebAppsGetSwiftVirtualNetworkConnectionOptionalParams): Promise<WebAppsGetSwiftVirtualNetworkConnectionResponse>;
    getSwiftVirtualNetworkConnectionSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetSwiftVirtualNetworkConnectionSlotOptionalParams): Promise<WebAppsGetSwiftVirtualNetworkConnectionSlotResponse>;
    getTriggeredWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsGetTriggeredWebJobOptionalParams): Promise<WebAppsGetTriggeredWebJobResponse>;
    getTriggeredWebJobHistory(resourceGroupName: string, name: string, webJobName: string, id: string, options?: WebAppsGetTriggeredWebJobHistoryOptionalParams): Promise<WebAppsGetTriggeredWebJobHistoryResponse>;
    getTriggeredWebJobHistorySlot(resourceGroupName: string, name: string, webJobName: string, id: string, slot: string, options?: WebAppsGetTriggeredWebJobHistorySlotOptionalParams): Promise<WebAppsGetTriggeredWebJobHistorySlotResponse>;
    getTriggeredWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsGetTriggeredWebJobSlotOptionalParams): Promise<WebAppsGetTriggeredWebJobSlotResponse>;
    getVnetConnection(resourceGroupName: string, name: string, vnetName: string, options?: WebAppsGetVnetConnectionOptionalParams): Promise<WebAppsGetVnetConnectionResponse>;
    getVnetConnectionGateway(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, options?: WebAppsGetVnetConnectionGatewayOptionalParams): Promise<WebAppsGetVnetConnectionGatewayResponse>;
    getVnetConnectionGatewaySlot(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, slot: string, options?: WebAppsGetVnetConnectionGatewaySlotOptionalParams): Promise<WebAppsGetVnetConnectionGatewaySlotResponse>;
    getVnetConnectionSlot(resourceGroupName: string, name: string, vnetName: string, slot: string, options?: WebAppsGetVnetConnectionSlotOptionalParams): Promise<WebAppsGetVnetConnectionSlotResponse>;
    getWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsGetWebJobOptionalParams): Promise<WebAppsGetWebJobResponse>;
    getWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsGetWebJobSlotOptionalParams): Promise<WebAppsGetWebJobSlotResponse>;
    getWebSiteContainerLogs(resourceGroupName: string, name: string, options?: WebAppsGetWebSiteContainerLogsOptionalParams): Promise<WebAppsGetWebSiteContainerLogsResponse>;
    getWebSiteContainerLogsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetWebSiteContainerLogsSlotOptionalParams): Promise<WebAppsGetWebSiteContainerLogsSlotResponse>;
    getWorkflow(resourceGroupName: string, name: string, workflowName: string, options?: WebAppsGetWorkflowOptionalParams): Promise<WebAppsGetWorkflowResponse>;
    isCloneable(resourceGroupName: string, name: string, options?: WebAppsIsCloneableOptionalParams): Promise<WebAppsIsCloneableResponse>;
    isCloneableSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsIsCloneableSlotOptionalParams): Promise<WebAppsIsCloneableSlotResponse>;
    list(options?: WebAppsListOptionalParams): PagedAsyncIterableIterator<Site>;
    listApplicationSettings(resourceGroupName: string, name: string, options?: WebAppsListApplicationSettingsOptionalParams): Promise<WebAppsListApplicationSettingsResponse>;
    listApplicationSettingsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListApplicationSettingsSlotOptionalParams): Promise<WebAppsListApplicationSettingsSlotResponse>;
    listAppSettingsKeyVaultReferences(resourceGroupName: string, name: string, options?: WebAppsGetAppSettingsKeyVaultReferencesOptionalParams): PagedAsyncIterableIterator<ApiKVReference>;
    listAppSettingsKeyVaultReferencesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetAppSettingsKeyVaultReferencesSlotOptionalParams): PagedAsyncIterableIterator<ApiKVReference>;
    listAzureStorageAccounts(resourceGroupName: string, name: string, options?: WebAppsListAzureStorageAccountsOptionalParams): Promise<WebAppsListAzureStorageAccountsResponse>;
    listAzureStorageAccountsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListAzureStorageAccountsSlotOptionalParams): Promise<WebAppsListAzureStorageAccountsSlotResponse>;
    listBackups(resourceGroupName: string, name: string, options?: WebAppsListBackupsOptionalParams): PagedAsyncIterableIterator<BackupItem>;
    listBackupsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListBackupsSlotOptionalParams): PagedAsyncIterableIterator<BackupItem>;
    listBackupStatusSecrets(resourceGroupName: string, name: string, backupId: string, request: BackupRequest, options?: WebAppsListBackupStatusSecretsOptionalParams): Promise<WebAppsListBackupStatusSecretsResponse>;
    listBackupStatusSecretsSlot(resourceGroupName: string, name: string, backupId: string, slot: string, request: BackupRequest, options?: WebAppsListBackupStatusSecretsSlotOptionalParams): Promise<WebAppsListBackupStatusSecretsSlotResponse>;
    listBasicPublishingCredentialsPolicies(resourceGroupName: string, name: string, options?: WebAppsListBasicPublishingCredentialsPoliciesOptionalParams): PagedAsyncIterableIterator<CsmPublishingCredentialsPoliciesEntity>;
    listBasicPublishingCredentialsPoliciesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListBasicPublishingCredentialsPoliciesSlotOptionalParams): PagedAsyncIterableIterator<CsmPublishingCredentialsPoliciesEntity>;
    listByResourceGroup(resourceGroupName: string, options?: WebAppsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<Site>;
    listConfigurations(resourceGroupName: string, name: string, options?: WebAppsListConfigurationsOptionalParams): PagedAsyncIterableIterator<SiteConfigResource>;
    listConfigurationSnapshotInfo(resourceGroupName: string, name: string, options?: WebAppsListConfigurationSnapshotInfoOptionalParams): PagedAsyncIterableIterator<SiteConfigurationSnapshotInfo>;
    listConfigurationSnapshotInfoSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListConfigurationSnapshotInfoSlotOptionalParams): PagedAsyncIterableIterator<SiteConfigurationSnapshotInfo>;
    listConfigurationsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListConfigurationsSlotOptionalParams): PagedAsyncIterableIterator<SiteConfigResource>;
    listConnectionStrings(resourceGroupName: string, name: string, options?: WebAppsListConnectionStringsOptionalParams): Promise<WebAppsListConnectionStringsResponse>;
    listConnectionStringsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListConnectionStringsSlotOptionalParams): Promise<WebAppsListConnectionStringsSlotResponse>;
    listContinuousWebJobs(resourceGroupName: string, name: string, options?: WebAppsListContinuousWebJobsOptionalParams): PagedAsyncIterableIterator<ContinuousWebJob>;
    listContinuousWebJobsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListContinuousWebJobsSlotOptionalParams): PagedAsyncIterableIterator<ContinuousWebJob>;
    listDeploymentLog(resourceGroupName: string, name: string, id: string, options?: WebAppsListDeploymentLogOptionalParams): Promise<WebAppsListDeploymentLogResponse>;
    listDeploymentLogSlot(resourceGroupName: string, name: string, id: string, slot: string, options?: WebAppsListDeploymentLogSlotOptionalParams): Promise<WebAppsListDeploymentLogSlotResponse>;
    listDeployments(resourceGroupName: string, name: string, options?: WebAppsListDeploymentsOptionalParams): PagedAsyncIterableIterator<Deployment>;
    listDeploymentsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListDeploymentsSlotOptionalParams): PagedAsyncIterableIterator<Deployment>;
    listDomainOwnershipIdentifiers(resourceGroupName: string, name: string, options?: WebAppsListDomainOwnershipIdentifiersOptionalParams): PagedAsyncIterableIterator<Identifier>;
    listDomainOwnershipIdentifiersSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListDomainOwnershipIdentifiersSlotOptionalParams): PagedAsyncIterableIterator<Identifier>;
    listFunctionKeys(resourceGroupName: string, name: string, functionName: string, options?: WebAppsListFunctionKeysOptionalParams): Promise<WebAppsListFunctionKeysResponse>;
    listFunctionKeysSlot(resourceGroupName: string, name: string, functionName: string, slot: string, options?: WebAppsListFunctionKeysSlotOptionalParams): Promise<WebAppsListFunctionKeysSlotResponse>;
    listFunctions(resourceGroupName: string, name: string, options?: WebAppsListFunctionsOptionalParams): PagedAsyncIterableIterator<FunctionEnvelope>;
    listFunctionSecrets(resourceGroupName: string, name: string, functionName: string, options?: WebAppsListFunctionSecretsOptionalParams): Promise<WebAppsListFunctionSecretsResponse>;
    listFunctionSecretsSlot(resourceGroupName: string, name: string, functionName: string, slot: string, options?: WebAppsListFunctionSecretsSlotOptionalParams): Promise<WebAppsListFunctionSecretsSlotResponse>;
    listHostKeys(resourceGroupName: string, name: string, options?: WebAppsListHostKeysOptionalParams): Promise<WebAppsListHostKeysResponse>;
    listHostKeysSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListHostKeysSlotOptionalParams): Promise<WebAppsListHostKeysSlotResponse>;
    listHostNameBindings(resourceGroupName: string, name: string, options?: WebAppsListHostNameBindingsOptionalParams): PagedAsyncIterableIterator<HostNameBinding>;
    listHostNameBindingsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListHostNameBindingsSlotOptionalParams): PagedAsyncIterableIterator<HostNameBinding>;
    listHybridConnections(resourceGroupName: string, name: string, options?: WebAppsListHybridConnectionsOptionalParams): Promise<WebAppsListHybridConnectionsResponse>;
    listHybridConnectionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListHybridConnectionsSlotOptionalParams): Promise<WebAppsListHybridConnectionsSlotResponse>;
    listInstanceFunctionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListInstanceFunctionsSlotOptionalParams): PagedAsyncIterableIterator<FunctionEnvelope>;
    listInstanceIdentifiers(resourceGroupName: string, name: string, options?: WebAppsListInstanceIdentifiersOptionalParams): PagedAsyncIterableIterator<WebSiteInstanceStatus>;
    listInstanceIdentifiersSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListInstanceIdentifiersSlotOptionalParams): PagedAsyncIterableIterator<WebSiteInstanceStatus>;
    listInstanceProcesses(resourceGroupName: string, name: string, instanceId: string, options?: WebAppsListInstanceProcessesOptionalParams): PagedAsyncIterableIterator<ProcessInfo>;
    listInstanceProcessesSlot(resourceGroupName: string, name: string, slot: string, instanceId: string, options?: WebAppsListInstanceProcessesSlotOptionalParams): PagedAsyncIterableIterator<ProcessInfo>;
    listInstanceProcessModules(resourceGroupName: string, name: string, processId: string, instanceId: string, options?: WebAppsListInstanceProcessModulesOptionalParams): PagedAsyncIterableIterator<ProcessModuleInfo>;
    listInstanceProcessModulesSlot(resourceGroupName: string, name: string, processId: string, slot: string, instanceId: string, options?: WebAppsListInstanceProcessModulesSlotOptionalParams): PagedAsyncIterableIterator<ProcessModuleInfo>;
    listInstanceProcessThreads(resourceGroupName: string, name: string, processId: string, instanceId: string, options?: WebAppsListInstanceProcessThreadsOptionalParams): PagedAsyncIterableIterator<ProcessThreadInfo>;
    listInstanceProcessThreadsSlot(resourceGroupName: string, name: string, processId: string, slot: string, instanceId: string, options?: WebAppsListInstanceProcessThreadsSlotOptionalParams): PagedAsyncIterableIterator<ProcessThreadInfo>;
    listInstanceWorkflowsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListInstanceWorkflowsSlotOptionalParams): PagedAsyncIterableIterator<WorkflowEnvelope>;
    listMetadata(resourceGroupName: string, name: string, options?: WebAppsListMetadataOptionalParams): Promise<WebAppsListMetadataResponse>;
    listMetadataSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListMetadataSlotOptionalParams): Promise<WebAppsListMetadataSlotResponse>;
    listNetworkFeatures(resourceGroupName: string, name: string, view: string, options?: WebAppsListNetworkFeaturesOptionalParams): Promise<WebAppsListNetworkFeaturesResponse>;
    listNetworkFeaturesSlot(resourceGroupName: string, name: string, view: string, slot: string, options?: WebAppsListNetworkFeaturesSlotOptionalParams): Promise<WebAppsListNetworkFeaturesSlotResponse>;
    listPerfMonCounters(resourceGroupName: string, name: string, options?: WebAppsListPerfMonCountersOptionalParams): PagedAsyncIterableIterator<PerfMonResponse>;
    listPerfMonCountersSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListPerfMonCountersSlotOptionalParams): PagedAsyncIterableIterator<PerfMonResponse>;
    listPremierAddOns(resourceGroupName: string, name: string, options?: WebAppsListPremierAddOnsOptionalParams): Promise<WebAppsListPremierAddOnsResponse>;
    listPremierAddOnsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListPremierAddOnsSlotOptionalParams): Promise<WebAppsListPremierAddOnsSlotResponse>;
    listPrivateEndpointConnectionList(resourceGroupName: string, name: string, options?: WebAppsGetPrivateEndpointConnectionListOptionalParams): PagedAsyncIterableIterator<RemotePrivateEndpointConnectionARMResource>;
    listPrivateEndpointConnectionListSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetPrivateEndpointConnectionListSlotOptionalParams): PagedAsyncIterableIterator<RemotePrivateEndpointConnectionARMResource>;
    listProcesses(resourceGroupName: string, name: string, options?: WebAppsListProcessesOptionalParams): PagedAsyncIterableIterator<ProcessInfo>;
    listProcessesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListProcessesSlotOptionalParams): PagedAsyncIterableIterator<ProcessInfo>;
    listProcessModules(resourceGroupName: string, name: string, processId: string, options?: WebAppsListProcessModulesOptionalParams): PagedAsyncIterableIterator<ProcessModuleInfo>;
    listProcessModulesSlot(resourceGroupName: string, name: string, processId: string, slot: string, options?: WebAppsListProcessModulesSlotOptionalParams): PagedAsyncIterableIterator<ProcessModuleInfo>;
    listProcessThreads(resourceGroupName: string, name: string, processId: string, options?: WebAppsListProcessThreadsOptionalParams): PagedAsyncIterableIterator<ProcessThreadInfo>;
    listProcessThreadsSlot(resourceGroupName: string, name: string, processId: string, slot: string, options?: WebAppsListProcessThreadsSlotOptionalParams): PagedAsyncIterableIterator<ProcessThreadInfo>;
    listProductionSiteDeploymentStatuses(resourceGroupName: string, name: string, options?: WebAppsListProductionSiteDeploymentStatusesOptionalParams): PagedAsyncIterableIterator<CsmDeploymentStatus>;
    listPublicCertificates(resourceGroupName: string, name: string, options?: WebAppsListPublicCertificatesOptionalParams): PagedAsyncIterableIterator<PublicCertificate>;
    listPublicCertificatesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListPublicCertificatesSlotOptionalParams): PagedAsyncIterableIterator<PublicCertificate>;
    listPublishingProfileXmlWithSecrets(resourceGroupName: string, name: string, publishingProfileOptions: CsmPublishingProfileOptions, options?: WebAppsListPublishingProfileXmlWithSecretsOptionalParams): Promise<WebAppsListPublishingProfileXmlWithSecretsResponse>;
    listPublishingProfileXmlWithSecretsSlot(resourceGroupName: string, name: string, slot: string, publishingProfileOptions: CsmPublishingProfileOptions, options?: WebAppsListPublishingProfileXmlWithSecretsSlotOptionalParams): Promise<WebAppsListPublishingProfileXmlWithSecretsSlotResponse>;
    listRelayServiceConnections(resourceGroupName: string, name: string, options?: WebAppsListRelayServiceConnectionsOptionalParams): Promise<WebAppsListRelayServiceConnectionsResponse>;
    listRelayServiceConnectionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListRelayServiceConnectionsSlotOptionalParams): Promise<WebAppsListRelayServiceConnectionsSlotResponse>;
    listSiteBackups(resourceGroupName: string, name: string, options?: WebAppsListSiteBackupsOptionalParams): PagedAsyncIterableIterator<BackupItem>;
    listSiteBackupsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSiteBackupsSlotOptionalParams): PagedAsyncIterableIterator<BackupItem>;
    listSiteConnectionStringKeyVaultReferences(resourceGroupName: string, name: string, options?: WebAppsGetSiteConnectionStringKeyVaultReferencesOptionalParams): PagedAsyncIterableIterator<ApiKVReference>;
    listSiteConnectionStringKeyVaultReferencesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsGetSiteConnectionStringKeyVaultReferencesSlotOptionalParams): PagedAsyncIterableIterator<ApiKVReference>;
    listSiteContainers(resourceGroupName: string, name: string, options?: WebAppsListSiteContainersOptionalParams): PagedAsyncIterableIterator<SiteContainer>;
    listSiteContainersSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSiteContainersSlotOptionalParams): PagedAsyncIterableIterator<SiteContainer>;
    listSiteExtensions(resourceGroupName: string, name: string, options?: WebAppsListSiteExtensionsOptionalParams): PagedAsyncIterableIterator<SiteExtensionInfo>;
    listSiteExtensionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSiteExtensionsSlotOptionalParams): PagedAsyncIterableIterator<SiteExtensionInfo>;
    listSitePushSettings(resourceGroupName: string, name: string, options?: WebAppsListSitePushSettingsOptionalParams): Promise<WebAppsListSitePushSettingsResponse>;
    listSitePushSettingsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSitePushSettingsSlotOptionalParams): Promise<WebAppsListSitePushSettingsSlotResponse>;
    listSlotConfigurationNames(resourceGroupName: string, name: string, options?: WebAppsListSlotConfigurationNamesOptionalParams): Promise<WebAppsListSlotConfigurationNamesResponse>;
    listSlotDifferencesFromProduction(resourceGroupName: string, name: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsListSlotDifferencesFromProductionOptionalParams): PagedAsyncIterableIterator<SlotDifference>;
    listSlotDifferencesSlot(resourceGroupName: string, name: string, slot: string, slotSwapEntity: CsmSlotEntity, options?: WebAppsListSlotDifferencesSlotOptionalParams): PagedAsyncIterableIterator<SlotDifference>;
    listSlots(resourceGroupName: string, name: string, options?: WebAppsListSlotsOptionalParams): PagedAsyncIterableIterator<Site>;
    listSlotSiteDeploymentStatusesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSlotSiteDeploymentStatusesSlotOptionalParams): PagedAsyncIterableIterator<CsmDeploymentStatus>;
    listSnapshots(resourceGroupName: string, name: string, options?: WebAppsListSnapshotsOptionalParams): PagedAsyncIterableIterator<Snapshot>;
    listSnapshotsFromDRSecondary(resourceGroupName: string, name: string, options?: WebAppsListSnapshotsFromDRSecondaryOptionalParams): PagedAsyncIterableIterator<Snapshot>;
    listSnapshotsFromDRSecondarySlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSnapshotsFromDRSecondarySlotOptionalParams): PagedAsyncIterableIterator<Snapshot>;
    listSnapshotsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSnapshotsSlotOptionalParams): PagedAsyncIterableIterator<Snapshot>;
    listSyncFunctionTriggers(resourceGroupName: string, name: string, options?: WebAppsListSyncFunctionTriggersOptionalParams): Promise<WebAppsListSyncFunctionTriggersResponse>;
    listSyncFunctionTriggersSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSyncFunctionTriggersSlotOptionalParams): Promise<WebAppsListSyncFunctionTriggersSlotResponse>;
    listSyncStatus(resourceGroupName: string, name: string, options?: WebAppsListSyncStatusOptionalParams): Promise<void>;
    listSyncStatusSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListSyncStatusSlotOptionalParams): Promise<void>;
    listTriggeredWebJobHistory(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsListTriggeredWebJobHistoryOptionalParams): PagedAsyncIterableIterator<TriggeredJobHistory>;
    listTriggeredWebJobHistorySlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsListTriggeredWebJobHistorySlotOptionalParams): PagedAsyncIterableIterator<TriggeredJobHistory>;
    listTriggeredWebJobs(resourceGroupName: string, name: string, options?: WebAppsListTriggeredWebJobsOptionalParams): PagedAsyncIterableIterator<TriggeredWebJob>;
    listTriggeredWebJobsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListTriggeredWebJobsSlotOptionalParams): PagedAsyncIterableIterator<TriggeredWebJob>;
    listUsages(resourceGroupName: string, name: string, options?: WebAppsListUsagesOptionalParams): PagedAsyncIterableIterator<CsmUsageQuota>;
    listUsagesSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListUsagesSlotOptionalParams): PagedAsyncIterableIterator<CsmUsageQuota>;
    listVnetConnections(resourceGroupName: string, name: string, options?: WebAppsListVnetConnectionsOptionalParams): Promise<WebAppsListVnetConnectionsResponse>;
    listVnetConnectionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListVnetConnectionsSlotOptionalParams): Promise<WebAppsListVnetConnectionsSlotResponse>;
    listWebJobs(resourceGroupName: string, name: string, options?: WebAppsListWebJobsOptionalParams): PagedAsyncIterableIterator<WebJob>;
    listWebJobsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListWebJobsSlotOptionalParams): PagedAsyncIterableIterator<WebJob>;
    listWorkflows(resourceGroupName: string, name: string, options?: WebAppsListWorkflowsOptionalParams): PagedAsyncIterableIterator<WorkflowEnvelope>;
    listWorkflowsConnections(resourceGroupName: string, name: string, options?: WebAppsListWorkflowsConnectionsOptionalParams): Promise<WebAppsListWorkflowsConnectionsResponse>;
    listWorkflowsConnectionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsListWorkflowsConnectionsSlotOptionalParams): Promise<WebAppsListWorkflowsConnectionsSlotResponse>;
    putPrivateAccessVnet(resourceGroupName: string, name: string, access: PrivateAccess, options?: WebAppsPutPrivateAccessVnetOptionalParams): Promise<WebAppsPutPrivateAccessVnetResponse>;
    putPrivateAccessVnetSlot(resourceGroupName: string, name: string, slot: string, access: PrivateAccess, options?: WebAppsPutPrivateAccessVnetSlotOptionalParams): Promise<WebAppsPutPrivateAccessVnetSlotResponse>;
    recoverSiteConfigurationSnapshot(resourceGroupName: string, name: string, snapshotId: string, options?: WebAppsRecoverSiteConfigurationSnapshotOptionalParams): Promise<void>;
    recoverSiteConfigurationSnapshotSlot(resourceGroupName: string, name: string, snapshotId: string, slot: string, options?: WebAppsRecoverSiteConfigurationSnapshotSlotOptionalParams): Promise<void>;
    resetProductionSlotConfig(resourceGroupName: string, name: string, options?: WebAppsResetProductionSlotConfigOptionalParams): Promise<void>;
    resetSlotConfigurationSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsResetSlotConfigurationSlotOptionalParams): Promise<void>;
    restart(resourceGroupName: string, name: string, options?: WebAppsRestartOptionalParams): Promise<void>;
    restartSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsRestartSlotOptionalParams): Promise<void>;
    runTriggeredWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsRunTriggeredWebJobOptionalParams): Promise<void>;
    runTriggeredWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsRunTriggeredWebJobSlotOptionalParams): Promise<void>;
    start(resourceGroupName: string, name: string, options?: WebAppsStartOptionalParams): Promise<void>;
    startContinuousWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsStartContinuousWebJobOptionalParams): Promise<void>;
    startContinuousWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsStartContinuousWebJobSlotOptionalParams): Promise<void>;
    startSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStartSlotOptionalParams): Promise<void>;
    startWebSiteNetworkTrace(resourceGroupName: string, name: string, options?: WebAppsStartWebSiteNetworkTraceOptionalParams): Promise<WebAppsStartWebSiteNetworkTraceResponse>;
    startWebSiteNetworkTraceSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStartWebSiteNetworkTraceSlotOptionalParams): Promise<WebAppsStartWebSiteNetworkTraceSlotResponse>;
    stop(resourceGroupName: string, name: string, options?: WebAppsStopOptionalParams): Promise<void>;
    stopContinuousWebJob(resourceGroupName: string, name: string, webJobName: string, options?: WebAppsStopContinuousWebJobOptionalParams): Promise<void>;
    stopContinuousWebJobSlot(resourceGroupName: string, name: string, webJobName: string, slot: string, options?: WebAppsStopContinuousWebJobSlotOptionalParams): Promise<void>;
    stopNetworkTrace(resourceGroupName: string, name: string, options?: WebAppsStopNetworkTraceOptionalParams): Promise<void>;
    stopNetworkTraceSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStopNetworkTraceSlotOptionalParams): Promise<void>;
    stopSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStopSlotOptionalParams): Promise<void>;
    stopWebSiteNetworkTrace(resourceGroupName: string, name: string, options?: WebAppsStopWebSiteNetworkTraceOptionalParams): Promise<void>;
    stopWebSiteNetworkTraceSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsStopWebSiteNetworkTraceSlotOptionalParams): Promise<void>;
    syncFunctions(resourceGroupName: string, name: string, options?: WebAppsSyncFunctionsOptionalParams): Promise<void>;
    syncFunctionsSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsSyncFunctionsSlotOptionalParams): Promise<void>;
    syncFunctionTriggers(resourceGroupName: string, name: string, options?: WebAppsSyncFunctionTriggersOptionalParams): Promise<void>;
    syncFunctionTriggersSlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsSyncFunctionTriggersSlotOptionalParams): Promise<void>;
    syncRepository(resourceGroupName: string, name: string, options?: WebAppsSyncRepositoryOptionalParams): Promise<void>;
    syncRepositorySlot(resourceGroupName: string, name: string, slot: string, options?: WebAppsSyncRepositorySlotOptionalParams): Promise<void>;
    update(resourceGroupName: string, name: string, siteEnvelope: SitePatchResource, options?: WebAppsUpdateOptionalParams): Promise<WebAppsUpdateResponse>;
    updateApplicationSettings(resourceGroupName: string, name: string, appSettings: StringDictionary, options?: WebAppsUpdateApplicationSettingsOptionalParams): Promise<WebAppsUpdateApplicationSettingsResponse>;
    updateApplicationSettingsSlot(resourceGroupName: string, name: string, slot: string, appSettings: StringDictionary, options?: WebAppsUpdateApplicationSettingsSlotOptionalParams): Promise<WebAppsUpdateApplicationSettingsSlotResponse>;
    updateAuthSettings(resourceGroupName: string, name: string, siteAuthSettings: SiteAuthSettings, options?: WebAppsUpdateAuthSettingsOptionalParams): Promise<WebAppsUpdateAuthSettingsResponse>;
    updateAuthSettingsSlot(resourceGroupName: string, name: string, slot: string, siteAuthSettings: SiteAuthSettings, options?: WebAppsUpdateAuthSettingsSlotOptionalParams): Promise<WebAppsUpdateAuthSettingsSlotResponse>;
    updateAuthSettingsV2(resourceGroupName: string, name: string, siteAuthSettingsV2: SiteAuthSettingsV2, options?: WebAppsUpdateAuthSettingsV2OptionalParams): Promise<WebAppsUpdateAuthSettingsV2Response>;
    updateAuthSettingsV2Slot(resourceGroupName: string, name: string, slot: string, siteAuthSettingsV2: SiteAuthSettingsV2, options?: WebAppsUpdateAuthSettingsV2SlotOptionalParams): Promise<WebAppsUpdateAuthSettingsV2SlotResponse>;
    updateAzureStorageAccounts(resourceGroupName: string, name: string, azureStorageAccounts: AzureStoragePropertyDictionaryResource, options?: WebAppsUpdateAzureStorageAccountsOptionalParams): Promise<WebAppsUpdateAzureStorageAccountsResponse>;
    updateAzureStorageAccountsSlot(resourceGroupName: string, name: string, slot: string, azureStorageAccounts: AzureStoragePropertyDictionaryResource, options?: WebAppsUpdateAzureStorageAccountsSlotOptionalParams): Promise<WebAppsUpdateAzureStorageAccountsSlotResponse>;
    updateBackupConfiguration(resourceGroupName: string, name: string, request: BackupRequest, options?: WebAppsUpdateBackupConfigurationOptionalParams): Promise<WebAppsUpdateBackupConfigurationResponse>;
    updateBackupConfigurationSlot(resourceGroupName: string, name: string, slot: string, request: BackupRequest, options?: WebAppsUpdateBackupConfigurationSlotOptionalParams): Promise<WebAppsUpdateBackupConfigurationSlotResponse>;
    updateConfiguration(resourceGroupName: string, name: string, siteConfig: SiteConfigResource, options?: WebAppsUpdateConfigurationOptionalParams): Promise<WebAppsUpdateConfigurationResponse>;
    updateConfigurationSlot(resourceGroupName: string, name: string, slot: string, siteConfig: SiteConfigResource, options?: WebAppsUpdateConfigurationSlotOptionalParams): Promise<WebAppsUpdateConfigurationSlotResponse>;
    updateConnectionStrings(resourceGroupName: string, name: string, connectionStrings: ConnectionStringDictionary, options?: WebAppsUpdateConnectionStringsOptionalParams): Promise<WebAppsUpdateConnectionStringsResponse>;
    updateConnectionStringsSlot(resourceGroupName: string, name: string, slot: string, connectionStrings: ConnectionStringDictionary, options?: WebAppsUpdateConnectionStringsSlotOptionalParams): Promise<WebAppsUpdateConnectionStringsSlotResponse>;
    updateDiagnosticLogsConfig(resourceGroupName: string, name: string, siteLogsConfig: SiteLogsConfig, options?: WebAppsUpdateDiagnosticLogsConfigOptionalParams): Promise<WebAppsUpdateDiagnosticLogsConfigResponse>;
    updateDiagnosticLogsConfigSlot(resourceGroupName: string, name: string, slot: string, siteLogsConfig: SiteLogsConfig, options?: WebAppsUpdateDiagnosticLogsConfigSlotOptionalParams): Promise<WebAppsUpdateDiagnosticLogsConfigSlotResponse>;
    updateDomainOwnershipIdentifier(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, domainOwnershipIdentifier: Identifier, options?: WebAppsUpdateDomainOwnershipIdentifierOptionalParams): Promise<WebAppsUpdateDomainOwnershipIdentifierResponse>;
    updateDomainOwnershipIdentifierSlot(resourceGroupName: string, name: string, domainOwnershipIdentifierName: string, slot: string, domainOwnershipIdentifier: Identifier, options?: WebAppsUpdateDomainOwnershipIdentifierSlotOptionalParams): Promise<WebAppsUpdateDomainOwnershipIdentifierSlotResponse>;
    updateFtpAllowed(resourceGroupName: string, name: string, csmPublishingAccessPoliciesEntity: CsmPublishingCredentialsPoliciesEntity, options?: WebAppsUpdateFtpAllowedOptionalParams): Promise<WebAppsUpdateFtpAllowedResponse>;
    updateFtpAllowedSlot(resourceGroupName: string, name: string, slot: string, csmPublishingAccessPoliciesEntity: CsmPublishingCredentialsPoliciesEntity, options?: WebAppsUpdateFtpAllowedSlotOptionalParams): Promise<WebAppsUpdateFtpAllowedSlotResponse>;
    updateHybridConnection(resourceGroupName: string, name: string, namespaceName: string, relayName: string, connectionEnvelope: HybridConnection, options?: WebAppsUpdateHybridConnectionOptionalParams): Promise<WebAppsUpdateHybridConnectionResponse>;
    updateHybridConnectionSlot(resourceGroupName: string, name: string, namespaceName: string, relayName: string, slot: string, connectionEnvelope: HybridConnection, options?: WebAppsUpdateHybridConnectionSlotOptionalParams): Promise<WebAppsUpdateHybridConnectionSlotResponse>;
    updateMetadata(resourceGroupName: string, name: string, metadata: StringDictionary, options?: WebAppsUpdateMetadataOptionalParams): Promise<WebAppsUpdateMetadataResponse>;
    updateMetadataSlot(resourceGroupName: string, name: string, slot: string, metadata: StringDictionary, options?: WebAppsUpdateMetadataSlotOptionalParams): Promise<WebAppsUpdateMetadataSlotResponse>;
    updatePremierAddOn(resourceGroupName: string, name: string, premierAddOnName: string, premierAddOn: PremierAddOnPatchResource, options?: WebAppsUpdatePremierAddOnOptionalParams): Promise<WebAppsUpdatePremierAddOnResponse>;
    updatePremierAddOnSlot(resourceGroupName: string, name: string, premierAddOnName: string, slot: string, premierAddOn: PremierAddOnPatchResource, options?: WebAppsUpdatePremierAddOnSlotOptionalParams): Promise<WebAppsUpdatePremierAddOnSlotResponse>;
    updateRelayServiceConnection(resourceGroupName: string, name: string, entityName: string, connectionEnvelope: RelayServiceConnectionEntity, options?: WebAppsUpdateRelayServiceConnectionOptionalParams): Promise<WebAppsUpdateRelayServiceConnectionResponse>;
    updateRelayServiceConnectionSlot(resourceGroupName: string, name: string, entityName: string, slot: string, connectionEnvelope: RelayServiceConnectionEntity, options?: WebAppsUpdateRelayServiceConnectionSlotOptionalParams): Promise<WebAppsUpdateRelayServiceConnectionSlotResponse>;
    updateScmAllowed(resourceGroupName: string, name: string, csmPublishingAccessPoliciesEntity: CsmPublishingCredentialsPoliciesEntity, options?: WebAppsUpdateScmAllowedOptionalParams): Promise<WebAppsUpdateScmAllowedResponse>;
    updateScmAllowedSlot(resourceGroupName: string, name: string, slot: string, csmPublishingAccessPoliciesEntity: CsmPublishingCredentialsPoliciesEntity, options?: WebAppsUpdateScmAllowedSlotOptionalParams): Promise<WebAppsUpdateScmAllowedSlotResponse>;
    updateSitePushSettings(resourceGroupName: string, name: string, pushSettings: PushSettings, options?: WebAppsUpdateSitePushSettingsOptionalParams): Promise<WebAppsUpdateSitePushSettingsResponse>;
    updateSitePushSettingsSlot(resourceGroupName: string, name: string, slot: string, pushSettings: PushSettings, options?: WebAppsUpdateSitePushSettingsSlotOptionalParams): Promise<WebAppsUpdateSitePushSettingsSlotResponse>;
    updateSlot(resourceGroupName: string, name: string, slot: string, siteEnvelope: SitePatchResource, options?: WebAppsUpdateSlotOptionalParams): Promise<WebAppsUpdateSlotResponse>;
    updateSlotConfigurationNames(resourceGroupName: string, name: string, slotConfigNames: SlotConfigNamesResource, options?: WebAppsUpdateSlotConfigurationNamesOptionalParams): Promise<WebAppsUpdateSlotConfigurationNamesResponse>;
    updateSourceControl(resourceGroupName: string, name: string, siteSourceControl: SiteSourceControl, options?: WebAppsUpdateSourceControlOptionalParams): Promise<WebAppsUpdateSourceControlResponse>;
    updateSourceControlSlot(resourceGroupName: string, name: string, slot: string, siteSourceControl: SiteSourceControl, options?: WebAppsUpdateSourceControlSlotOptionalParams): Promise<WebAppsUpdateSourceControlSlotResponse>;
    updateSwiftVirtualNetworkConnectionWithCheck(resourceGroupName: string, name: string, connectionEnvelope: SwiftVirtualNetwork, options?: WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckOptionalParams): Promise<WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckResponse>;
    updateSwiftVirtualNetworkConnectionWithCheckSlot(resourceGroupName: string, name: string, slot: string, connectionEnvelope: SwiftVirtualNetwork, options?: WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckSlotOptionalParams): Promise<WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckSlotResponse>;
    updateVnetConnection(resourceGroupName: string, name: string, vnetName: string, connectionEnvelope: VnetInfoResource, options?: WebAppsUpdateVnetConnectionOptionalParams): Promise<WebAppsUpdateVnetConnectionResponse>;
    updateVnetConnectionGateway(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, connectionEnvelope: VnetGateway, options?: WebAppsUpdateVnetConnectionGatewayOptionalParams): Promise<WebAppsUpdateVnetConnectionGatewayResponse>;
    updateVnetConnectionGatewaySlot(resourceGroupName: string, name: string, vnetName: string, gatewayName: string, slot: string, connectionEnvelope: VnetGateway, options?: WebAppsUpdateVnetConnectionGatewaySlotOptionalParams): Promise<WebAppsUpdateVnetConnectionGatewaySlotResponse>;
    updateVnetConnectionSlot(resourceGroupName: string, name: string, vnetName: string, slot: string, connectionEnvelope: VnetInfoResource, options?: WebAppsUpdateVnetConnectionSlotOptionalParams): Promise<WebAppsUpdateVnetConnectionSlotResponse>;
}

// @public
export interface WebAppsAddPremierAddOnOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsAddPremierAddOnResponse = PremierAddOn;

// @public
export interface WebAppsAddPremierAddOnSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsAddPremierAddOnSlotResponse = PremierAddOn;

// @public
export interface WebAppsAnalyzeCustomHostnameOptionalParams extends coreClient.OperationOptions {
    hostName?: string;
}

// @public
export type WebAppsAnalyzeCustomHostnameResponse = CustomHostnameAnalysisResult;

// @public
export interface WebAppsAnalyzeCustomHostnameSlotOptionalParams extends coreClient.OperationOptions {
    hostName?: string;
}

// @public
export type WebAppsAnalyzeCustomHostnameSlotResponse = CustomHostnameAnalysisResult;

// @public
export interface WebAppsApplySlotConfigToProductionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsApplySlotConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsApproveOrRejectPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsApproveOrRejectPrivateEndpointConnectionResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface WebAppsApproveOrRejectPrivateEndpointConnectionSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsApproveOrRejectPrivateEndpointConnectionSlotResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface WebAppsBackupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsBackupResponse = BackupItem;

// @public
export interface WebAppsBackupSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsBackupSlotResponse = BackupItem;

// @public
export interface WebAppsCreateDeploymentOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateDeploymentResponse = Deployment;

// @public
export interface WebAppsCreateDeploymentSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateDeploymentSlotResponse = Deployment;

// @public
export interface WebAppsCreateFunctionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateFunctionResponse = FunctionEnvelope;

// @public
export interface WebAppsCreateInstanceFunctionSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateInstanceFunctionSlotResponse = FunctionEnvelope;

// @public
export interface WebAppsCreateInstanceMSDeployOperationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateInstanceMSDeployOperationResponse = MSDeployStatus;

// @public
export interface WebAppsCreateInstanceMSDeployOperationSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateInstanceMSDeployOperationSlotResponse = MSDeployStatus;

// @public
export interface WebAppsCreateMSDeployOperationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateMSDeployOperationResponse = MSDeployStatus;

// @public
export interface WebAppsCreateMSDeployOperationSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateMSDeployOperationSlotResponse = MSDeployStatus;

// @public
export interface WebAppsCreateOneDeployOperationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOneDeployOperationResponse = Record<string, unknown>;

// @public
export interface WebAppsCreateOrUpdateConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateConfigurationResponse = SiteConfigResource;

// @public
export interface WebAppsCreateOrUpdateConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateConfigurationSlotResponse = SiteConfigResource;

// @public
export interface WebAppsCreateOrUpdateDomainOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateDomainOwnershipIdentifierResponse = Identifier;

// @public
export interface WebAppsCreateOrUpdateDomainOwnershipIdentifierSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateDomainOwnershipIdentifierSlotResponse = Identifier;

// @public
export interface WebAppsCreateOrUpdateFunctionSecretOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateFunctionSecretResponse = KeyInfo;

// @public
export interface WebAppsCreateOrUpdateFunctionSecretSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateFunctionSecretSlotResponse = KeyInfo;

// @public
export interface WebAppsCreateOrUpdateHostNameBindingOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateHostNameBindingResponse = HostNameBinding;

// @public
export interface WebAppsCreateOrUpdateHostNameBindingSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateHostNameBindingSlotResponse = HostNameBinding;

// @public
export interface WebAppsCreateOrUpdateHostSecretOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateHostSecretResponse = KeyInfo;

// @public
export interface WebAppsCreateOrUpdateHostSecretSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateHostSecretSlotResponse = KeyInfo;

// @public
export interface WebAppsCreateOrUpdateHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateHybridConnectionResponse = HybridConnection;

// @public
export interface WebAppsCreateOrUpdateHybridConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateHybridConnectionSlotResponse = HybridConnection;

// @public
export interface WebAppsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsCreateOrUpdatePublicCertificateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdatePublicCertificateResponse = PublicCertificate;

// @public
export interface WebAppsCreateOrUpdatePublicCertificateSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdatePublicCertificateSlotResponse = PublicCertificate;

// @public
export interface WebAppsCreateOrUpdateRelayServiceConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateRelayServiceConnectionResponse = RelayServiceConnectionEntity;

// @public
export interface WebAppsCreateOrUpdateRelayServiceConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateRelayServiceConnectionSlotResponse = RelayServiceConnectionEntity;

// @public
export type WebAppsCreateOrUpdateResponse = Site;

// @public
export interface WebAppsCreateOrUpdateSiteContainerOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateSiteContainerResponse = SiteContainer;

// @public
export interface WebAppsCreateOrUpdateSiteContainerSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateSiteContainerSlotResponse = SiteContainer;

// @public
export interface WebAppsCreateOrUpdateSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateOrUpdateSlotResponse = Site;

// @public
export interface WebAppsCreateOrUpdateSourceControlOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateOrUpdateSourceControlResponse = SiteSourceControl;

// @public
export interface WebAppsCreateOrUpdateSourceControlSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsCreateOrUpdateSourceControlSlotResponse = SiteSourceControl;

// @public
export interface WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckResponse = SwiftVirtualNetwork;

// @public
export interface WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateSwiftVirtualNetworkConnectionWithCheckSlotResponse = SwiftVirtualNetwork;

// @public
export interface WebAppsCreateOrUpdateVnetConnectionGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateVnetConnectionGatewayResponse = VnetGateway;

// @public
export interface WebAppsCreateOrUpdateVnetConnectionGatewaySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateVnetConnectionGatewaySlotResponse = VnetGateway;

// @public
export interface WebAppsCreateOrUpdateVnetConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateVnetConnectionResponse = VnetInfoResource;

// @public
export interface WebAppsCreateOrUpdateVnetConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsCreateOrUpdateVnetConnectionSlotResponse = VnetInfoResource;

// @public
export interface WebAppsDeleteBackupConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteBackupConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteBackupOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteBackupSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteContinuousWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteContinuousWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteDeploymentOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteDeploymentSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteDomainOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteDomainOwnershipIdentifierSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteFunctionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteFunctionSecretOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteFunctionSecretSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteHostNameBindingOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteHostNameBindingSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteHostSecretOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteHostSecretSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteHybridConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteInstanceFunctionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteInstanceProcessOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteInstanceProcessSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteOptionalParams extends coreClient.OperationOptions {
    deleteEmptyServerFarm?: boolean;
    deleteMetrics?: boolean;
}

// @public
export interface WebAppsDeletePremierAddOnOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeletePremierAddOnSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeletePrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsDeletePrivateEndpointConnectionResponse = Record<string, unknown>;

// @public
export interface WebAppsDeletePrivateEndpointConnectionSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsDeletePrivateEndpointConnectionSlotResponse = Record<string, unknown>;

// @public
export interface WebAppsDeleteProcessOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteProcessSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeletePublicCertificateOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeletePublicCertificateSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteRelayServiceConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteRelayServiceConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteSiteContainerOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteSiteContainerSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteSiteExtensionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteSiteExtensionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteSlotOptionalParams extends coreClient.OperationOptions {
    deleteEmptyServerFarm?: boolean;
    deleteMetrics?: boolean;
}

// @public
export interface WebAppsDeleteSourceControlOptionalParams extends coreClient.OperationOptions {
    // (undocumented)
    additionalFlags?: string;
}

// @public
export interface WebAppsDeleteSourceControlSlotOptionalParams extends coreClient.OperationOptions {
    // (undocumented)
    additionalFlags?: string;
}

// @public
export interface WebAppsDeleteSwiftVirtualNetworkOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteSwiftVirtualNetworkSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteTriggeredWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteTriggeredWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteVnetConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeleteVnetConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsDeployWorkflowArtifactsOptionalParams extends coreClient.OperationOptions {
    workflowArtifacts?: WorkflowArtifacts;
}

// @public
export interface WebAppsDeployWorkflowArtifactsSlotOptionalParams extends coreClient.OperationOptions {
    workflowArtifacts?: WorkflowArtifacts;
}

// @public
export interface WebAppsDiscoverBackupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsDiscoverBackupResponse = RestoreRequest;

// @public
export interface WebAppsDiscoverBackupSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsDiscoverBackupSlotResponse = RestoreRequest;

// @public
export interface WebAppsGenerateNewSitePublishingPasswordOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsGenerateNewSitePublishingPasswordSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsGetAppSettingKeyVaultReferenceOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAppSettingKeyVaultReferenceResponse = ApiKVReference;

// @public
export interface WebAppsGetAppSettingKeyVaultReferenceSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAppSettingKeyVaultReferenceSlotResponse = ApiKVReference;

// @public
export interface WebAppsGetAppSettingsKeyVaultReferencesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAppSettingsKeyVaultReferencesNextResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetAppSettingsKeyVaultReferencesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAppSettingsKeyVaultReferencesResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetAppSettingsKeyVaultReferencesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAppSettingsKeyVaultReferencesSlotNextResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetAppSettingsKeyVaultReferencesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAppSettingsKeyVaultReferencesSlotResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetAuthSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAuthSettingsResponse = SiteAuthSettings;

// @public
export interface WebAppsGetAuthSettingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAuthSettingsSlotResponse = SiteAuthSettings;

// @public
export interface WebAppsGetAuthSettingsV2OptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAuthSettingsV2Response = SiteAuthSettingsV2;

// @public
export interface WebAppsGetAuthSettingsV2SlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAuthSettingsV2SlotResponse = SiteAuthSettingsV2;

// @public
export interface WebAppsGetAuthSettingsV2WithoutSecretsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAuthSettingsV2WithoutSecretsResponse = SiteAuthSettingsV2;

// @public
export interface WebAppsGetAuthSettingsV2WithoutSecretsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetAuthSettingsV2WithoutSecretsSlotResponse = SiteAuthSettingsV2;

// @public
export interface WebAppsGetBackupConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetBackupConfigurationResponse = BackupRequest;

// @public
export interface WebAppsGetBackupConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetBackupConfigurationSlotResponse = BackupRequest;

// @public
export interface WebAppsGetBackupStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetBackupStatusResponse = BackupItem;

// @public
export interface WebAppsGetBackupStatusSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetBackupStatusSlotResponse = BackupItem;

// @public
export interface WebAppsGetConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetConfigurationResponse = SiteConfigResource;

// @public
export interface WebAppsGetConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetConfigurationSlotResponse = SiteConfigResource;

// @public
export interface WebAppsGetConfigurationSnapshotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetConfigurationSnapshotResponse = SiteConfigResource;

// @public
export interface WebAppsGetConfigurationSnapshotSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetConfigurationSnapshotSlotResponse = SiteConfigResource;

// @public
export interface WebAppsGetContainerLogsZipOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetContainerLogsZipResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetContainerLogsZipSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetContainerLogsZipSlotResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetContinuousWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetContinuousWebJobResponse = ContinuousWebJob;

// @public
export interface WebAppsGetContinuousWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetContinuousWebJobSlotResponse = ContinuousWebJob;

// @public
export interface WebAppsGetDeploymentOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetDeploymentResponse = Deployment;

// @public
export interface WebAppsGetDeploymentSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetDeploymentSlotResponse = Deployment;

// @public
export interface WebAppsGetDiagnosticLogsConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetDiagnosticLogsConfigurationResponse = SiteLogsConfig;

// @public
export interface WebAppsGetDiagnosticLogsConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetDiagnosticLogsConfigurationSlotResponse = SiteLogsConfig;

// @public
export interface WebAppsGetDomainOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetDomainOwnershipIdentifierResponse = Identifier;

// @public
export interface WebAppsGetDomainOwnershipIdentifierSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetDomainOwnershipIdentifierSlotResponse = Identifier;

// @public
export interface WebAppsGetFtpAllowedOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetFtpAllowedResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsGetFtpAllowedSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetFtpAllowedSlotResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsGetFunctionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetFunctionResponse = FunctionEnvelope;

// @public
export interface WebAppsGetFunctionsAdminTokenOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetFunctionsAdminTokenResponse = {
    body: string;
};

// @public
export interface WebAppsGetFunctionsAdminTokenSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetFunctionsAdminTokenSlotResponse = {
    body: string;
};

// @public
export interface WebAppsGetHostNameBindingOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetHostNameBindingResponse = HostNameBinding;

// @public
export interface WebAppsGetHostNameBindingSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetHostNameBindingSlotResponse = HostNameBinding;

// @public
export interface WebAppsGetHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetHybridConnectionResponse = HybridConnection;

// @public
export interface WebAppsGetHybridConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetHybridConnectionSlotResponse = HybridConnection;

// @public
export interface WebAppsGetInstanceFunctionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceFunctionSlotResponse = FunctionEnvelope;

// @public
export interface WebAppsGetInstanceInfoOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceInfoResponse = WebSiteInstanceStatus;

// @public
export interface WebAppsGetInstanceInfoSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceInfoSlotResponse = WebSiteInstanceStatus;

// @public
export interface WebAppsGetInstanceMSDeployLogOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceMSDeployLogResponse = MSDeployLog;

// @public
export interface WebAppsGetInstanceMSDeployLogSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceMSDeployLogSlotResponse = MSDeployLog;

// @public
export interface WebAppsGetInstanceMsDeployStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceMsDeployStatusResponse = MSDeployStatus;

// @public
export interface WebAppsGetInstanceMsDeployStatusSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceMsDeployStatusSlotResponse = MSDeployStatus;

// @public
export interface WebAppsGetInstanceProcessDumpOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceProcessDumpResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetInstanceProcessDumpSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceProcessDumpSlotResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetInstanceProcessModuleOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceProcessModuleResponse = ProcessModuleInfo;

// @public
export interface WebAppsGetInstanceProcessModuleSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceProcessModuleSlotResponse = ProcessModuleInfo;

// @public
export interface WebAppsGetInstanceProcessOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceProcessResponse = ProcessInfo;

// @public
export interface WebAppsGetInstanceProcessSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceProcessSlotResponse = ProcessInfo;

// @public
export interface WebAppsGetInstanceWorkflowSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetInstanceWorkflowSlotResponse = WorkflowEnvelope;

// @public
export interface WebAppsGetMigrateMySqlStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetMigrateMySqlStatusResponse = MigrateMySqlStatus;

// @public
export interface WebAppsGetMigrateMySqlStatusSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetMigrateMySqlStatusSlotResponse = MigrateMySqlStatus;

// @public
export interface WebAppsGetMSDeployLogOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetMSDeployLogResponse = MSDeployLog;

// @public
export interface WebAppsGetMSDeployLogSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetMSDeployLogSlotResponse = MSDeployLog;

// @public
export interface WebAppsGetMSDeployStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetMSDeployStatusResponse = MSDeployStatus;

// @public
export interface WebAppsGetMSDeployStatusSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetMSDeployStatusSlotResponse = MSDeployStatus;

// @public
export interface WebAppsGetNetworkTraceOperationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTraceOperationResponse = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTraceOperationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTraceOperationSlotResponse = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTraceOperationSlotV2OptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTraceOperationSlotV2Response = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTraceOperationV2OptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTraceOperationV2Response = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTracesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTracesResponse = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTracesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTracesSlotResponse = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTracesSlotV2OptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTracesSlotV2Response = NetworkTrace[];

// @public
export interface WebAppsGetNetworkTracesV2OptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetNetworkTracesV2Response = NetworkTrace[];

// @public
export interface WebAppsGetOneDeployStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetOneDeployStatusResponse = Record<string, unknown>;

// @public
export interface WebAppsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsGetPremierAddOnOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPremierAddOnResponse = PremierAddOn;

// @public
export interface WebAppsGetPremierAddOnSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPremierAddOnSlotResponse = PremierAddOn;

// @public
export interface WebAppsGetPrivateAccessOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateAccessResponse = PrivateAccess;

// @public
export interface WebAppsGetPrivateAccessSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateAccessSlotResponse = PrivateAccess;

// @public
export interface WebAppsGetPrivateEndpointConnectionListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateEndpointConnectionListNextResponse = PrivateEndpointConnectionCollection;

// @public
export interface WebAppsGetPrivateEndpointConnectionListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateEndpointConnectionListResponse = PrivateEndpointConnectionCollection;

// @public
export interface WebAppsGetPrivateEndpointConnectionListSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateEndpointConnectionListSlotNextResponse = PrivateEndpointConnectionCollection;

// @public
export interface WebAppsGetPrivateEndpointConnectionListSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateEndpointConnectionListSlotResponse = PrivateEndpointConnectionCollection;

// @public
export interface WebAppsGetPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateEndpointConnectionResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface WebAppsGetPrivateEndpointConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateEndpointConnectionSlotResponse = RemotePrivateEndpointConnectionARMResource;

// @public
export interface WebAppsGetPrivateLinkResourcesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateLinkResourcesResponse = PrivateLinkResourcesWrapper;

// @public
export interface WebAppsGetPrivateLinkResourcesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPrivateLinkResourcesSlotResponse = PrivateLinkResourcesWrapper;

// @public
export interface WebAppsGetProcessDumpOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetProcessDumpResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetProcessDumpSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetProcessDumpSlotResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetProcessModuleOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetProcessModuleResponse = ProcessModuleInfo;

// @public
export interface WebAppsGetProcessModuleSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetProcessModuleSlotResponse = ProcessModuleInfo;

// @public
export interface WebAppsGetProcessOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetProcessResponse = ProcessInfo;

// @public
export interface WebAppsGetProcessSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetProcessSlotResponse = ProcessInfo;

// @public
export interface WebAppsGetProductionSiteDeploymentStatusOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsGetProductionSiteDeploymentStatusResponse = CsmDeploymentStatus;

// @public
export interface WebAppsGetPublicCertificateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPublicCertificateResponse = PublicCertificate;

// @public
export interface WebAppsGetPublicCertificateSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetPublicCertificateSlotResponse = PublicCertificate;

// @public
export interface WebAppsGetRelayServiceConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetRelayServiceConnectionResponse = RelayServiceConnectionEntity;

// @public
export interface WebAppsGetRelayServiceConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetRelayServiceConnectionSlotResponse = RelayServiceConnectionEntity;

// @public
export type WebAppsGetResponse = Site;

// @public
export interface WebAppsGetScmAllowedOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetScmAllowedResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsGetScmAllowedSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetScmAllowedSlotResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsGetSiteConnectionStringKeyVaultReferenceOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteConnectionStringKeyVaultReferenceResponse = ApiKVReference;

// @public
export interface WebAppsGetSiteConnectionStringKeyVaultReferenceSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteConnectionStringKeyVaultReferenceSlotResponse = ApiKVReference;

// @public
export interface WebAppsGetSiteConnectionStringKeyVaultReferencesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteConnectionStringKeyVaultReferencesNextResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetSiteConnectionStringKeyVaultReferencesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteConnectionStringKeyVaultReferencesResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetSiteConnectionStringKeyVaultReferencesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteConnectionStringKeyVaultReferencesSlotNextResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetSiteConnectionStringKeyVaultReferencesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteConnectionStringKeyVaultReferencesSlotResponse = ApiKVReferenceCollection;

// @public
export interface WebAppsGetSiteContainerOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteContainerResponse = SiteContainer;

// @public
export interface WebAppsGetSiteContainerSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteContainerSlotResponse = SiteContainer;

// @public
export interface WebAppsGetSiteExtensionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteExtensionResponse = SiteExtensionInfo;

// @public
export interface WebAppsGetSiteExtensionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSiteExtensionSlotResponse = SiteExtensionInfo;

// @public
export interface WebAppsGetSitePhpErrorLogFlagOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSitePhpErrorLogFlagResponse = SitePhpErrorLogFlag;

// @public
export interface WebAppsGetSitePhpErrorLogFlagSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSitePhpErrorLogFlagSlotResponse = SitePhpErrorLogFlag;

// @public
export interface WebAppsGetSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSlotResponse = Site;

// @public
export interface WebAppsGetSlotSiteDeploymentStatusSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsGetSlotSiteDeploymentStatusSlotResponse = CsmDeploymentStatus;

// @public
export interface WebAppsGetSourceControlOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSourceControlResponse = SiteSourceControl;

// @public
export interface WebAppsGetSourceControlSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSourceControlSlotResponse = SiteSourceControl;

// @public
export interface WebAppsGetSwiftVirtualNetworkConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSwiftVirtualNetworkConnectionResponse = SwiftVirtualNetwork;

// @public
export interface WebAppsGetSwiftVirtualNetworkConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetSwiftVirtualNetworkConnectionSlotResponse = SwiftVirtualNetwork;

// @public
export interface WebAppsGetTriggeredWebJobHistoryOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetTriggeredWebJobHistoryResponse = TriggeredJobHistory;

// @public
export interface WebAppsGetTriggeredWebJobHistorySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetTriggeredWebJobHistorySlotResponse = TriggeredJobHistory;

// @public
export interface WebAppsGetTriggeredWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetTriggeredWebJobResponse = TriggeredWebJob;

// @public
export interface WebAppsGetTriggeredWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetTriggeredWebJobSlotResponse = TriggeredWebJob;

// @public
export interface WebAppsGetVnetConnectionGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetVnetConnectionGatewayResponse = VnetGateway;

// @public
export interface WebAppsGetVnetConnectionGatewaySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetVnetConnectionGatewaySlotResponse = VnetGateway;

// @public
export interface WebAppsGetVnetConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetVnetConnectionResponse = VnetInfoResource;

// @public
export interface WebAppsGetVnetConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetVnetConnectionSlotResponse = VnetInfoResource;

// @public
export interface WebAppsGetWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetWebJobResponse = WebJob;

// @public
export interface WebAppsGetWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetWebJobSlotResponse = WebJob;

// @public
export interface WebAppsGetWebSiteContainerLogsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetWebSiteContainerLogsResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetWebSiteContainerLogsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetWebSiteContainerLogsSlotResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsGetWorkflowOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsGetWorkflowResponse = WorkflowEnvelope;

// @public
export interface WebAppsInstallSiteExtensionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsInstallSiteExtensionResponse = SiteExtensionInfo;

// @public
export interface WebAppsInstallSiteExtensionSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsInstallSiteExtensionSlotResponse = SiteExtensionInfo;

// @public
export interface WebAppsIsCloneableOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsIsCloneableResponse = SiteCloneability;

// @public
export interface WebAppsIsCloneableSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsIsCloneableSlotResponse = SiteCloneability;

// @public
export interface WebAppsListApplicationSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListApplicationSettingsResponse = StringDictionary;

// @public
export interface WebAppsListApplicationSettingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListApplicationSettingsSlotResponse = StringDictionary;

// @public
export interface WebAppsListAzureStorageAccountsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListAzureStorageAccountsResponse = AzureStoragePropertyDictionaryResource;

// @public
export interface WebAppsListAzureStorageAccountsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListAzureStorageAccountsSlotResponse = AzureStoragePropertyDictionaryResource;

// @public
export interface WebAppsListBackupsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBackupsNextResponse = BackupItemCollection;

// @public
export interface WebAppsListBackupsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBackupsResponse = BackupItemCollection;

// @public
export interface WebAppsListBackupsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBackupsSlotNextResponse = BackupItemCollection;

// @public
export interface WebAppsListBackupsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBackupsSlotResponse = BackupItemCollection;

// @public
export interface WebAppsListBackupStatusSecretsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBackupStatusSecretsResponse = BackupItem;

// @public
export interface WebAppsListBackupStatusSecretsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBackupStatusSecretsSlotResponse = BackupItem;

// @public
export interface WebAppsListBasicPublishingCredentialsPoliciesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBasicPublishingCredentialsPoliciesNextResponse = PublishingCredentialsPoliciesCollection;

// @public
export interface WebAppsListBasicPublishingCredentialsPoliciesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBasicPublishingCredentialsPoliciesResponse = PublishingCredentialsPoliciesCollection;

// @public
export interface WebAppsListBasicPublishingCredentialsPoliciesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBasicPublishingCredentialsPoliciesSlotNextResponse = PublishingCredentialsPoliciesCollection;

// @public
export interface WebAppsListBasicPublishingCredentialsPoliciesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListBasicPublishingCredentialsPoliciesSlotResponse = PublishingCredentialsPoliciesCollection;

// @public
export interface WebAppsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListByResourceGroupNextResponse = WebAppCollection;

// @public
export interface WebAppsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
    includeSlots?: boolean;
}

// @public
export type WebAppsListByResourceGroupResponse = WebAppCollection;

// @public
export interface WebAppsListConfigurationSnapshotInfoNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationSnapshotInfoNextResponse = SiteConfigurationSnapshotInfoCollection;

// @public
export interface WebAppsListConfigurationSnapshotInfoOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationSnapshotInfoResponse = SiteConfigurationSnapshotInfoCollection;

// @public
export interface WebAppsListConfigurationSnapshotInfoSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationSnapshotInfoSlotNextResponse = SiteConfigurationSnapshotInfoCollection;

// @public
export interface WebAppsListConfigurationSnapshotInfoSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationSnapshotInfoSlotResponse = SiteConfigurationSnapshotInfoCollection;

// @public
export interface WebAppsListConfigurationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationsNextResponse = SiteConfigResourceCollection;

// @public
export interface WebAppsListConfigurationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationsResponse = SiteConfigResourceCollection;

// @public
export interface WebAppsListConfigurationsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationsSlotNextResponse = SiteConfigResourceCollection;

// @public
export interface WebAppsListConfigurationsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConfigurationsSlotResponse = SiteConfigResourceCollection;

// @public
export interface WebAppsListConnectionStringsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConnectionStringsResponse = ConnectionStringDictionary;

// @public
export interface WebAppsListConnectionStringsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListConnectionStringsSlotResponse = ConnectionStringDictionary;

// @public
export interface WebAppsListContinuousWebJobsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListContinuousWebJobsNextResponse = ContinuousWebJobCollection;

// @public
export interface WebAppsListContinuousWebJobsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListContinuousWebJobsResponse = ContinuousWebJobCollection;

// @public
export interface WebAppsListContinuousWebJobsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListContinuousWebJobsSlotNextResponse = ContinuousWebJobCollection;

// @public
export interface WebAppsListContinuousWebJobsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListContinuousWebJobsSlotResponse = ContinuousWebJobCollection;

// @public
export interface WebAppsListDeploymentLogOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDeploymentLogResponse = Deployment;

// @public
export interface WebAppsListDeploymentLogSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDeploymentLogSlotResponse = Deployment;

// @public
export interface WebAppsListDeploymentsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDeploymentsNextResponse = DeploymentCollection;

// @public
export interface WebAppsListDeploymentsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDeploymentsResponse = DeploymentCollection;

// @public
export interface WebAppsListDeploymentsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDeploymentsSlotNextResponse = DeploymentCollection;

// @public
export interface WebAppsListDeploymentsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDeploymentsSlotResponse = DeploymentCollection;

// @public
export interface WebAppsListDomainOwnershipIdentifiersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDomainOwnershipIdentifiersNextResponse = IdentifierCollection;

// @public
export interface WebAppsListDomainOwnershipIdentifiersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDomainOwnershipIdentifiersResponse = IdentifierCollection;

// @public
export interface WebAppsListDomainOwnershipIdentifiersSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDomainOwnershipIdentifiersSlotNextResponse = IdentifierCollection;

// @public
export interface WebAppsListDomainOwnershipIdentifiersSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListDomainOwnershipIdentifiersSlotResponse = IdentifierCollection;

// @public
export interface WebAppsListFunctionKeysOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListFunctionKeysResponse = StringDictionary;

// @public
export interface WebAppsListFunctionKeysSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListFunctionKeysSlotResponse = StringDictionary;

// @public
export interface WebAppsListFunctionSecretsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListFunctionSecretsResponse = FunctionSecrets;

// @public
export interface WebAppsListFunctionSecretsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListFunctionSecretsSlotResponse = FunctionSecrets;

// @public
export interface WebAppsListFunctionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListFunctionsNextResponse = FunctionEnvelopeCollection;

// @public
export interface WebAppsListFunctionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListFunctionsResponse = FunctionEnvelopeCollection;

// @public
export interface WebAppsListHostKeysOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHostKeysResponse = HostKeys;

// @public
export interface WebAppsListHostKeysSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHostKeysSlotResponse = HostKeys;

// @public
export interface WebAppsListHostNameBindingsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHostNameBindingsNextResponse = HostNameBindingCollection;

// @public
export interface WebAppsListHostNameBindingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHostNameBindingsResponse = HostNameBindingCollection;

// @public
export interface WebAppsListHostNameBindingsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHostNameBindingsSlotNextResponse = HostNameBindingCollection;

// @public
export interface WebAppsListHostNameBindingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHostNameBindingsSlotResponse = HostNameBindingCollection;

// @public
export interface WebAppsListHybridConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHybridConnectionsResponse = HybridConnection;

// @public
export interface WebAppsListHybridConnectionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListHybridConnectionsSlotResponse = HybridConnection;

// @public
export interface WebAppsListInstanceFunctionsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceFunctionsSlotNextResponse = FunctionEnvelopeCollection;

// @public
export interface WebAppsListInstanceFunctionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceFunctionsSlotResponse = FunctionEnvelopeCollection;

// @public
export interface WebAppsListInstanceIdentifiersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceIdentifiersNextResponse = WebAppInstanceStatusCollection;

// @public
export interface WebAppsListInstanceIdentifiersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceIdentifiersResponse = WebAppInstanceStatusCollection;

// @public
export interface WebAppsListInstanceIdentifiersSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceIdentifiersSlotNextResponse = WebAppInstanceStatusCollection;

// @public
export interface WebAppsListInstanceIdentifiersSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceIdentifiersSlotResponse = WebAppInstanceStatusCollection;

// @public
export interface WebAppsListInstanceProcessesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessesNextResponse = ProcessInfoCollection;

// @public
export interface WebAppsListInstanceProcessesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessesResponse = ProcessInfoCollection;

// @public
export interface WebAppsListInstanceProcessesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessesSlotNextResponse = ProcessInfoCollection;

// @public
export interface WebAppsListInstanceProcessesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessesSlotResponse = ProcessInfoCollection;

// @public
export interface WebAppsListInstanceProcessModulesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessModulesNextResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListInstanceProcessModulesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessModulesResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListInstanceProcessModulesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessModulesSlotNextResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListInstanceProcessModulesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessModulesSlotResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListInstanceProcessThreadsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessThreadsNextResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListInstanceProcessThreadsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessThreadsResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListInstanceProcessThreadsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessThreadsSlotNextResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListInstanceProcessThreadsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceProcessThreadsSlotResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListInstanceWorkflowsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceWorkflowsSlotNextResponse = WorkflowEnvelopeCollection;

// @public
export interface WebAppsListInstanceWorkflowsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListInstanceWorkflowsSlotResponse = WorkflowEnvelopeCollection;

// @public
export interface WebAppsListMetadataOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListMetadataResponse = StringDictionary;

// @public
export interface WebAppsListMetadataSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListMetadataSlotResponse = StringDictionary;

// @public
export interface WebAppsListNetworkFeaturesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListNetworkFeaturesResponse = NetworkFeatures;

// @public
export interface WebAppsListNetworkFeaturesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListNetworkFeaturesSlotResponse = NetworkFeatures;

// @public
export interface WebAppsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListNextResponse = WebAppCollection;

// @public
export interface WebAppsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsListPerfMonCountersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPerfMonCountersNextResponse = PerfMonCounterCollection;

// @public
export interface WebAppsListPerfMonCountersOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type WebAppsListPerfMonCountersResponse = PerfMonCounterCollection;

// @public
export interface WebAppsListPerfMonCountersSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPerfMonCountersSlotNextResponse = PerfMonCounterCollection;

// @public
export interface WebAppsListPerfMonCountersSlotOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type WebAppsListPerfMonCountersSlotResponse = PerfMonCounterCollection;

// @public
export interface WebAppsListPremierAddOnsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPremierAddOnsResponse = PremierAddOn;

// @public
export interface WebAppsListPremierAddOnsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPremierAddOnsSlotResponse = PremierAddOn;

// @public
export interface WebAppsListProcessesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessesNextResponse = ProcessInfoCollection;

// @public
export interface WebAppsListProcessesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessesResponse = ProcessInfoCollection;

// @public
export interface WebAppsListProcessesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessesSlotNextResponse = ProcessInfoCollection;

// @public
export interface WebAppsListProcessesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessesSlotResponse = ProcessInfoCollection;

// @public
export interface WebAppsListProcessModulesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessModulesNextResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListProcessModulesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessModulesResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListProcessModulesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessModulesSlotNextResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListProcessModulesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessModulesSlotResponse = ProcessModuleInfoCollection;

// @public
export interface WebAppsListProcessThreadsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessThreadsNextResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListProcessThreadsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessThreadsResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListProcessThreadsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessThreadsSlotNextResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListProcessThreadsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProcessThreadsSlotResponse = ProcessThreadInfoCollection;

// @public
export interface WebAppsListProductionSiteDeploymentStatusesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProductionSiteDeploymentStatusesNextResponse = CsmDeploymentStatusCollection;

// @public
export interface WebAppsListProductionSiteDeploymentStatusesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListProductionSiteDeploymentStatusesResponse = CsmDeploymentStatusCollection;

// @public
export interface WebAppsListPublicCertificatesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPublicCertificatesNextResponse = PublicCertificateCollection;

// @public
export interface WebAppsListPublicCertificatesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPublicCertificatesResponse = PublicCertificateCollection;

// @public
export interface WebAppsListPublicCertificatesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPublicCertificatesSlotNextResponse = PublicCertificateCollection;

// @public
export interface WebAppsListPublicCertificatesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPublicCertificatesSlotResponse = PublicCertificateCollection;

// @public
export interface WebAppsListPublishingCredentialsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsListPublishingCredentialsResponse = User;

// @public
export interface WebAppsListPublishingCredentialsSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsListPublishingCredentialsSlotResponse = User;

// @public
export interface WebAppsListPublishingProfileXmlWithSecretsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPublishingProfileXmlWithSecretsResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsListPublishingProfileXmlWithSecretsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListPublishingProfileXmlWithSecretsSlotResponse = {
    blobBody?: Promise<Blob>;
    readableStreamBody?: NodeJS.ReadableStream;
};

// @public
export interface WebAppsListRelayServiceConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListRelayServiceConnectionsResponse = RelayServiceConnectionEntity;

// @public
export interface WebAppsListRelayServiceConnectionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListRelayServiceConnectionsSlotResponse = RelayServiceConnectionEntity;

// @public
export type WebAppsListResponse = WebAppCollection;

// @public
export interface WebAppsListSiteBackupsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteBackupsNextResponse = BackupItemCollection;

// @public
export interface WebAppsListSiteBackupsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteBackupsResponse = BackupItemCollection;

// @public
export interface WebAppsListSiteBackupsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteBackupsSlotNextResponse = BackupItemCollection;

// @public
export interface WebAppsListSiteBackupsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteBackupsSlotResponse = BackupItemCollection;

// @public
export interface WebAppsListSiteContainersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteContainersNextResponse = SiteContainerCollection;

// @public
export interface WebAppsListSiteContainersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteContainersResponse = SiteContainerCollection;

// @public
export interface WebAppsListSiteContainersSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteContainersSlotNextResponse = SiteContainerCollection;

// @public
export interface WebAppsListSiteContainersSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteContainersSlotResponse = SiteContainerCollection;

// @public
export interface WebAppsListSiteExtensionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteExtensionsNextResponse = SiteExtensionInfoCollection;

// @public
export interface WebAppsListSiteExtensionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteExtensionsResponse = SiteExtensionInfoCollection;

// @public
export interface WebAppsListSiteExtensionsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteExtensionsSlotNextResponse = SiteExtensionInfoCollection;

// @public
export interface WebAppsListSiteExtensionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSiteExtensionsSlotResponse = SiteExtensionInfoCollection;

// @public
export interface WebAppsListSitePushSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSitePushSettingsResponse = PushSettings;

// @public
export interface WebAppsListSitePushSettingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSitePushSettingsSlotResponse = PushSettings;

// @public
export interface WebAppsListSlotConfigurationNamesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotConfigurationNamesResponse = SlotConfigNamesResource;

// @public
export interface WebAppsListSlotDifferencesFromProductionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotDifferencesFromProductionNextResponse = SlotDifferenceCollection;

// @public
export interface WebAppsListSlotDifferencesFromProductionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotDifferencesFromProductionResponse = SlotDifferenceCollection;

// @public
export interface WebAppsListSlotDifferencesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotDifferencesSlotNextResponse = SlotDifferenceCollection;

// @public
export interface WebAppsListSlotDifferencesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotDifferencesSlotResponse = SlotDifferenceCollection;

// @public
export interface WebAppsListSlotSiteDeploymentStatusesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotSiteDeploymentStatusesSlotNextResponse = CsmDeploymentStatusCollection;

// @public
export interface WebAppsListSlotSiteDeploymentStatusesSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotSiteDeploymentStatusesSlotResponse = CsmDeploymentStatusCollection;

// @public
export interface WebAppsListSlotsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotsNextResponse = WebAppCollection;

// @public
export interface WebAppsListSlotsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSlotsResponse = WebAppCollection;

// @public
export interface WebAppsListSnapshotsFromDRSecondaryNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsFromDRSecondaryNextResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsFromDRSecondaryOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsFromDRSecondaryResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsFromDRSecondarySlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsFromDRSecondarySlotNextResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsFromDRSecondarySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsFromDRSecondarySlotResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsNextResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsSlotNextResponse = SnapshotCollection;

// @public
export interface WebAppsListSnapshotsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSnapshotsSlotResponse = SnapshotCollection;

// @public
export interface WebAppsListSyncFunctionTriggersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSyncFunctionTriggersResponse = FunctionSecrets;

// @public
export interface WebAppsListSyncFunctionTriggersSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListSyncFunctionTriggersSlotResponse = FunctionSecrets;

// @public
export interface WebAppsListSyncStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsListSyncStatusSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsListTriggeredWebJobHistoryNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobHistoryNextResponse = TriggeredJobHistoryCollection;

// @public
export interface WebAppsListTriggeredWebJobHistoryOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobHistoryResponse = TriggeredJobHistoryCollection;

// @public
export interface WebAppsListTriggeredWebJobHistorySlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobHistorySlotNextResponse = TriggeredJobHistoryCollection;

// @public
export interface WebAppsListTriggeredWebJobHistorySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobHistorySlotResponse = TriggeredJobHistoryCollection;

// @public
export interface WebAppsListTriggeredWebJobsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobsNextResponse = TriggeredWebJobCollection;

// @public
export interface WebAppsListTriggeredWebJobsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobsResponse = TriggeredWebJobCollection;

// @public
export interface WebAppsListTriggeredWebJobsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobsSlotNextResponse = TriggeredWebJobCollection;

// @public
export interface WebAppsListTriggeredWebJobsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListTriggeredWebJobsSlotResponse = TriggeredWebJobCollection;

// @public
export interface WebAppsListUsagesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListUsagesNextResponse = CsmUsageQuotaCollection;

// @public
export interface WebAppsListUsagesOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type WebAppsListUsagesResponse = CsmUsageQuotaCollection;

// @public
export interface WebAppsListUsagesSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListUsagesSlotNextResponse = CsmUsageQuotaCollection;

// @public
export interface WebAppsListUsagesSlotOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type WebAppsListUsagesSlotResponse = CsmUsageQuotaCollection;

// @public
export interface WebAppsListVnetConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListVnetConnectionsResponse = VnetInfoResource[];

// @public
export interface WebAppsListVnetConnectionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListVnetConnectionsSlotResponse = VnetInfoResource[];

// @public
export interface WebAppsListWebJobsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWebJobsNextResponse = WebJobCollection;

// @public
export interface WebAppsListWebJobsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWebJobsResponse = WebJobCollection;

// @public
export interface WebAppsListWebJobsSlotNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWebJobsSlotNextResponse = WebJobCollection;

// @public
export interface WebAppsListWebJobsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWebJobsSlotResponse = WebJobCollection;

// @public
export interface WebAppsListWorkflowsConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWorkflowsConnectionsResponse = WorkflowEnvelope;

// @public
export interface WebAppsListWorkflowsConnectionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWorkflowsConnectionsSlotResponse = WorkflowEnvelope;

// @public
export interface WebAppsListWorkflowsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWorkflowsNextResponse = WorkflowEnvelopeCollection;

// @public
export interface WebAppsListWorkflowsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsListWorkflowsResponse = WorkflowEnvelopeCollection;

// @public
export interface WebAppsMigrateMySqlOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsMigrateMySqlResponse = Operation;

// @public
export interface WebAppsMigrateStorageOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsMigrateStorageResponse = StorageMigrationResponse;

// @public
export interface WebAppsPutPrivateAccessVnetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsPutPrivateAccessVnetResponse = PrivateAccess;

// @public
export interface WebAppsPutPrivateAccessVnetSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsPutPrivateAccessVnetSlotResponse = PrivateAccess;

// @public
export interface WebAppsRecoverSiteConfigurationSnapshotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsRecoverSiteConfigurationSnapshotSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsResetProductionSlotConfigOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsResetSlotConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsRestartOptionalParams extends coreClient.OperationOptions {
    softRestart?: boolean;
    synchronous?: boolean;
}

// @public
export interface WebAppsRestartSlotOptionalParams extends coreClient.OperationOptions {
    softRestart?: boolean;
    synchronous?: boolean;
}

// @public
export interface WebAppsRestoreFromBackupBlobOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreFromBackupBlobSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreFromDeletedAppOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreFromDeletedAppSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreSnapshotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRestoreSnapshotSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsRunTriggeredWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsRunTriggeredWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStartContinuousWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStartContinuousWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStartNetworkTraceOptionalParams extends coreClient.OperationOptions {
    durationInSeconds?: number;
    maxFrameLength?: number;
    resumeFrom?: string;
    sasUrl?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsStartNetworkTraceResponse = NetworkTrace[];

// @public
export interface WebAppsStartNetworkTraceSlotOptionalParams extends coreClient.OperationOptions {
    durationInSeconds?: number;
    maxFrameLength?: number;
    resumeFrom?: string;
    sasUrl?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsStartNetworkTraceSlotResponse = NetworkTrace[];

// @public
export interface WebAppsStartOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStartSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStartWebSiteNetworkTraceOperationOptionalParams extends coreClient.OperationOptions {
    durationInSeconds?: number;
    maxFrameLength?: number;
    resumeFrom?: string;
    sasUrl?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsStartWebSiteNetworkTraceOperationResponse = NetworkTrace[];

// @public
export interface WebAppsStartWebSiteNetworkTraceOperationSlotOptionalParams extends coreClient.OperationOptions {
    durationInSeconds?: number;
    maxFrameLength?: number;
    resumeFrom?: string;
    sasUrl?: string;
    updateIntervalInMs?: number;
}

// @public
export type WebAppsStartWebSiteNetworkTraceOperationSlotResponse = NetworkTrace[];

// @public
export interface WebAppsStartWebSiteNetworkTraceOptionalParams extends coreClient.OperationOptions {
    durationInSeconds?: number;
    maxFrameLength?: number;
    sasUrl?: string;
}

// @public
export type WebAppsStartWebSiteNetworkTraceResponse = {
    body: string;
};

// @public
export interface WebAppsStartWebSiteNetworkTraceSlotOptionalParams extends coreClient.OperationOptions {
    durationInSeconds?: number;
    maxFrameLength?: number;
    sasUrl?: string;
}

// @public
export type WebAppsStartWebSiteNetworkTraceSlotResponse = {
    body: string;
};

// @public
export interface WebAppsStopContinuousWebJobOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopContinuousWebJobSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopNetworkTraceOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopNetworkTraceSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopWebSiteNetworkTraceOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsStopWebSiteNetworkTraceSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsSwapSlotOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsSwapSlotWithProductionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebAppsSyncFunctionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsSyncFunctionsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsSyncFunctionTriggersOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsSyncFunctionTriggersSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsSyncRepositoryOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsSyncRepositorySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppStack extends ProxyOnlyResource {
    readonly displayText?: string;
    readonly location?: string;
    readonly majorVersions?: WebAppMajorVersion[];
    readonly preferredOs?: StackPreferredOs;
    readonly value?: string;
}

// @public
export interface WebAppStackCollection {
    readonly nextLink?: string;
    value: WebAppStack[];
}

// @public
export interface WebAppsUpdateApplicationSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateApplicationSettingsResponse = StringDictionary;

// @public
export interface WebAppsUpdateApplicationSettingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateApplicationSettingsSlotResponse = StringDictionary;

// @public
export interface WebAppsUpdateAuthSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateAuthSettingsResponse = SiteAuthSettings;

// @public
export interface WebAppsUpdateAuthSettingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateAuthSettingsSlotResponse = SiteAuthSettings;

// @public
export interface WebAppsUpdateAuthSettingsV2OptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateAuthSettingsV2Response = SiteAuthSettingsV2;

// @public
export interface WebAppsUpdateAuthSettingsV2SlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateAuthSettingsV2SlotResponse = SiteAuthSettingsV2;

// @public
export interface WebAppsUpdateAzureStorageAccountsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateAzureStorageAccountsResponse = AzureStoragePropertyDictionaryResource;

// @public
export interface WebAppsUpdateAzureStorageAccountsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateAzureStorageAccountsSlotResponse = AzureStoragePropertyDictionaryResource;

// @public
export interface WebAppsUpdateBackupConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateBackupConfigurationResponse = BackupRequest;

// @public
export interface WebAppsUpdateBackupConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateBackupConfigurationSlotResponse = BackupRequest;

// @public
export interface WebAppsUpdateConfigurationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateConfigurationResponse = SiteConfigResource;

// @public
export interface WebAppsUpdateConfigurationSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateConfigurationSlotResponse = SiteConfigResource;

// @public
export interface WebAppsUpdateConnectionStringsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateConnectionStringsResponse = ConnectionStringDictionary;

// @public
export interface WebAppsUpdateConnectionStringsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateConnectionStringsSlotResponse = ConnectionStringDictionary;

// @public
export interface WebAppsUpdateDiagnosticLogsConfigOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateDiagnosticLogsConfigResponse = SiteLogsConfig;

// @public
export interface WebAppsUpdateDiagnosticLogsConfigSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateDiagnosticLogsConfigSlotResponse = SiteLogsConfig;

// @public
export interface WebAppsUpdateDomainOwnershipIdentifierOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateDomainOwnershipIdentifierResponse = Identifier;

// @public
export interface WebAppsUpdateDomainOwnershipIdentifierSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateDomainOwnershipIdentifierSlotResponse = Identifier;

// @public
export interface WebAppsUpdateFtpAllowedOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateFtpAllowedResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsUpdateFtpAllowedSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateFtpAllowedSlotResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsUpdateHybridConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateHybridConnectionResponse = HybridConnection;

// @public
export interface WebAppsUpdateHybridConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateHybridConnectionSlotResponse = HybridConnection;

// @public
export interface WebAppsUpdateMetadataOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateMetadataResponse = StringDictionary;

// @public
export interface WebAppsUpdateMetadataSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateMetadataSlotResponse = StringDictionary;

// @public
export interface WebAppsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WebAppsUpdatePremierAddOnOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdatePremierAddOnResponse = PremierAddOn;

// @public
export interface WebAppsUpdatePremierAddOnSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdatePremierAddOnSlotResponse = PremierAddOn;

// @public
export interface WebAppsUpdateRelayServiceConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateRelayServiceConnectionResponse = RelayServiceConnectionEntity;

// @public
export interface WebAppsUpdateRelayServiceConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateRelayServiceConnectionSlotResponse = RelayServiceConnectionEntity;

// @public
export type WebAppsUpdateResponse = Site;

// @public
export interface WebAppsUpdateScmAllowedOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateScmAllowedResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsUpdateScmAllowedSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateScmAllowedSlotResponse = CsmPublishingCredentialsPoliciesEntity;

// @public
export interface WebAppsUpdateSitePushSettingsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSitePushSettingsResponse = PushSettings;

// @public
export interface WebAppsUpdateSitePushSettingsSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSitePushSettingsSlotResponse = PushSettings;

// @public
export interface WebAppsUpdateSlotConfigurationNamesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSlotConfigurationNamesResponse = SlotConfigNamesResource;

// @public
export interface WebAppsUpdateSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSlotResponse = Site;

// @public
export interface WebAppsUpdateSourceControlOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSourceControlResponse = SiteSourceControl;

// @public
export interface WebAppsUpdateSourceControlSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSourceControlSlotResponse = SiteSourceControl;

// @public
export interface WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckResponse = SwiftVirtualNetwork;

// @public
export interface WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateSwiftVirtualNetworkConnectionWithCheckSlotResponse = SwiftVirtualNetwork;

// @public
export interface WebAppsUpdateVnetConnectionGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateVnetConnectionGatewayResponse = VnetGateway;

// @public
export interface WebAppsUpdateVnetConnectionGatewaySlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateVnetConnectionGatewaySlotResponse = VnetGateway;

// @public
export interface WebAppsUpdateVnetConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateVnetConnectionResponse = VnetInfoResource;

// @public
export interface WebAppsUpdateVnetConnectionSlotOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebAppsUpdateVnetConnectionSlotResponse = VnetInfoResource;

// @public
export interface WebJob extends ProxyOnlyResource {
    error?: string;
    extraInfoUrl?: string;
    runCommand?: string;
    settings?: {
        [propertyName: string]: Record<string, unknown>;
    };
    url?: string;
    usingSdk?: boolean;
    webJobType?: WebJobType;
}

// @public
export interface WebJobCollection {
    readonly nextLink?: string;
    value: WebJob[];
}

// @public
export type WebJobType = "Continuous" | "Triggered";

// @public (undocumented)
export interface WebSiteInstanceStatus extends ProxyOnlyResource {
    consoleUrl?: string;
    containers?: {
        [propertyName: string]: ContainerInfo;
    };
    detectorUrl?: string;
    healthCheckUrl?: string;
    // (undocumented)
    state?: SiteRuntimeState;
    statusUrl?: string;
}

// @public (undocumented)
export class WebSiteManagementClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: WebSiteManagementClientOptionalParams);
    constructor(credentials: coreAuth.TokenCredential, options?: WebSiteManagementClientOptionalParams);
    // (undocumented)
    apiVersion: string;
    // (undocumented)
    appServiceCertificateOrders: AppServiceCertificateOrders;
    // (undocumented)
    appServiceEnvironments: AppServiceEnvironments;
    // (undocumented)
    appServicePlans: AppServicePlans;
    // (undocumented)
    certificateOrdersDiagnostics: CertificateOrdersDiagnostics;
    // (undocumented)
    certificateRegistrationProvider: CertificateRegistrationProvider;
    // (undocumented)
    certificates: Certificates;
    checkNameAvailability(name: string, typeParam: CheckNameResourceTypes, options?: CheckNameAvailabilityOptionalParams): Promise<CheckNameAvailabilityResponse>;
    // (undocumented)
    containerApps: ContainerApps;
    // (undocumented)
    containerAppsRevisions: ContainerAppsRevisions;
    // (undocumented)
    deletedWebApps: DeletedWebApps;
    // (undocumented)
    diagnostics: Diagnostics;
    // (undocumented)
    domainRegistrationProvider: DomainRegistrationProvider;
    // (undocumented)
    domains: Domains;
    getPublishingUser(options?: GetPublishingUserOptionalParams): Promise<GetPublishingUserResponse>;
    getSourceControl(sourceControlType: string, options?: GetSourceControlOptionalParams): Promise<GetSourceControlResponse>;
    getSubscriptionDeploymentLocations(options?: GetSubscriptionDeploymentLocationsOptionalParams): Promise<GetSubscriptionDeploymentLocationsResponse>;
    // (undocumented)
    getUsagesInLocation: GetUsagesInLocation;
    // (undocumented)
    global: Global_2;
    // (undocumented)
    kubeEnvironments: KubeEnvironments;
    listAseRegions(options?: ListAseRegionsOptionalParams): PagedAsyncIterableIterator<AseRegion>;
    listBillingMeters(options?: ListBillingMetersOptionalParams): PagedAsyncIterableIterator<BillingMeter>;
    listCustomHostNameSites(options?: ListCustomHostNameSitesOptionalParams): PagedAsyncIterableIterator<CustomHostnameSites>;
    listGeoRegions(options?: ListGeoRegionsOptionalParams): PagedAsyncIterableIterator<GeoRegion>;
    listPremierAddOnOffers(options?: ListPremierAddOnOffersOptionalParams): PagedAsyncIterableIterator<PremierAddOnOffer>;
    listSiteIdentifiersAssignedToHostName(nameIdentifier: NameIdentifier, options?: ListSiteIdentifiersAssignedToHostNameOptionalParams): PagedAsyncIterableIterator<Identifier>;
    listSkus(options?: ListSkusOptionalParams): Promise<ListSkusResponse>;
    listSourceControls(options?: ListSourceControlsOptionalParams): PagedAsyncIterableIterator<SourceControl>;
    move(resourceGroupName: string, moveResourceEnvelope: CsmMoveResourceEnvelope, options?: MoveOptionalParams): Promise<void>;
    // (undocumented)
    provider: Provider;
    // (undocumented)
    recommendations: Recommendations;
    // (undocumented)
    resourceHealthMetadataOperations: ResourceHealthMetadataOperations;
    // (undocumented)
    staticSites: StaticSites;
    // (undocumented)
    subscriptionId?: string;
    // (undocumented)
    topLevelDomains: TopLevelDomains;
    updatePublishingUser(userDetails: User, options?: UpdatePublishingUserOptionalParams): Promise<UpdatePublishingUserResponse>;
    updateSourceControl(sourceControlType: string, requestMessage: SourceControl, options?: UpdateSourceControlOptionalParams): Promise<UpdateSourceControlResponse>;
    validate(resourceGroupName: string, validateRequest: ValidateRequest, options?: ValidateOptionalParams): Promise<ValidateOperationResponse>;
    validateMove(resourceGroupName: string, moveResourceEnvelope: CsmMoveResourceEnvelope, options?: ValidateMoveOptionalParams): Promise<void>;
    verifyHostingEnvironmentVnet(parameters: VnetParameters, options?: VerifyHostingEnvironmentVnetOptionalParams): Promise<VerifyHostingEnvironmentVnetResponse>;
    // (undocumented)
    webApps: WebApps;
    // (undocumented)
    workflowRunActionRepetitions: WorkflowRunActionRepetitions;
    // (undocumented)
    workflowRunActionRepetitionsRequestHistories: WorkflowRunActionRepetitionsRequestHistories;
    // (undocumented)
    workflowRunActions: WorkflowRunActions;
    // (undocumented)
    workflowRunActionScopeRepetitions: WorkflowRunActionScopeRepetitions;
    // (undocumented)
    workflowRuns: WorkflowRuns;
    // (undocumented)
    workflows: Workflows;
    // (undocumented)
    workflowTriggerHistories: WorkflowTriggerHistories;
    // (undocumented)
    workflowTriggers: WorkflowTriggers;
    // (undocumented)
    workflowVersions: WorkflowVersions;
}

// @public
export interface WebSiteManagementClientOptionalParams extends coreClient.ServiceClientOptions {
    $host?: string;
    apiVersion?: string;
    endpoint?: string;
}

// @public
export interface WindowsJavaContainerSettings {
    readonly endOfLifeDate?: Date;
    readonly isAutoUpdate?: boolean;
    readonly isDeprecated?: boolean;
    readonly isEarlyAccess?: boolean;
    readonly isHidden?: boolean;
    readonly isPreview?: boolean;
    readonly javaContainer?: string;
    readonly javaContainerVersion?: string;
}

// @public
export interface WorkerPoolCollection {
    readonly nextLink?: string;
    value: WorkerPoolResource[];
}

// @public
export interface WorkerPoolResource extends ProxyOnlyResource {
    computeMode?: ComputeModeOptions;
    readonly instanceNames?: string[];
    sku?: SkuDescription;
    workerCount?: number;
    workerSize?: string;
    workerSizeId?: number;
}

// @public
export type WorkerSizeOptions = "Small" | "Medium" | "Large" | "D1" | "D2" | "D3" | "SmallV3" | "MediumV3" | "LargeV3" | "NestedSmall" | "NestedSmallLinux" | "Default";

// @public
export interface Workflow extends WorkflowResource {
    accessControl?: FlowAccessControlConfiguration;
    readonly accessEndpoint?: string;
    readonly changedTime?: Date;
    readonly createdTime?: Date;
    definition?: Record<string, unknown>;
    endpointsConfiguration?: FlowEndpointsConfiguration;
    identity?: ManagedServiceIdentity;
    integrationAccount?: ResourceReference;
    integrationServiceEnvironment?: ResourceReference;
    kind?: Kind;
    parameters?: {
        [propertyName: string]: WorkflowParameter;
    };
    readonly provisioningState?: WorkflowProvisioningState;
    readonly sku?: WorkflowSku;
    state?: WorkflowState;
    readonly version?: string;
}

// @public
export interface WorkflowArtifacts {
    appSettings?: Record<string, unknown>;
    files?: {
        [propertyName: string]: Record<string, unknown>;
    };
    filesToDelete?: string[];
}

// @public
export interface WorkflowEnvelope {
    readonly id?: string;
    kind?: string;
    location?: string;
    readonly name?: string;
    properties?: WorkflowEnvelopeProperties;
    readonly type?: string;
}

// @public
export interface WorkflowEnvelopeCollection {
    readonly nextLink?: string;
    value: WorkflowEnvelope[];
}

// @public
export interface WorkflowEnvelopeProperties {
    files?: {
        [propertyName: string]: Record<string, unknown>;
    };
    flowState?: WorkflowState;
    health?: WorkflowHealth;
}

// @public
export interface WorkflowFilter {
    state?: WorkflowState;
}

// @public
export interface WorkflowHealth {
    error?: ErrorEntity;
    state: WorkflowHealthState;
}

// @public
export type WorkflowHealthState = "NotSpecified" | "Healthy" | "Unhealthy" | "Unknown";

// @public
export interface WorkflowListResult {
    nextLink?: string;
    value?: Workflow[];
}

// @public
export interface WorkflowOutputParameter extends WorkflowParameter {
    readonly error?: Record<string, unknown>;
}

// @public
export interface WorkflowParameter {
    description?: string;
    metadata?: Record<string, unknown>;
    type?: ParameterType;
    value?: Record<string, unknown>;
}

// @public
export type WorkflowProvisioningState = string;

// @public
export interface WorkflowResource {
    readonly id?: string;
    location?: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface WorkflowRun extends SubResource {
    readonly code?: string;
    correlation?: Correlation;
    readonly correlationId?: string;
    readonly endTime?: Date;
    readonly error?: Record<string, unknown>;
    readonly name?: string;
    readonly outputs?: {
        [propertyName: string]: WorkflowOutputParameter;
    };
    readonly response?: WorkflowRunTrigger;
    readonly startTime?: Date;
    readonly status?: WorkflowStatus;
    readonly trigger?: WorkflowRunTrigger;
    readonly type?: string;
    readonly waitEndTime?: Date;
    readonly workflow?: ResourceReference;
}

// @public
export interface WorkflowRunAction extends SubResource {
    readonly code?: string;
    correlation?: RunActionCorrelation;
    readonly endTime?: Date;
    readonly error?: Record<string, unknown>;
    readonly inputsLink?: ContentLink;
    readonly name?: string;
    readonly outputsLink?: ContentLink;
    retryHistory?: RetryHistory[];
    readonly startTime?: Date;
    readonly status?: WorkflowStatus;
    readonly trackedProperties?: Record<string, unknown>;
    readonly trackingId?: string;
    readonly type?: string;
}

// @public
export interface WorkflowRunActionFilter {
    status?: WorkflowStatus;
}

// @public
export interface WorkflowRunActionListResult {
    nextLink?: string;
    value?: WorkflowRunAction[];
}

// @public
export interface WorkflowRunActionRepetitionDefinition extends WorkflowResource {
    code?: string;
    correlation?: RunActionCorrelation;
    endTime?: Date;
    error?: any;
    readonly inputs?: Record<string, unknown>;
    readonly inputsLink?: ContentLink;
    // (undocumented)
    iterationCount?: number;
    readonly outputs?: Record<string, unknown>;
    readonly outputsLink?: ContentLink;
    repetitionIndexes?: RepetitionIndex[];
    retryHistory?: RetryHistory[];
    startTime?: Date;
    status?: WorkflowStatus;
    readonly trackedProperties?: Record<string, unknown>;
    readonly trackingId?: string;
}

// @public
export interface WorkflowRunActionRepetitionDefinitionCollection {
    nextLink?: string;
    // (undocumented)
    value?: WorkflowRunActionRepetitionDefinition[];
}

// @public
export interface WorkflowRunActionRepetitionProperties extends OperationResult {
    repetitionIndexes?: RepetitionIndex[];
}

// @public
export interface WorkflowRunActionRepetitions {
    get(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, repetitionName: string, options?: WorkflowRunActionRepetitionsGetOptionalParams): Promise<WorkflowRunActionRepetitionsGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, options?: WorkflowRunActionRepetitionsListOptionalParams): PagedAsyncIterableIterator<WorkflowRunActionRepetitionDefinition>;
    listExpressionTraces(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, repetitionName: string, options?: WorkflowRunActionRepetitionsListExpressionTracesOptionalParams): PagedAsyncIterableIterator<ExpressionRoot>;
}

// @public
export interface WorkflowRunActionRepetitionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsGetResponse = WorkflowRunActionRepetitionDefinition;

// @public
export interface WorkflowRunActionRepetitionsListExpressionTracesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsListExpressionTracesNextResponse = ExpressionTraces;

// @public
export interface WorkflowRunActionRepetitionsListExpressionTracesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsListExpressionTracesResponse = ExpressionTraces;

// @public
export interface WorkflowRunActionRepetitionsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsListNextResponse = WorkflowRunActionRepetitionDefinitionCollection;

// @public
export interface WorkflowRunActionRepetitionsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsListResponse = WorkflowRunActionRepetitionDefinitionCollection;

// @public
export interface WorkflowRunActionRepetitionsRequestHistories {
    get(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, repetitionName: string, requestHistoryName: string, options?: WorkflowRunActionRepetitionsRequestHistoriesGetOptionalParams): Promise<WorkflowRunActionRepetitionsRequestHistoriesGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, repetitionName: string, options?: WorkflowRunActionRepetitionsRequestHistoriesListOptionalParams): PagedAsyncIterableIterator<RequestHistory>;
}

// @public
export interface WorkflowRunActionRepetitionsRequestHistoriesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsRequestHistoriesGetResponse = RequestHistory;

// @public
export interface WorkflowRunActionRepetitionsRequestHistoriesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsRequestHistoriesListNextResponse = RequestHistoryListResult;

// @public
export interface WorkflowRunActionRepetitionsRequestHistoriesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionRepetitionsRequestHistoriesListResponse = RequestHistoryListResult;

// @public
export interface WorkflowRunActions {
    get(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, options?: WorkflowRunActionsGetOptionalParams): Promise<WorkflowRunActionsGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, runName: string, options?: WorkflowRunActionsListOptionalParams): PagedAsyncIterableIterator<WorkflowRunAction>;
    listExpressionTraces(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, options?: WorkflowRunActionsListExpressionTracesOptionalParams): PagedAsyncIterableIterator<ExpressionRoot>;
}

// @public
export interface WorkflowRunActionScopeRepetitions {
    get(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, repetitionName: string, options?: WorkflowRunActionScopeRepetitionsGetOptionalParams): Promise<WorkflowRunActionScopeRepetitionsGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, runName: string, actionName: string, options?: WorkflowRunActionScopeRepetitionsListOptionalParams): PagedAsyncIterableIterator<WorkflowRunActionRepetitionDefinition>;
}

// @public
export interface WorkflowRunActionScopeRepetitionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionScopeRepetitionsGetResponse = WorkflowRunActionRepetitionDefinition;

// @public
export interface WorkflowRunActionScopeRepetitionsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionScopeRepetitionsListNextResponse = WorkflowRunActionRepetitionDefinitionCollection;

// @public
export interface WorkflowRunActionScopeRepetitionsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionScopeRepetitionsListResponse = WorkflowRunActionRepetitionDefinitionCollection;

// @public
export interface WorkflowRunActionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionsGetResponse = WorkflowRunAction;

// @public
export interface WorkflowRunActionsListExpressionTracesNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionsListExpressionTracesNextResponse = ExpressionTraces;

// @public
export interface WorkflowRunActionsListExpressionTracesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionsListExpressionTracesResponse = ExpressionTraces;

// @public
export interface WorkflowRunActionsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunActionsListNextResponse = WorkflowRunActionListResult;

// @public
export interface WorkflowRunActionsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    top?: number;
}

// @public
export type WorkflowRunActionsListResponse = WorkflowRunActionListResult;

// @public
export interface WorkflowRunFilter {
    status?: WorkflowStatus;
}

// @public
export interface WorkflowRunListResult {
    nextLink?: string;
    value?: WorkflowRun[];
}

// @public
export interface WorkflowRuns {
    cancel(resourceGroupName: string, name: string, workflowName: string, runName: string, options?: WorkflowRunsCancelOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, workflowName: string, runName: string, options?: WorkflowRunsGetOptionalParams): Promise<WorkflowRunsGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, options?: WorkflowRunsListOptionalParams): PagedAsyncIterableIterator<WorkflowRun>;
}

// @public
export interface WorkflowRunsCancelOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WorkflowRunsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunsGetResponse = WorkflowRun;

// @public
export interface WorkflowRunsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowRunsListNextResponse = WorkflowRunListResult;

// @public
export interface WorkflowRunsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    top?: number;
}

// @public
export type WorkflowRunsListResponse = WorkflowRunListResult;

// @public
export interface WorkflowRunTrigger {
    readonly code?: string;
    correlation?: Correlation;
    readonly endTime?: Date;
    readonly error?: Record<string, unknown>;
    readonly inputs?: Record<string, unknown>;
    readonly inputsLink?: ContentLink;
    readonly name?: string;
    readonly outputs?: Record<string, unknown>;
    readonly outputsLink?: ContentLink;
    readonly scheduledTime?: Date;
    readonly startTime?: Date;
    readonly status?: WorkflowStatus;
    readonly trackedProperties?: Record<string, unknown>;
    readonly trackingId?: string;
}

// @public
export interface Workflows {
    regenerateAccessKey(resourceGroupName: string, name: string, workflowName: string, keyType: RegenerateActionParameter, options?: WorkflowsRegenerateAccessKeyOptionalParams): Promise<void>;
    validate(resourceGroupName: string, name: string, workflowName: string, validate: Workflow, options?: WorkflowsValidateOptionalParams): Promise<void>;
}

// @public
export interface WorkflowSku {
    name: WorkflowSkuName;
    plan?: ResourceReference;
}

// @public
export type WorkflowSkuName = string;

// @public
export interface WorkflowsRegenerateAccessKeyOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowState = string;

// @public
export type WorkflowStatus = string;

// @public
export interface WorkflowsValidateOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface WorkflowTrigger extends SubResource {
    readonly changedTime?: Date;
    readonly createdTime?: Date;
    readonly lastExecutionTime?: Date;
    readonly name?: string;
    readonly nextExecutionTime?: Date;
    readonly provisioningState?: WorkflowTriggerProvisioningState;
    readonly recurrence?: WorkflowTriggerRecurrence;
    readonly state?: WorkflowState;
    readonly status?: WorkflowStatus;
    readonly type?: string;
    readonly workflow?: ResourceReference;
}

// @public
export interface WorkflowTriggerCallbackUrl {
    readonly basePath?: string;
    readonly method?: string;
    queries?: WorkflowTriggerListCallbackUrlQueries;
    readonly relativePath?: string;
    relativePathParameters?: string[];
    readonly value?: string;
}

// @public
export interface WorkflowTriggerFilter {
    state?: WorkflowState;
}

// @public
export interface WorkflowTriggerHistories {
    beginResubmit(resourceGroupName: string, name: string, workflowName: string, triggerName: string, historyName: string, options?: WorkflowTriggerHistoriesResubmitOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginResubmitAndWait(resourceGroupName: string, name: string, workflowName: string, triggerName: string, historyName: string, options?: WorkflowTriggerHistoriesResubmitOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, workflowName: string, triggerName: string, historyName: string, options?: WorkflowTriggerHistoriesGetOptionalParams): Promise<WorkflowTriggerHistoriesGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, triggerName: string, options?: WorkflowTriggerHistoriesListOptionalParams): PagedAsyncIterableIterator<WorkflowTriggerHistory>;
}

// @public
export interface WorkflowTriggerHistoriesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowTriggerHistoriesGetResponse = WorkflowTriggerHistory;

// @public
export interface WorkflowTriggerHistoriesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowTriggerHistoriesListNextResponse = WorkflowTriggerHistoryListResult;

// @public
export interface WorkflowTriggerHistoriesListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    top?: number;
}

// @public
export type WorkflowTriggerHistoriesListResponse = WorkflowTriggerHistoryListResult;

// @public
export interface WorkflowTriggerHistoriesResubmitOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WorkflowTriggerHistory extends SubResource {
    readonly code?: string;
    correlation?: Correlation;
    readonly endTime?: Date;
    readonly error?: Record<string, unknown>;
    readonly fired?: boolean;
    readonly inputsLink?: ContentLink;
    readonly name?: string;
    readonly outputsLink?: ContentLink;
    readonly run?: ResourceReference;
    readonly scheduledTime?: Date;
    readonly startTime?: Date;
    readonly status?: WorkflowStatus;
    readonly trackingId?: string;
    readonly type?: string;
}

// @public
export interface WorkflowTriggerHistoryFilter {
    status?: WorkflowStatus;
}

// @public
export interface WorkflowTriggerHistoryListResult {
    nextLink?: string;
    value?: WorkflowTriggerHistory[];
}

// @public
export interface WorkflowTriggerListCallbackUrlQueries {
    apiVersion?: string;
    se?: string;
    sig?: string;
    sp?: string;
    sv?: string;
}

// @public
export interface WorkflowTriggerListResult {
    nextLink?: string;
    value?: WorkflowTrigger[];
}

// @public
export type WorkflowTriggerProvisioningState = string;

// @public
export interface WorkflowTriggerRecurrence {
    endTime?: string;
    frequency?: RecurrenceFrequency;
    interval?: number;
    schedule?: RecurrenceSchedule;
    startTime?: string;
    timeZone?: string;
}

// @public
export interface WorkflowTriggers {
    beginRun(resourceGroupName: string, name: string, workflowName: string, triggerName: string, options?: WorkflowTriggersRunOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginRunAndWait(resourceGroupName: string, name: string, workflowName: string, triggerName: string, options?: WorkflowTriggersRunOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, workflowName: string, triggerName: string, options?: WorkflowTriggersGetOptionalParams): Promise<WorkflowTriggersGetResponse>;
    getSchemaJson(resourceGroupName: string, name: string, workflowName: string, triggerName: string, options?: WorkflowTriggersGetSchemaJsonOptionalParams): Promise<WorkflowTriggersGetSchemaJsonResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, options?: WorkflowTriggersListOptionalParams): PagedAsyncIterableIterator<WorkflowTrigger>;
    listCallbackUrl(resourceGroupName: string, name: string, workflowName: string, triggerName: string, options?: WorkflowTriggersListCallbackUrlOptionalParams): Promise<WorkflowTriggersListCallbackUrlResponse>;
}

// @public
export interface WorkflowTriggersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowTriggersGetResponse = WorkflowTrigger;

// @public
export interface WorkflowTriggersGetSchemaJsonOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowTriggersGetSchemaJsonResponse = JsonSchema;

// @public
export interface WorkflowTriggersListCallbackUrlOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowTriggersListCallbackUrlResponse = WorkflowTriggerCallbackUrl;

// @public
export interface WorkflowTriggersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowTriggersListNextResponse = WorkflowTriggerListResult;

// @public
export interface WorkflowTriggersListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    top?: number;
}

// @public
export type WorkflowTriggersListResponse = WorkflowTriggerListResult;

// @public
export interface WorkflowTriggersRunOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WorkflowVersion extends WorkflowResource {
    accessControl?: FlowAccessControlConfiguration;
    readonly accessEndpoint?: string;
    readonly changedTime?: Date;
    readonly createdTime?: Date;
    definition?: Record<string, unknown>;
    endpointsConfiguration?: FlowEndpointsConfiguration;
    integrationAccount?: ResourceReference;
    parameters?: {
        [propertyName: string]: WorkflowParameter;
    };
    readonly provisioningState?: WorkflowProvisioningState;
    readonly sku?: WorkflowSku;
    state?: WorkflowState;
    readonly version?: string;
}

// @public
export interface WorkflowVersionListResult {
    nextLink?: string;
    value?: WorkflowVersion[];
}

// @public
export interface WorkflowVersions {
    get(resourceGroupName: string, name: string, workflowName: string, versionId: string, options?: WorkflowVersionsGetOptionalParams): Promise<WorkflowVersionsGetResponse>;
    list(resourceGroupName: string, name: string, workflowName: string, options?: WorkflowVersionsListOptionalParams): PagedAsyncIterableIterator<WorkflowVersion>;
}

// @public
export interface WorkflowVersionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowVersionsGetResponse = WorkflowVersion;

// @public
export interface WorkflowVersionsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WorkflowVersionsListNextResponse = WorkflowVersionListResult;

// @public
export interface WorkflowVersionsListOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type WorkflowVersionsListResponse = WorkflowVersionListResult;

// (No @packageDocumentation comment for this package)

```