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

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

```ts

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 AadAuthenticationParameters {
    aadAudience?: string;
    aadIssuer?: string;
    aadTenant?: string;
}

// @public
export type Access = string;

// @public
export type AccessRuleDirection = string;

// @public
export interface Action {
    parameters?: Parameter[];
    type?: RouteMapActionType;
}

// @public
export type ActionType = string;

// @public
export interface ActiveBaseSecurityAdminRule {
    commitTime?: Date;
    configurationDescription?: string;
    id?: string;
    kind: "Custom" | "Default";
    region?: string;
    ruleCollectionAppliesToGroups?: NetworkManagerSecurityGroupItem[];
    ruleCollectionDescription?: string;
    ruleGroups?: ConfigurationGroup[];
}

// @public (undocumented)
export type ActiveBaseSecurityAdminRuleUnion = ActiveBaseSecurityAdminRule | ActiveSecurityAdminRule | ActiveDefaultSecurityAdminRule;

// @public
export interface ActiveConfigurationParameter {
    regions?: string[];
    skipToken?: string;
}

// @public
export interface ActiveConnectivityConfiguration extends EffectiveConnectivityConfiguration {
    commitTime?: Date;
    region?: string;
}

// @public
export interface ActiveConnectivityConfigurationsListResult {
    skipToken?: string;
    value?: ActiveConnectivityConfiguration[];
}

// @public
export interface ActiveDefaultSecurityAdminRule extends ActiveBaseSecurityAdminRule {
    readonly access?: SecurityConfigurationRuleAccess;
    readonly description?: string;
    readonly destinationPortRanges?: string[];
    readonly destinations?: AddressPrefixItem[];
    readonly direction?: SecurityConfigurationRuleDirection;
    flag?: string;
    kind: "Default";
    readonly priority?: number;
    readonly protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly sourcePortRanges?: string[];
    readonly sources?: AddressPrefixItem[];
}

// @public
export interface ActiveSecurityAdminRule extends ActiveBaseSecurityAdminRule {
    access?: SecurityConfigurationRuleAccess;
    description?: string;
    destinationPortRanges?: string[];
    destinations?: AddressPrefixItem[];
    direction?: SecurityConfigurationRuleDirection;
    kind: "Custom";
    priority?: number;
    protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    sourcePortRanges?: string[];
    sources?: AddressPrefixItem[];
}

// @public
export interface ActiveSecurityAdminRulesListResult {
    skipToken?: string;
    value?: ActiveBaseSecurityAdminRuleUnion[];
}

// @public
export interface AddressPrefixItem {
    addressPrefix?: string;
    addressPrefixType?: AddressPrefixType;
}

// @public
export type AddressPrefixType = string;

// @public
export interface AddressSpace {
    addressPrefixes?: string[];
    ipamPoolPrefixAllocations?: IpamPoolPrefixAllocation[];
}

// @public
export type AddressSpaceAggregationOption = string;

// @public
export interface AdminRule extends BaseAdminRule {
    access?: SecurityConfigurationRuleAccess;
    description?: string;
    destinationPortRanges?: string[];
    destinations?: AddressPrefixItem[];
    direction?: SecurityConfigurationRuleDirection;
    kind: "Custom";
    priority?: number;
    protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    sourcePortRanges?: string[];
    sources?: AddressPrefixItem[];
}

// @public
export interface AdminRuleCollection extends ChildResource {
    appliesToGroups?: NetworkManagerSecurityGroupItem[];
    description?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface AdminRuleCollectionListResult {
    nextLink?: string;
    value?: AdminRuleCollection[];
}

// @public
export interface AdminRuleCollections {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: AdminRuleCollectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: AdminRuleCollectionsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleCollection: AdminRuleCollection, options?: AdminRuleCollectionsCreateOrUpdateOptionalParams): Promise<AdminRuleCollectionsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: AdminRuleCollectionsGetOptionalParams): Promise<AdminRuleCollectionsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: AdminRuleCollectionsListOptionalParams): PagedAsyncIterableIterator<AdminRuleCollection>;
}

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

// @public
export type AdminRuleCollectionsCreateOrUpdateResponse = AdminRuleCollection;

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

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

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

// @public
export type AdminRuleCollectionsGetResponse = AdminRuleCollection;

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

// @public
export type AdminRuleCollectionsListNextResponse = AdminRuleCollectionListResult;

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

// @public
export type AdminRuleCollectionsListResponse = AdminRuleCollectionListResult;

// @public
export type AdminRuleKind = string;

// @public
export interface AdminRuleListResult {
    nextLink?: string;
    value?: BaseAdminRuleUnion[];
}

// @public
export interface AdminRules {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: AdminRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: AdminRulesDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, adminRule: BaseAdminRuleUnion, options?: AdminRulesCreateOrUpdateOptionalParams): Promise<AdminRulesCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: AdminRulesGetOptionalParams): Promise<AdminRulesGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: AdminRulesListOptionalParams): PagedAsyncIterableIterator<BaseAdminRuleUnion>;
}

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

// @public
export type AdminRulesCreateOrUpdateResponse = BaseAdminRuleUnion;

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

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

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

// @public
export type AdminRulesGetResponse = BaseAdminRuleUnion;

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

// @public
export type AdminRulesListNextResponse = AdminRuleListResult;

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

// @public
export type AdminRulesListResponse = AdminRuleListResult;

// @public
export type AdminState = string;

// @public
export interface AdvertisedPublicPrefixProperties {
    prefix?: string;
    signature?: string;
    validationId?: string;
    readonly validationState?: AdvertisedPublicPrefixPropertiesValidationState;
}

// @public
export type AdvertisedPublicPrefixPropertiesValidationState = string;

// @public
export interface ApplicationGateway extends Resource {
    authenticationCertificates?: ApplicationGatewayAuthenticationCertificate[];
    autoscaleConfiguration?: ApplicationGatewayAutoscaleConfiguration;
    backendAddressPools?: ApplicationGatewayBackendAddressPool[];
    backendHttpSettingsCollection?: ApplicationGatewayBackendHttpSettings[];
    backendSettingsCollection?: ApplicationGatewayBackendSettings[];
    customErrorConfigurations?: ApplicationGatewayCustomError[];
    readonly defaultPredefinedSslPolicy?: ApplicationGatewaySslPolicyName;
    enableFips?: boolean;
    enableHttp2?: boolean;
    readonly etag?: string;
    firewallPolicy?: SubResource;
    forceFirewallPolicyAssociation?: boolean;
    frontendIPConfigurations?: ApplicationGatewayFrontendIPConfiguration[];
    frontendPorts?: ApplicationGatewayFrontendPort[];
    gatewayIPConfigurations?: ApplicationGatewayIPConfiguration[];
    globalConfiguration?: ApplicationGatewayGlobalConfiguration;
    httpListeners?: ApplicationGatewayHttpListener[];
    identity?: ManagedServiceIdentity;
    listeners?: ApplicationGatewayListener[];
    loadDistributionPolicies?: ApplicationGatewayLoadDistributionPolicy[];
    readonly operationalState?: ApplicationGatewayOperationalState;
    readonly privateEndpointConnections?: ApplicationGatewayPrivateEndpointConnection[];
    privateLinkConfigurations?: ApplicationGatewayPrivateLinkConfiguration[];
    probes?: ApplicationGatewayProbe[];
    readonly provisioningState?: ProvisioningState;
    redirectConfigurations?: ApplicationGatewayRedirectConfiguration[];
    requestRoutingRules?: ApplicationGatewayRequestRoutingRule[];
    readonly resourceGuid?: string;
    rewriteRuleSets?: ApplicationGatewayRewriteRuleSet[];
    routingRules?: ApplicationGatewayRoutingRule[];
    sku?: ApplicationGatewaySku;
    sslCertificates?: ApplicationGatewaySslCertificate[];
    sslPolicy?: ApplicationGatewaySslPolicy;
    sslProfiles?: ApplicationGatewaySslProfile[];
    trustedClientCertificates?: ApplicationGatewayTrustedClientCertificate[];
    trustedRootCertificates?: ApplicationGatewayTrustedRootCertificate[];
    urlPathMaps?: ApplicationGatewayUrlPathMap[];
    webApplicationFirewallConfiguration?: ApplicationGatewayWebApplicationFirewallConfiguration;
    zones?: string[];
}

// @public
export interface ApplicationGatewayAuthenticationCertificate extends SubResource {
    data?: string;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayAutoscaleConfiguration {
    maxCapacity?: number;
    minCapacity: number;
}

// @public
export interface ApplicationGatewayAvailableSslOptions extends Resource {
    availableCipherSuites?: ApplicationGatewaySslCipherSuite[];
    availableProtocols?: ApplicationGatewaySslProtocol[];
    defaultPolicy?: ApplicationGatewaySslPolicyName;
    predefinedPolicies?: SubResource[];
}

// @public
export interface ApplicationGatewayAvailableSslPredefinedPolicies {
    nextLink?: string;
    value?: ApplicationGatewaySslPredefinedPolicy[];
}

// @public
export interface ApplicationGatewayAvailableWafRuleSetsResult {
    value?: ApplicationGatewayFirewallRuleSet[];
}

// @public
export interface ApplicationGatewayBackendAddress {
    fqdn?: string;
    ipAddress?: string;
}

// @public
export interface ApplicationGatewayBackendAddressPool extends SubResource {
    backendAddresses?: ApplicationGatewayBackendAddress[];
    readonly backendIPConfigurations?: NetworkInterfaceIPConfiguration[];
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayBackendHealth {
    backendAddressPools?: ApplicationGatewayBackendHealthPool[];
}

// @public
export interface ApplicationGatewayBackendHealthHttpSettings {
    backendHttpSettings?: ApplicationGatewayBackendHttpSettings;
    servers?: ApplicationGatewayBackendHealthServer[];
}

// @public
export interface ApplicationGatewayBackendHealthOnDemand {
    backendAddressPool?: ApplicationGatewayBackendAddressPool;
    backendHealthHttpSettings?: ApplicationGatewayBackendHealthHttpSettings;
}

// @public
export interface ApplicationGatewayBackendHealthPool {
    backendAddressPool?: ApplicationGatewayBackendAddressPool;
    backendHttpSettingsCollection?: ApplicationGatewayBackendHealthHttpSettings[];
}

// @public
export interface ApplicationGatewayBackendHealthServer {
    address?: string;
    health?: ApplicationGatewayBackendHealthServerHealth;
    healthProbeLog?: string;
    ipConfiguration?: NetworkInterfaceIPConfiguration;
}

// @public
export type ApplicationGatewayBackendHealthServerHealth = string;

// @public
export interface ApplicationGatewayBackendHttpSettings extends SubResource {
    affinityCookieName?: string;
    authenticationCertificates?: SubResource[];
    connectionDraining?: ApplicationGatewayConnectionDraining;
    cookieBasedAffinity?: ApplicationGatewayCookieBasedAffinity;
    readonly etag?: string;
    hostName?: string;
    name?: string;
    path?: string;
    pickHostNameFromBackendAddress?: boolean;
    port?: number;
    probe?: SubResource;
    probeEnabled?: boolean;
    protocol?: ApplicationGatewayProtocol;
    readonly provisioningState?: ProvisioningState;
    requestTimeout?: number;
    trustedRootCertificates?: SubResource[];
    readonly type?: string;
}

// @public
export interface ApplicationGatewayBackendSettings extends SubResource {
    readonly etag?: string;
    hostName?: string;
    name?: string;
    pickHostNameFromBackendAddress?: boolean;
    port?: number;
    probe?: SubResource;
    protocol?: ApplicationGatewayProtocol;
    readonly provisioningState?: ProvisioningState;
    timeout?: number;
    trustedRootCertificates?: SubResource[];
    readonly type?: string;
}

// @public
export interface ApplicationGatewayClientAuthConfiguration {
    verifyClientCertIssuerDN?: boolean;
    verifyClientRevocation?: ApplicationGatewayClientRevocationOptions;
}

// @public
export type ApplicationGatewayClientRevocationOptions = string;

// @public
export interface ApplicationGatewayConnectionDraining {
    drainTimeoutInSec: number;
    enabled: boolean;
}

// @public
export type ApplicationGatewayCookieBasedAffinity = string;

// @public
export interface ApplicationGatewayCustomError {
    customErrorPageUrl?: string;
    statusCode?: ApplicationGatewayCustomErrorStatusCode;
}

// @public
export type ApplicationGatewayCustomErrorStatusCode = string;

// @public
export interface ApplicationGatewayFirewallDisabledRuleGroup {
    ruleGroupName: string;
    rules?: number[];
}

// @public
export interface ApplicationGatewayFirewallExclusion {
    matchVariable: string;
    selector: string;
    selectorMatchOperator: string;
}

// @public
export interface ApplicationGatewayFirewallManifestRuleSet {
    ruleGroups: ApplicationGatewayFirewallRuleGroup[];
    ruleSetType: string;
    ruleSetVersion: string;
    status?: ApplicationGatewayRuleSetStatusOptions;
    tiers?: ApplicationGatewayTierTypes[];
}

// @public
export type ApplicationGatewayFirewallMode = string;

// @public
export type ApplicationGatewayFirewallRateLimitDuration = string;

// @public
export interface ApplicationGatewayFirewallRule {
    action?: ApplicationGatewayWafRuleActionTypes;
    description?: string;
    ruleId: number;
    ruleIdString?: string;
    sensitivity?: ApplicationGatewayWafRuleSensitivityTypes;
    state?: ApplicationGatewayWafRuleStateTypes;
}

// @public
export interface ApplicationGatewayFirewallRuleGroup {
    description?: string;
    ruleGroupName: string;
    rules: ApplicationGatewayFirewallRule[];
}

// @public
export interface ApplicationGatewayFirewallRuleSet extends Resource {
    readonly provisioningState?: ProvisioningState;
    ruleGroups?: ApplicationGatewayFirewallRuleGroup[];
    ruleSetType?: string;
    ruleSetVersion?: string;
    tiers?: ApplicationGatewayTierTypes[];
}

// @public
export type ApplicationGatewayFirewallUserSessionVariable = string;

// @public
export interface ApplicationGatewayForContainersReferenceDefinition {
    id: string;
}

// @public
export interface ApplicationGatewayFrontendIPConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    privateIPAddress?: string;
    privateIPAllocationMethod?: IPAllocationMethod;
    privateLinkConfiguration?: SubResource;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: SubResource;
    subnet?: SubResource;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayFrontendPort extends SubResource {
    readonly etag?: string;
    name?: string;
    port?: number;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayGlobalConfiguration {
    enableRequestBuffering?: boolean;
    enableResponseBuffering?: boolean;
}

// @public
export interface ApplicationGatewayHeaderConfiguration {
    headerName?: string;
    headerValue?: string;
    headerValueMatcher?: HeaderValueMatcher;
}

// @public
export interface ApplicationGatewayHttpListener extends SubResource {
    customErrorConfigurations?: ApplicationGatewayCustomError[];
    readonly etag?: string;
    firewallPolicy?: SubResource;
    frontendIPConfiguration?: SubResource;
    frontendPort?: SubResource;
    hostName?: string;
    hostNames?: string[];
    name?: string;
    protocol?: ApplicationGatewayProtocol;
    readonly provisioningState?: ProvisioningState;
    requireServerNameIndication?: boolean;
    sslCertificate?: SubResource;
    sslProfile?: SubResource;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayIPConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    subnet?: SubResource;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayListener extends SubResource {
    readonly etag?: string;
    frontendIPConfiguration?: SubResource;
    frontendPort?: SubResource;
    hostNames?: string[];
    name?: string;
    protocol?: ApplicationGatewayProtocol;
    readonly provisioningState?: ProvisioningState;
    sslCertificate?: SubResource;
    sslProfile?: SubResource;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayListResult {
    nextLink?: string;
    value?: ApplicationGateway[];
}

// @public
export type ApplicationGatewayLoadDistributionAlgorithm = string;

// @public
export interface ApplicationGatewayLoadDistributionPolicy extends SubResource {
    readonly etag?: string;
    loadDistributionAlgorithm?: ApplicationGatewayLoadDistributionAlgorithm;
    loadDistributionTargets?: ApplicationGatewayLoadDistributionTarget[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayLoadDistributionTarget extends SubResource {
    backendAddressPool?: SubResource;
    readonly etag?: string;
    name?: string;
    readonly type?: string;
    weightPerServer?: number;
}

// @public
export interface ApplicationGatewayOnDemandProbe {
    backendAddressPool?: SubResource;
    backendHttpSettings?: SubResource;
    host?: string;
    match?: ApplicationGatewayProbeHealthResponseMatch;
    path?: string;
    pickHostNameFromBackendHttpSettings?: boolean;
    protocol?: ApplicationGatewayProtocol;
    timeout?: number;
}

// @public
export type ApplicationGatewayOperationalState = string;

// @public
export interface ApplicationGatewayPathRule extends SubResource {
    backendAddressPool?: SubResource;
    backendHttpSettings?: SubResource;
    readonly etag?: string;
    firewallPolicy?: SubResource;
    loadDistributionPolicy?: SubResource;
    name?: string;
    paths?: string[];
    readonly provisioningState?: ProvisioningState;
    redirectConfiguration?: SubResource;
    rewriteRuleSet?: SubResource;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayPrivateEndpointConnection extends SubResource {
    readonly etag?: string;
    readonly linkIdentifier?: string;
    name?: string;
    readonly privateEndpoint?: PrivateEndpoint;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayPrivateEndpointConnectionListResult {
    nextLink?: string;
    value?: ApplicationGatewayPrivateEndpointConnection[];
}

// @public
export interface ApplicationGatewayPrivateEndpointConnections {
    beginDelete(resourceGroupName: string, applicationGatewayName: string, connectionName: string, options?: ApplicationGatewayPrivateEndpointConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, applicationGatewayName: string, connectionName: string, options?: ApplicationGatewayPrivateEndpointConnectionsDeleteOptionalParams): Promise<void>;
    beginUpdate(resourceGroupName: string, applicationGatewayName: string, connectionName: string, parameters: ApplicationGatewayPrivateEndpointConnection, options?: ApplicationGatewayPrivateEndpointConnectionsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApplicationGatewayPrivateEndpointConnectionsUpdateResponse>, ApplicationGatewayPrivateEndpointConnectionsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, applicationGatewayName: string, connectionName: string, parameters: ApplicationGatewayPrivateEndpointConnection, options?: ApplicationGatewayPrivateEndpointConnectionsUpdateOptionalParams): Promise<ApplicationGatewayPrivateEndpointConnectionsUpdateResponse>;
    get(resourceGroupName: string, applicationGatewayName: string, connectionName: string, options?: ApplicationGatewayPrivateEndpointConnectionsGetOptionalParams): Promise<ApplicationGatewayPrivateEndpointConnectionsGetResponse>;
    list(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewayPrivateEndpointConnectionsListOptionalParams): PagedAsyncIterableIterator<ApplicationGatewayPrivateEndpointConnection>;
}

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

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

// @public
export type ApplicationGatewayPrivateEndpointConnectionsGetResponse = ApplicationGatewayPrivateEndpointConnection;

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

// @public
export type ApplicationGatewayPrivateEndpointConnectionsListNextResponse = ApplicationGatewayPrivateEndpointConnectionListResult;

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

// @public
export type ApplicationGatewayPrivateEndpointConnectionsListResponse = ApplicationGatewayPrivateEndpointConnectionListResult;

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

// @public
export type ApplicationGatewayPrivateEndpointConnectionsUpdateResponse = ApplicationGatewayPrivateEndpointConnection;

// @public
export interface ApplicationGatewayPrivateLinkConfiguration extends SubResource {
    readonly etag?: string;
    ipConfigurations?: ApplicationGatewayPrivateLinkIpConfiguration[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayPrivateLinkIpConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    primary?: boolean;
    privateIPAddress?: string;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    subnet?: SubResource;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayPrivateLinkResource extends SubResource {
    readonly etag?: string;
    readonly groupId?: string;
    name?: string;
    readonly requiredMembers?: string[];
    requiredZoneNames?: string[];
    readonly type?: string;
}

// @public
export interface ApplicationGatewayPrivateLinkResourceListResult {
    nextLink?: string;
    value?: ApplicationGatewayPrivateLinkResource[];
}

// @public
export interface ApplicationGatewayPrivateLinkResources {
    list(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewayPrivateLinkResourcesListOptionalParams): PagedAsyncIterableIterator<ApplicationGatewayPrivateLinkResource>;
}

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

// @public
export type ApplicationGatewayPrivateLinkResourcesListNextResponse = ApplicationGatewayPrivateLinkResourceListResult;

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

// @public
export type ApplicationGatewayPrivateLinkResourcesListResponse = ApplicationGatewayPrivateLinkResourceListResult;

// @public
export interface ApplicationGatewayProbe extends SubResource {
    readonly etag?: string;
    host?: string;
    interval?: number;
    match?: ApplicationGatewayProbeHealthResponseMatch;
    minServers?: number;
    name?: string;
    path?: string;
    pickHostNameFromBackendHttpSettings?: boolean;
    pickHostNameFromBackendSettings?: boolean;
    port?: number;
    protocol?: ApplicationGatewayProtocol;
    readonly provisioningState?: ProvisioningState;
    timeout?: number;
    readonly type?: string;
    unhealthyThreshold?: number;
}

// @public
export interface ApplicationGatewayProbeHealthResponseMatch {
    body?: string;
    statusCodes?: string[];
}

// @public
export type ApplicationGatewayProtocol = string;

// @public
export interface ApplicationGatewayRedirectConfiguration extends SubResource {
    readonly etag?: string;
    includePath?: boolean;
    includeQueryString?: boolean;
    name?: string;
    pathRules?: SubResource[];
    redirectType?: ApplicationGatewayRedirectType;
    requestRoutingRules?: SubResource[];
    targetListener?: SubResource;
    targetUrl?: string;
    readonly type?: string;
    urlPathMaps?: SubResource[];
}

// @public
export type ApplicationGatewayRedirectType = string;

// @public
export interface ApplicationGatewayRequestRoutingRule extends SubResource {
    backendAddressPool?: SubResource;
    backendHttpSettings?: SubResource;
    readonly etag?: string;
    httpListener?: SubResource;
    loadDistributionPolicy?: SubResource;
    name?: string;
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    redirectConfiguration?: SubResource;
    rewriteRuleSet?: SubResource;
    ruleType?: ApplicationGatewayRequestRoutingRuleType;
    readonly type?: string;
    urlPathMap?: SubResource;
}

// @public
export type ApplicationGatewayRequestRoutingRuleType = string;

// @public
export interface ApplicationGatewayRewriteRule {
    actionSet?: ApplicationGatewayRewriteRuleActionSet;
    conditions?: ApplicationGatewayRewriteRuleCondition[];
    name?: string;
    ruleSequence?: number;
}

// @public
export interface ApplicationGatewayRewriteRuleActionSet {
    requestHeaderConfigurations?: ApplicationGatewayHeaderConfiguration[];
    responseHeaderConfigurations?: ApplicationGatewayHeaderConfiguration[];
    urlConfiguration?: ApplicationGatewayUrlConfiguration;
}

// @public
export interface ApplicationGatewayRewriteRuleCondition {
    ignoreCase?: boolean;
    negate?: boolean;
    pattern?: string;
    variable?: string;
}

// @public
export interface ApplicationGatewayRewriteRuleSet extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    rewriteRules?: ApplicationGatewayRewriteRule[];
}

// @public
export interface ApplicationGatewayRoutingRule extends SubResource {
    backendAddressPool?: SubResource;
    backendSettings?: SubResource;
    readonly etag?: string;
    listener?: SubResource;
    name?: string;
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    ruleType?: ApplicationGatewayRequestRoutingRuleType;
    readonly type?: string;
}

// @public
export type ApplicationGatewayRuleSetStatusOptions = string;

// @public
export interface ApplicationGateways {
    beginBackendHealth(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysBackendHealthOptionalParams): Promise<SimplePollerLike<OperationState<ApplicationGatewaysBackendHealthResponse>, ApplicationGatewaysBackendHealthResponse>>;
    beginBackendHealthAndWait(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysBackendHealthOptionalParams): Promise<ApplicationGatewaysBackendHealthResponse>;
    beginBackendHealthOnDemand(resourceGroupName: string, applicationGatewayName: string, probeRequest: ApplicationGatewayOnDemandProbe, options?: ApplicationGatewaysBackendHealthOnDemandOptionalParams): Promise<SimplePollerLike<OperationState<ApplicationGatewaysBackendHealthOnDemandResponse>, ApplicationGatewaysBackendHealthOnDemandResponse>>;
    beginBackendHealthOnDemandAndWait(resourceGroupName: string, applicationGatewayName: string, probeRequest: ApplicationGatewayOnDemandProbe, options?: ApplicationGatewaysBackendHealthOnDemandOptionalParams): Promise<ApplicationGatewaysBackendHealthOnDemandResponse>;
    beginCreateOrUpdate(resourceGroupName: string, applicationGatewayName: string, parameters: ApplicationGateway, options?: ApplicationGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApplicationGatewaysCreateOrUpdateResponse>, ApplicationGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, applicationGatewayName: string, parameters: ApplicationGateway, options?: ApplicationGatewaysCreateOrUpdateOptionalParams): Promise<ApplicationGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysDeleteOptionalParams): Promise<void>;
    beginStart(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysStartOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginStartAndWait(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysStartOptionalParams): Promise<void>;
    beginStop(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysStopOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginStopAndWait(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysStopOptionalParams): Promise<void>;
    get(resourceGroupName: string, applicationGatewayName: string, options?: ApplicationGatewaysGetOptionalParams): Promise<ApplicationGatewaysGetResponse>;
    getSslPredefinedPolicy(predefinedPolicyName: string, options?: ApplicationGatewaysGetSslPredefinedPolicyOptionalParams): Promise<ApplicationGatewaysGetSslPredefinedPolicyResponse>;
    list(resourceGroupName: string, options?: ApplicationGatewaysListOptionalParams): PagedAsyncIterableIterator<ApplicationGateway>;
    listAll(options?: ApplicationGatewaysListAllOptionalParams): PagedAsyncIterableIterator<ApplicationGateway>;
    listAvailableRequestHeaders(options?: ApplicationGatewaysListAvailableRequestHeadersOptionalParams): Promise<ApplicationGatewaysListAvailableRequestHeadersResponse>;
    listAvailableResponseHeaders(options?: ApplicationGatewaysListAvailableResponseHeadersOptionalParams): Promise<ApplicationGatewaysListAvailableResponseHeadersResponse>;
    listAvailableServerVariables(options?: ApplicationGatewaysListAvailableServerVariablesOptionalParams): Promise<ApplicationGatewaysListAvailableServerVariablesResponse>;
    listAvailableSslOptions(options?: ApplicationGatewaysListAvailableSslOptionsOptionalParams): Promise<ApplicationGatewaysListAvailableSslOptionsResponse>;
    listAvailableSslPredefinedPolicies(options?: ApplicationGatewaysListAvailableSslPredefinedPoliciesOptionalParams): PagedAsyncIterableIterator<ApplicationGatewaySslPredefinedPolicy>;
    listAvailableWafRuleSets(options?: ApplicationGatewaysListAvailableWafRuleSetsOptionalParams): Promise<ApplicationGatewaysListAvailableWafRuleSetsResponse>;
    updateTags(resourceGroupName: string, applicationGatewayName: string, parameters: TagsObject, options?: ApplicationGatewaysUpdateTagsOptionalParams): Promise<ApplicationGatewaysUpdateTagsResponse>;
}

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

// @public
export type ApplicationGatewaysBackendHealthOnDemandResponse = ApplicationGatewayBackendHealthOnDemand;

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

// @public
export type ApplicationGatewaysBackendHealthResponse = ApplicationGatewayBackendHealth;

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

// @public
export type ApplicationGatewaysCreateOrUpdateResponse = ApplicationGateway;

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

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

// @public
export type ApplicationGatewaysGetResponse = ApplicationGateway;

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

// @public
export type ApplicationGatewaysGetSslPredefinedPolicyResponse = ApplicationGatewaySslPredefinedPolicy;

// @public
export interface ApplicationGatewaySku {
    capacity?: number;
    family?: ApplicationGatewaySkuFamily;
    name?: ApplicationGatewaySkuName;
    tier?: ApplicationGatewayTier;
}

// @public
export type ApplicationGatewaySkuFamily = string;

// @public
export type ApplicationGatewaySkuName = string;

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

// @public
export type ApplicationGatewaysListAllNextResponse = ApplicationGatewayListResult;

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

// @public
export type ApplicationGatewaysListAllResponse = ApplicationGatewayListResult;

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

// @public
export type ApplicationGatewaysListAvailableRequestHeadersResponse = {
    body: string[];
};

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

// @public
export type ApplicationGatewaysListAvailableResponseHeadersResponse = {
    body: string[];
};

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

// @public
export type ApplicationGatewaysListAvailableServerVariablesResponse = {
    body: string[];
};

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

// @public
export type ApplicationGatewaysListAvailableSslOptionsResponse = ApplicationGatewayAvailableSslOptions;

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

// @public
export type ApplicationGatewaysListAvailableSslPredefinedPoliciesNextResponse = ApplicationGatewayAvailableSslPredefinedPolicies;

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

// @public
export type ApplicationGatewaysListAvailableSslPredefinedPoliciesResponse = ApplicationGatewayAvailableSslPredefinedPolicies;

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

// @public
export type ApplicationGatewaysListAvailableWafRuleSetsResponse = ApplicationGatewayAvailableWafRuleSetsResult;

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

// @public
export type ApplicationGatewaysListNextResponse = ApplicationGatewayListResult;

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

// @public
export type ApplicationGatewaysListResponse = ApplicationGatewayListResult;

// @public
export interface ApplicationGatewaySslCertificate extends SubResource {
    data?: string;
    readonly etag?: string;
    keyVaultSecretId?: string;
    name?: string;
    password?: string;
    readonly provisioningState?: ProvisioningState;
    readonly publicCertData?: string;
    readonly type?: string;
}

// @public
export type ApplicationGatewaySslCipherSuite = string;

// @public
export interface ApplicationGatewaySslPolicy {
    cipherSuites?: ApplicationGatewaySslCipherSuite[];
    disabledSslProtocols?: ApplicationGatewaySslProtocol[];
    minProtocolVersion?: ApplicationGatewaySslProtocol;
    policyName?: ApplicationGatewaySslPolicyName;
    policyType?: ApplicationGatewaySslPolicyType;
}

// @public
export type ApplicationGatewaySslPolicyName = string;

// @public
export type ApplicationGatewaySslPolicyType = string;

// @public
export interface ApplicationGatewaySslPredefinedPolicy extends SubResource {
    cipherSuites?: ApplicationGatewaySslCipherSuite[];
    minProtocolVersion?: ApplicationGatewaySslProtocol;
    name?: string;
}

// @public
export interface ApplicationGatewaySslProfile extends SubResource {
    clientAuthConfiguration?: ApplicationGatewayClientAuthConfiguration;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    sslPolicy?: ApplicationGatewaySslPolicy;
    trustedClientCertificates?: SubResource[];
    readonly type?: string;
}

// @public
export type ApplicationGatewaySslProtocol = string;

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

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

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

// @public
export type ApplicationGatewaysUpdateTagsResponse = ApplicationGateway;

// @public
export type ApplicationGatewayTier = string;

// @public
export type ApplicationGatewayTierTypes = string;

// @public
export interface ApplicationGatewayTrustedClientCertificate extends SubResource {
    readonly clientCertIssuerDN?: string;
    data?: string;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
    readonly validatedCertData?: string;
}

// @public
export interface ApplicationGatewayTrustedRootCertificate extends SubResource {
    data?: string;
    readonly etag?: string;
    keyVaultSecretId?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayUrlConfiguration {
    modifiedPath?: string;
    modifiedQueryString?: string;
    reroute?: boolean;
}

// @public
export interface ApplicationGatewayUrlPathMap extends SubResource {
    defaultBackendAddressPool?: SubResource;
    defaultBackendHttpSettings?: SubResource;
    defaultLoadDistributionPolicy?: SubResource;
    defaultRedirectConfiguration?: SubResource;
    defaultRewriteRuleSet?: SubResource;
    readonly etag?: string;
    name?: string;
    pathRules?: ApplicationGatewayPathRule[];
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayWafDynamicManifestResult {
    availableRuleSets?: ApplicationGatewayFirewallManifestRuleSet[];
    id?: string;
    readonly name?: string;
    ruleSetType?: string;
    ruleSetVersion?: string;
    readonly type?: string;
}

// @public
export interface ApplicationGatewayWafDynamicManifestResultList {
    nextLink?: string;
    value?: ApplicationGatewayWafDynamicManifestResult[];
}

// @public
export interface ApplicationGatewayWafDynamicManifests {
    list(location: string, options?: ApplicationGatewayWafDynamicManifestsGetOptionalParams): PagedAsyncIterableIterator<ApplicationGatewayWafDynamicManifestResult>;
}

// @public
export interface ApplicationGatewayWafDynamicManifestsDefault {
    get(location: string, options?: ApplicationGatewayWafDynamicManifestsDefaultGetOptionalParams): Promise<ApplicationGatewayWafDynamicManifestsDefaultGetResponse>;
}

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

// @public
export type ApplicationGatewayWafDynamicManifestsDefaultGetResponse = ApplicationGatewayWafDynamicManifestResult;

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

// @public
export type ApplicationGatewayWafDynamicManifestsGetNextResponse = ApplicationGatewayWafDynamicManifestResultList;

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

// @public
export type ApplicationGatewayWafDynamicManifestsGetResponse = ApplicationGatewayWafDynamicManifestResultList;

// @public
export type ApplicationGatewayWafRuleActionTypes = string;

// @public
export type ApplicationGatewayWafRuleSensitivityTypes = string;

// @public
export type ApplicationGatewayWafRuleStateTypes = string;

// @public
export interface ApplicationGatewayWebApplicationFirewallConfiguration {
    disabledRuleGroups?: ApplicationGatewayFirewallDisabledRuleGroup[];
    enabled: boolean;
    exclusions?: ApplicationGatewayFirewallExclusion[];
    fileUploadLimitInMb?: number;
    firewallMode: ApplicationGatewayFirewallMode;
    maxRequestBodySize?: number;
    maxRequestBodySizeInKb?: number;
    requestBodyCheck?: boolean;
    ruleSetType: string;
    ruleSetVersion: string;
}

// @public
export interface ApplicationRule extends FirewallPolicyRule {
    destinationAddresses?: string[];
    fqdnTags?: string[];
    httpHeadersToInsert?: FirewallPolicyHttpHeaderToInsert[];
    protocols?: FirewallPolicyRuleApplicationProtocol[];
    ruleType: "ApplicationRule";
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
    targetFqdns?: string[];
    targetUrls?: string[];
    terminateTLS?: boolean;
    webCategories?: string[];
}

// @public
export interface ApplicationSecurityGroup extends Resource {
    readonly etag?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

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

// @public
export interface ApplicationSecurityGroups {
    beginCreateOrUpdate(resourceGroupName: string, applicationSecurityGroupName: string, parameters: ApplicationSecurityGroup, options?: ApplicationSecurityGroupsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApplicationSecurityGroupsCreateOrUpdateResponse>, ApplicationSecurityGroupsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, applicationSecurityGroupName: string, parameters: ApplicationSecurityGroup, options?: ApplicationSecurityGroupsCreateOrUpdateOptionalParams): Promise<ApplicationSecurityGroupsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, applicationSecurityGroupName: string, options?: ApplicationSecurityGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, applicationSecurityGroupName: string, options?: ApplicationSecurityGroupsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, applicationSecurityGroupName: string, options?: ApplicationSecurityGroupsGetOptionalParams): Promise<ApplicationSecurityGroupsGetResponse>;
    list(resourceGroupName: string, options?: ApplicationSecurityGroupsListOptionalParams): PagedAsyncIterableIterator<ApplicationSecurityGroup>;
    listAll(options?: ApplicationSecurityGroupsListAllOptionalParams): PagedAsyncIterableIterator<ApplicationSecurityGroup>;
    updateTags(resourceGroupName: string, applicationSecurityGroupName: string, parameters: TagsObject, options?: ApplicationSecurityGroupsUpdateTagsOptionalParams): Promise<ApplicationSecurityGroupsUpdateTagsResponse>;
}

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

// @public
export type ApplicationSecurityGroupsCreateOrUpdateResponse = ApplicationSecurityGroup;

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

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

// @public
export type ApplicationSecurityGroupsGetResponse = ApplicationSecurityGroup;

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

// @public
export type ApplicationSecurityGroupsListAllNextResponse = ApplicationSecurityGroupListResult;

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

// @public
export type ApplicationSecurityGroupsListAllResponse = ApplicationSecurityGroupListResult;

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

// @public
export type ApplicationSecurityGroupsListNextResponse = ApplicationSecurityGroupListResult;

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

// @public
export type ApplicationSecurityGroupsListResponse = ApplicationSecurityGroupListResult;

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

// @public
export type ApplicationSecurityGroupsUpdateTagsResponse = ApplicationSecurityGroup;

// @public
export type AssociationAccessMode = string;

// @public
export type AssociationType = string;

// @public
export type AuthenticationMethod = string;

// @public
export interface AuthorizationListResult {
    nextLink?: string;
    value?: ExpressRouteCircuitAuthorization[];
}

// @public
export type AuthorizationUseStatus = string;

// @public
export interface AutoApprovedPrivateLinkService {
    privateLinkService?: string;
}

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

// @public
export type AutoLearnPrivateRangesMode = string;

// @public
export interface Availability {
    blobDuration?: string;
    retention?: string;
    timeGrain?: string;
}

// @public
export interface AvailableDelegation {
    actions?: string[];
    id?: string;
    name?: string;
    serviceName?: string;
    type?: string;
}

// @public
export interface AvailableDelegations {
    list(location: string, options?: AvailableDelegationsListOptionalParams): PagedAsyncIterableIterator<AvailableDelegation>;
}

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

// @public
export type AvailableDelegationsListNextResponse = AvailableDelegationsResult;

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

// @public
export type AvailableDelegationsListResponse = AvailableDelegationsResult;

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

// @public
export interface AvailableEndpointServices {
    list(location: string, options?: AvailableEndpointServicesListOptionalParams): PagedAsyncIterableIterator<EndpointServiceResult>;
}

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

// @public
export type AvailableEndpointServicesListNextResponse = EndpointServicesListResult;

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

// @public
export type AvailableEndpointServicesListResponse = EndpointServicesListResult;

// @public
export interface AvailablePrivateEndpointType {
    displayName?: string;
    id?: string;
    name?: string;
    resourceName?: string;
    type?: string;
}

// @public
export interface AvailablePrivateEndpointTypes {
    list(location: string, options?: AvailablePrivateEndpointTypesListOptionalParams): PagedAsyncIterableIterator<AvailablePrivateEndpointType>;
    listByResourceGroup(location: string, resourceGroupName: string, options?: AvailablePrivateEndpointTypesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AvailablePrivateEndpointType>;
}

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

// @public
export type AvailablePrivateEndpointTypesListByResourceGroupNextResponse = AvailablePrivateEndpointTypesResult;

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

// @public
export type AvailablePrivateEndpointTypesListByResourceGroupResponse = AvailablePrivateEndpointTypesResult;

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

// @public
export type AvailablePrivateEndpointTypesListNextResponse = AvailablePrivateEndpointTypesResult;

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

// @public
export type AvailablePrivateEndpointTypesListResponse = AvailablePrivateEndpointTypesResult;

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

// @public
export interface AvailableProvidersList {
    countries: AvailableProvidersListCountry[];
}

// @public
export interface AvailableProvidersListCity {
    cityName?: string;
    providers?: string[];
}

// @public
export interface AvailableProvidersListCountry {
    countryName?: string;
    providers?: string[];
    states?: AvailableProvidersListState[];
}

// @public
export interface AvailableProvidersListParameters {
    azureLocations?: string[];
    city?: string;
    country?: string;
    state?: string;
}

// @public
export interface AvailableProvidersListState {
    cities?: AvailableProvidersListCity[];
    providers?: string[];
    stateName?: string;
}

// @public
export interface AvailableResourceGroupDelegations {
    list(location: string, resourceGroupName: string, options?: AvailableResourceGroupDelegationsListOptionalParams): PagedAsyncIterableIterator<AvailableDelegation>;
}

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

// @public
export type AvailableResourceGroupDelegationsListNextResponse = AvailableDelegationsResult;

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

// @public
export type AvailableResourceGroupDelegationsListResponse = AvailableDelegationsResult;

// @public
export interface AvailableServiceAlias {
    id?: string;
    name?: string;
    resourceName?: string;
    type?: string;
}

// @public
export interface AvailableServiceAliases {
    list(location: string, options?: AvailableServiceAliasesListOptionalParams): PagedAsyncIterableIterator<AvailableServiceAlias>;
    listByResourceGroup(resourceGroupName: string, location: string, options?: AvailableServiceAliasesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AvailableServiceAlias>;
}

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

// @public
export type AvailableServiceAliasesListByResourceGroupNextResponse = AvailableServiceAliasesResult;

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

// @public
export type AvailableServiceAliasesListByResourceGroupResponse = AvailableServiceAliasesResult;

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

// @public
export type AvailableServiceAliasesListNextResponse = AvailableServiceAliasesResult;

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

// @public
export type AvailableServiceAliasesListResponse = AvailableServiceAliasesResult;

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

// @public
export interface AzureAsyncOperationResult {
    error?: ErrorModel;
    status?: NetworkOperationStatus;
}

// @public
export interface AzureFirewall extends Resource {
    additionalProperties?: {
        [propertyName: string]: string;
    };
    applicationRuleCollections?: AzureFirewallApplicationRuleCollection[];
    autoscaleConfiguration?: AzureFirewallAutoscaleConfiguration;
    readonly etag?: string;
    firewallPolicy?: SubResource;
    hubIPAddresses?: HubIPAddresses;
    ipConfigurations?: AzureFirewallIPConfiguration[];
    readonly ipGroups?: AzureFirewallIpGroups[];
    managementIpConfiguration?: AzureFirewallIPConfiguration;
    natRuleCollections?: AzureFirewallNatRuleCollection[];
    networkRuleCollections?: AzureFirewallNetworkRuleCollection[];
    readonly provisioningState?: ProvisioningState;
    sku?: AzureFirewallSku;
    threatIntelMode?: AzureFirewallThreatIntelMode;
    virtualHub?: SubResource;
    zones?: string[];
}

// @public
export interface AzureFirewallApplicationRule {
    description?: string;
    fqdnTags?: string[];
    name?: string;
    protocols?: AzureFirewallApplicationRuleProtocol[];
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
    targetFqdns?: string[];
}

// @public
export interface AzureFirewallApplicationRuleCollection extends SubResource {
    action?: AzureFirewallRCAction;
    readonly etag?: string;
    name?: string;
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    rules?: AzureFirewallApplicationRule[];
}

// @public
export interface AzureFirewallApplicationRuleProtocol {
    port?: number;
    protocolType?: AzureFirewallApplicationRuleProtocolType;
}

// @public
export type AzureFirewallApplicationRuleProtocolType = string;

// @public
export interface AzureFirewallAutoscaleConfiguration {
    maxCapacity?: number;
    minCapacity?: number;
}

// @public
export interface AzureFirewallFqdnTag extends Resource {
    readonly etag?: string;
    readonly fqdnTagName?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface AzureFirewallFqdnTagListResult {
    nextLink?: string;
    value?: AzureFirewallFqdnTag[];
}

// @public
export interface AzureFirewallFqdnTags {
    listAll(options?: AzureFirewallFqdnTagsListAllOptionalParams): PagedAsyncIterableIterator<AzureFirewallFqdnTag>;
}

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

// @public
export type AzureFirewallFqdnTagsListAllNextResponse = AzureFirewallFqdnTagListResult;

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

// @public
export type AzureFirewallFqdnTagsListAllResponse = AzureFirewallFqdnTagListResult;

// @public
export interface AzureFirewallIPConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly privateIPAddress?: string;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: SubResource;
    subnet?: SubResource;
    readonly type?: string;
}

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

// @public
export interface AzureFirewallListResult {
    nextLink?: string;
    value?: AzureFirewall[];
}

// @public
export interface AzureFirewallNatRCAction {
    type?: AzureFirewallNatRCActionType;
}

// @public
export type AzureFirewallNatRCActionType = string;

// @public
export interface AzureFirewallNatRule {
    description?: string;
    destinationAddresses?: string[];
    destinationPorts?: string[];
    name?: string;
    protocols?: AzureFirewallNetworkRuleProtocol[];
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
    translatedAddress?: string;
    translatedFqdn?: string;
    translatedPort?: string;
}

// @public
export interface AzureFirewallNatRuleCollection extends SubResource {
    action?: AzureFirewallNatRCAction;
    readonly etag?: string;
    name?: string;
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    rules?: AzureFirewallNatRule[];
}

// @public
export interface AzureFirewallNetworkRule {
    description?: string;
    destinationAddresses?: string[];
    destinationFqdns?: string[];
    destinationIpGroups?: string[];
    destinationPorts?: string[];
    name?: string;
    protocols?: AzureFirewallNetworkRuleProtocol[];
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
}

// @public
export interface AzureFirewallNetworkRuleCollection extends SubResource {
    action?: AzureFirewallRCAction;
    readonly etag?: string;
    name?: string;
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    rules?: AzureFirewallNetworkRule[];
}

// @public
export type AzureFirewallNetworkRuleProtocol = string;

// @public
export interface AzureFirewallPacketCaptureFlags {
    type?: AzureFirewallPacketCaptureFlagsType;
}

// @public
export type AzureFirewallPacketCaptureFlagsType = string;

// @public
export interface AzureFirewallPacketCaptureRule {
    destinationPorts?: string[];
    destinations?: string[];
    sources?: string[];
}

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

// @public
export interface AzureFirewallRCAction {
    type?: AzureFirewallRCActionType;
}

// @public
export type AzureFirewallRCActionType = string;

// @public
export interface AzureFirewalls {
    beginCreateOrUpdate(resourceGroupName: string, azureFirewallName: string, parameters: AzureFirewall, options?: AzureFirewallsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AzureFirewallsCreateOrUpdateResponse>, AzureFirewallsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, azureFirewallName: string, parameters: AzureFirewall, options?: AzureFirewallsCreateOrUpdateOptionalParams): Promise<AzureFirewallsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, azureFirewallName: string, options?: AzureFirewallsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, azureFirewallName: string, options?: AzureFirewallsDeleteOptionalParams): Promise<void>;
    beginListLearnedPrefixes(resourceGroupName: string, azureFirewallName: string, options?: AzureFirewallsListLearnedPrefixesOptionalParams): Promise<SimplePollerLike<OperationState<AzureFirewallsListLearnedPrefixesResponse>, AzureFirewallsListLearnedPrefixesResponse>>;
    beginListLearnedPrefixesAndWait(resourceGroupName: string, azureFirewallName: string, options?: AzureFirewallsListLearnedPrefixesOptionalParams): Promise<AzureFirewallsListLearnedPrefixesResponse>;
    beginPacketCapture(resourceGroupName: string, azureFirewallName: string, parameters: FirewallPacketCaptureParameters, options?: AzureFirewallsPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<AzureFirewallsPacketCaptureResponse>, AzureFirewallsPacketCaptureResponse>>;
    beginPacketCaptureAndWait(resourceGroupName: string, azureFirewallName: string, parameters: FirewallPacketCaptureParameters, options?: AzureFirewallsPacketCaptureOptionalParams): Promise<AzureFirewallsPacketCaptureResponse>;
    beginUpdateTags(resourceGroupName: string, azureFirewallName: string, parameters: TagsObject, options?: AzureFirewallsUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<AzureFirewallsUpdateTagsResponse>, AzureFirewallsUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, azureFirewallName: string, parameters: TagsObject, options?: AzureFirewallsUpdateTagsOptionalParams): Promise<AzureFirewallsUpdateTagsResponse>;
    get(resourceGroupName: string, azureFirewallName: string, options?: AzureFirewallsGetOptionalParams): Promise<AzureFirewallsGetResponse>;
    list(resourceGroupName: string, options?: AzureFirewallsListOptionalParams): PagedAsyncIterableIterator<AzureFirewall>;
    listAll(options?: AzureFirewallsListAllOptionalParams): PagedAsyncIterableIterator<AzureFirewall>;
}

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

// @public
export type AzureFirewallsCreateOrUpdateResponse = AzureFirewall;

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

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

// @public
export type AzureFirewallsGetResponse = AzureFirewall;

// @public
export interface AzureFirewallSku {
    name?: AzureFirewallSkuName;
    tier?: AzureFirewallSkuTier;
}

// @public
export type AzureFirewallSkuName = string;

// @public
export type AzureFirewallSkuTier = string;

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

// @public
export type AzureFirewallsListAllNextResponse = AzureFirewallListResult;

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

// @public
export type AzureFirewallsListAllResponse = AzureFirewallListResult;

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

// @public
export type AzureFirewallsListLearnedPrefixesResponse = IPPrefixesList;

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

// @public
export type AzureFirewallsListNextResponse = AzureFirewallListResult;

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

// @public
export type AzureFirewallsListResponse = AzureFirewallListResult;

// @public
export interface AzureFirewallsPacketCaptureHeaders {
    // (undocumented)
    location?: string;
}

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

// @public
export type AzureFirewallsPacketCaptureResponse = AzureFirewallsPacketCaptureHeaders;

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

// @public
export type AzureFirewallsUpdateTagsResponse = AzureFirewall;

// @public
export type AzureFirewallThreatIntelMode = string;

// @public
export interface AzureReachabilityReport {
    aggregationLevel: string;
    providerLocation: AzureReachabilityReportLocation;
    reachabilityReport: AzureReachabilityReportItem[];
}

// @public
export interface AzureReachabilityReportItem {
    azureLocation?: string;
    latencies?: AzureReachabilityReportLatencyInfo[];
    provider?: string;
}

// @public
export interface AzureReachabilityReportLatencyInfo {
    score?: number;
    timeStamp?: Date;
}

// @public
export interface AzureReachabilityReportLocation {
    city?: string;
    country: string;
    state?: string;
}

// @public
export interface AzureReachabilityReportParameters {
    azureLocations?: string[];
    endTime: Date;
    providerLocation: AzureReachabilityReportLocation;
    providers?: string[];
    startTime: Date;
}

// @public
export interface AzureWebCategory {
    readonly etag?: string;
    readonly group?: string;
    id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export interface AzureWebCategoryListResult {
    nextLink?: string;
    value?: AzureWebCategory[];
}

// @public
export interface BackendAddressInboundNatRulePortMappings {
    inboundNatRulePortMappings?: InboundNatRulePortMapping[];
}

// @public
export interface BackendAddressPool extends SubResource {
    readonly backendIPConfigurations?: NetworkInterfaceIPConfiguration[];
    drainPeriodInSeconds?: number;
    readonly etag?: string;
    readonly inboundNatRules?: SubResource[];
    loadBalancerBackendAddresses?: LoadBalancerBackendAddress[];
    readonly loadBalancingRules?: SubResource[];
    location?: string;
    name?: string;
    readonly outboundRule?: SubResource;
    readonly outboundRules?: SubResource[];
    readonly provisioningState?: ProvisioningState;
    syncMode?: SyncMode;
    tunnelInterfaces?: GatewayLoadBalancerTunnelInterface[];
    readonly type?: string;
    virtualNetwork?: SubResource;
}

// @public
export interface BaseAdminRule extends ChildResource {
    kind: AdminRuleKind;
    readonly systemData?: SystemData;
}

// @public (undocumented)
export type BaseAdminRuleUnion = BaseAdminRule | AdminRule | DefaultAdminRule;

// @public
export interface BastionActiveSession {
    readonly protocol?: BastionConnectProtocol;
    readonly resourceType?: string;
    readonly sessionDurationInMins?: number;
    readonly sessionId?: string;
    readonly startTime?: Record<string, unknown>;
    readonly targetHostName?: string;
    readonly targetIpAddress?: string;
    readonly targetResourceGroup?: string;
    readonly targetResourceId?: string;
    readonly targetSubscriptionId?: string;
    readonly userName?: string;
}

// @public
export interface BastionActiveSessionListResult {
    nextLink?: string;
    value?: BastionActiveSession[];
}

// @public
export type BastionConnectProtocol = string;

// @public
export interface BastionHost extends Resource {
    disableCopyPaste?: boolean;
    dnsName?: string;
    enableFileCopy?: boolean;
    enableIpConnect?: boolean;
    enableKerberos?: boolean;
    enablePrivateOnlyBastion?: boolean;
    enableSessionRecording?: boolean;
    enableShareableLink?: boolean;
    enableTunneling?: boolean;
    readonly etag?: string;
    ipConfigurations?: BastionHostIPConfiguration[];
    // (undocumented)
    networkAcls?: BastionHostPropertiesFormatNetworkAcls;
    readonly provisioningState?: ProvisioningState;
    scaleUnits?: number;
    sku?: Sku;
    virtualNetwork?: SubResource;
    zones?: string[];
}

// @public
export interface BastionHostIPConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: SubResource;
    subnet?: SubResource;
    readonly type?: string;
}

// @public
export interface BastionHostListResult {
    nextLink?: string;
    value?: BastionHost[];
}

// @public (undocumented)
export interface BastionHostPropertiesFormatNetworkAcls {
    ipRules?: IPRule[];
}

// @public
export interface BastionHosts {
    beginCreateOrUpdate(resourceGroupName: string, bastionHostName: string, parameters: BastionHost, options?: BastionHostsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<BastionHostsCreateOrUpdateResponse>, BastionHostsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, bastionHostName: string, parameters: BastionHost, options?: BastionHostsCreateOrUpdateOptionalParams): Promise<BastionHostsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, bastionHostName: string, options?: BastionHostsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, bastionHostName: string, options?: BastionHostsDeleteOptionalParams): Promise<void>;
    beginUpdateTags(resourceGroupName: string, bastionHostName: string, parameters: TagsObject, options?: BastionHostsUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<BastionHostsUpdateTagsResponse>, BastionHostsUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, bastionHostName: string, parameters: TagsObject, options?: BastionHostsUpdateTagsOptionalParams): Promise<BastionHostsUpdateTagsResponse>;
    get(resourceGroupName: string, bastionHostName: string, options?: BastionHostsGetOptionalParams): Promise<BastionHostsGetResponse>;
    list(options?: BastionHostsListOptionalParams): PagedAsyncIterableIterator<BastionHost>;
    listByResourceGroup(resourceGroupName: string, options?: BastionHostsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<BastionHost>;
}

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

// @public
export type BastionHostsCreateOrUpdateResponse = BastionHost;

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

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

// @public
export type BastionHostsGetResponse = BastionHost;

// @public
export type BastionHostSkuName = string;

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

// @public
export type BastionHostsListByResourceGroupNextResponse = BastionHostListResult;

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

// @public
export type BastionHostsListByResourceGroupResponse = BastionHostListResult;

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

// @public
export type BastionHostsListNextResponse = BastionHostListResult;

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

// @public
export type BastionHostsListResponse = BastionHostListResult;

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

// @public
export type BastionHostsUpdateTagsResponse = BastionHost;

// @public
export interface BastionSessionDeleteResult {
    nextLink?: string;
    value?: BastionSessionState[];
}

// @public
export interface BastionSessionState {
    readonly message?: string;
    readonly sessionId?: string;
    readonly state?: string;
}

// @public
export interface BastionShareableLink {
    readonly bsl?: string;
    readonly createdAt?: string;
    readonly message?: string;
    vm: Vm;
}

// @public
export interface BastionShareableLinkListRequest {
    vms?: BastionShareableLink[];
}

// @public
export interface BastionShareableLinkListResult {
    nextLink?: string;
    value?: BastionShareableLink[];
}

// @public
export interface BastionShareableLinkTokenListRequest {
    tokens?: string[];
}

// @public
export interface BGPCommunity {
    communityName?: string;
    communityPrefixes?: string[];
    communityValue?: string;
    isAuthorizedToUse?: boolean;
    serviceGroup?: string;
    serviceSupportedRegion?: string;
}

// @public
export interface BgpConnection extends SubResource {
    readonly connectionState?: HubBgpConnectionStatus;
    readonly etag?: string;
    hubVirtualNetworkConnection?: SubResource;
    name?: string;
    peerAsn?: number;
    peerIp?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export type BgpPeerState = string;

// @public
export interface BgpPeerStatus {
    readonly asn?: number;
    readonly connectedDuration?: string;
    readonly localAddress?: string;
    readonly messagesReceived?: number;
    readonly messagesSent?: number;
    readonly neighbor?: string;
    readonly routesReceived?: number;
    readonly state?: BgpPeerState;
}

// @public
export interface BgpPeerStatusListResult {
    value?: BgpPeerStatus[];
}

// @public
export interface BgpServiceCommunities {
    list(options?: BgpServiceCommunitiesListOptionalParams): PagedAsyncIterableIterator<BgpServiceCommunity>;
}

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

// @public
export type BgpServiceCommunitiesListNextResponse = BgpServiceCommunityListResult;

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

// @public
export type BgpServiceCommunitiesListResponse = BgpServiceCommunityListResult;

// @public
export interface BgpServiceCommunity extends Resource {
    bgpCommunities?: BGPCommunity[];
    serviceName?: string;
}

// @public
export interface BgpServiceCommunityListResult {
    nextLink?: string;
    value?: BgpServiceCommunity[];
}

// @public
export interface BgpSettings {
    asn?: number;
    bgpPeeringAddress?: string;
    bgpPeeringAddresses?: IPConfigurationBgpPeeringAddress[];
    peerWeight?: number;
}

// @public
export interface BreakOutCategoryPolicies {
    allow?: boolean;
    default?: boolean;
    optimize?: boolean;
}

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

// @public
export type CheckDnsNameAvailabilityResponse = DnsNameAvailabilityResult;

// @public
export interface CheckPrivateLinkServiceVisibilityRequest {
    privateLinkServiceAlias?: string;
}

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

// @public
export type CircuitConnectionStatus = string;

// @public (undocumented)
export interface CircuitMetadataMap {
    link?: string;
    location?: string;
    name?: string;
}

// @public
export interface CloudError {
    error?: CloudErrorBody;
}

// @public
export interface CloudErrorBody {
    code?: string;
    details?: CloudErrorBody[];
    message?: string;
    target?: string;
}

// @public
export type CommissionedState = string;

// @public
export interface CommonErrorAdditionalInfo {
    readonly info?: Record<string, unknown>;
    readonly type?: string;
}

// @public
export interface CommonErrorDetail {
    readonly additionalInfo?: CommonErrorAdditionalInfo[];
    readonly code?: string;
    readonly details?: CommonErrorDetail[];
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface CommonErrorResponse {
    error?: CommonErrorDetail;
}

// @public
export interface CommonProxyResource extends CommonResource {
}

// @public
export interface CommonResource {
    readonly id?: string;
    readonly name?: string;
    readonly systemData?: SystemData;
    readonly type?: string;
}

// @public
export interface CommonTrackedResource extends CommonResource {
    location: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public (undocumented)
export interface Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties {
    readonly clientId?: string;
    readonly principalId?: string;
}

// @public
export interface ConfigurationGroup {
    description?: string;
    id?: string;
    memberType?: GroupMemberType;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

// @public
export interface ConfigurationPolicyGroups {
    beginCreateOrUpdate(resourceGroupName: string, vpnServerConfigurationName: string, configurationPolicyGroupName: string, vpnServerConfigurationPolicyGroupParameters: VpnServerConfigurationPolicyGroup, options?: ConfigurationPolicyGroupsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ConfigurationPolicyGroupsCreateOrUpdateResponse>, ConfigurationPolicyGroupsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, vpnServerConfigurationName: string, configurationPolicyGroupName: string, vpnServerConfigurationPolicyGroupParameters: VpnServerConfigurationPolicyGroup, options?: ConfigurationPolicyGroupsCreateOrUpdateOptionalParams): Promise<ConfigurationPolicyGroupsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, vpnServerConfigurationName: string, configurationPolicyGroupName: string, options?: ConfigurationPolicyGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, vpnServerConfigurationName: string, configurationPolicyGroupName: string, options?: ConfigurationPolicyGroupsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, vpnServerConfigurationName: string, configurationPolicyGroupName: string, options?: ConfigurationPolicyGroupsGetOptionalParams): Promise<ConfigurationPolicyGroupsGetResponse>;
    listByVpnServerConfiguration(resourceGroupName: string, vpnServerConfigurationName: string, options?: ConfigurationPolicyGroupsListByVpnServerConfigurationOptionalParams): PagedAsyncIterableIterator<VpnServerConfigurationPolicyGroup>;
}

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

// @public
export type ConfigurationPolicyGroupsCreateOrUpdateResponse = VpnServerConfigurationPolicyGroup;

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

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

// @public
export type ConfigurationPolicyGroupsGetResponse = VpnServerConfigurationPolicyGroup;

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

// @public
export type ConfigurationPolicyGroupsListByVpnServerConfigurationNextResponse = ListVpnServerConfigurationPolicyGroupsResult;

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

// @public
export type ConfigurationPolicyGroupsListByVpnServerConfigurationResponse = ListVpnServerConfigurationPolicyGroupsResult;

// @public
export type ConfigurationType = string;

// @public
export type ConnectedGroupAddressOverlap = string;

// @public
export type ConnectedGroupPrivateEndpointsScale = string;

// @public
export interface ConnectionMonitor {
    autoStart?: boolean;
    destination?: ConnectionMonitorDestination;
    endpoints?: ConnectionMonitorEndpoint[];
    location?: string;
    monitoringIntervalInSeconds?: number;
    notes?: string;
    outputs?: ConnectionMonitorOutput[];
    source?: ConnectionMonitorSource;
    tags?: {
        [propertyName: string]: string;
    };
    testConfigurations?: ConnectionMonitorTestConfiguration[];
    testGroups?: ConnectionMonitorTestGroup[];
}

// @public
export interface ConnectionMonitorDestination {
    address?: string;
    port?: number;
    resourceId?: string;
}

// @public
export interface ConnectionMonitorEndpoint {
    address?: string;
    coverageLevel?: CoverageLevel;
    filter?: ConnectionMonitorEndpointFilter;
    locationDetails?: ConnectionMonitorEndpointLocationDetails;
    name: string;
    resourceId?: string;
    scope?: ConnectionMonitorEndpointScope;
    subscriptionId?: string;
    type?: EndpointType;
}

// @public
export interface ConnectionMonitorEndpointFilter {
    items?: ConnectionMonitorEndpointFilterItem[];
    type?: ConnectionMonitorEndpointFilterType;
}

// @public
export interface ConnectionMonitorEndpointFilterItem {
    address?: string;
    type?: ConnectionMonitorEndpointFilterItemType;
}

// @public
export type ConnectionMonitorEndpointFilterItemType = string;

// @public
export type ConnectionMonitorEndpointFilterType = string;

// @public
export interface ConnectionMonitorEndpointLocationDetails {
    region?: string;
}

// @public
export interface ConnectionMonitorEndpointScope {
    exclude?: ConnectionMonitorEndpointScopeItem[];
    include?: ConnectionMonitorEndpointScopeItem[];
}

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

// @public
export interface ConnectionMonitorHttpConfiguration {
    method?: HttpConfigurationMethod;
    path?: string;
    port?: number;
    preferHttps?: boolean;
    requestHeaders?: HttpHeader[];
    validStatusCodeRanges?: string[];
}

// @public
export interface ConnectionMonitorIcmpConfiguration {
    disableTraceRoute?: boolean;
}

// @public
export interface ConnectionMonitorListResult {
    value?: ConnectionMonitorResult[];
}

// @public
export interface ConnectionMonitorOutput {
    type?: OutputType;
    workspaceSettings?: ConnectionMonitorWorkspaceSettings;
}

// @public
export interface ConnectionMonitorParameters {
    autoStart?: boolean;
    destination?: ConnectionMonitorDestination;
    endpoints?: ConnectionMonitorEndpoint[];
    monitoringIntervalInSeconds?: number;
    notes?: string;
    outputs?: ConnectionMonitorOutput[];
    source?: ConnectionMonitorSource;
    testConfigurations?: ConnectionMonitorTestConfiguration[];
    testGroups?: ConnectionMonitorTestGroup[];
}

// @public
export interface ConnectionMonitorQueryResult {
    sourceStatus?: ConnectionMonitorSourceStatus;
    states?: ConnectionStateSnapshot[];
}

// @public
export interface ConnectionMonitorResult {
    autoStart?: boolean;
    readonly connectionMonitorType?: ConnectionMonitorType;
    destination?: ConnectionMonitorDestination;
    endpoints?: ConnectionMonitorEndpoint[];
    readonly etag?: string;
    readonly id?: string;
    location?: string;
    monitoringIntervalInSeconds?: number;
    readonly monitoringStatus?: string;
    readonly name?: string;
    notes?: string;
    outputs?: ConnectionMonitorOutput[];
    readonly provisioningState?: ProvisioningState;
    source?: ConnectionMonitorSource;
    readonly startTime?: Date;
    tags?: {
        [propertyName: string]: string;
    };
    testConfigurations?: ConnectionMonitorTestConfiguration[];
    testGroups?: ConnectionMonitorTestGroup[];
    readonly type?: string;
}

// @public
export interface ConnectionMonitorResultProperties extends ConnectionMonitorParameters {
    readonly connectionMonitorType?: ConnectionMonitorType;
    readonly monitoringStatus?: string;
    readonly provisioningState?: ProvisioningState;
    readonly startTime?: Date;
}

// @public
export interface ConnectionMonitors {
    beginCreateOrUpdate(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, parameters: ConnectionMonitor, options?: ConnectionMonitorsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ConnectionMonitorsCreateOrUpdateResponse>, ConnectionMonitorsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, parameters: ConnectionMonitor, options?: ConnectionMonitorsCreateOrUpdateOptionalParams): Promise<ConnectionMonitorsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, options?: ConnectionMonitorsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, options?: ConnectionMonitorsDeleteOptionalParams): Promise<void>;
    beginStop(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, options?: ConnectionMonitorsStopOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginStopAndWait(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, options?: ConnectionMonitorsStopOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, options?: ConnectionMonitorsGetOptionalParams): Promise<ConnectionMonitorsGetResponse>;
    list(resourceGroupName: string, networkWatcherName: string, options?: ConnectionMonitorsListOptionalParams): PagedAsyncIterableIterator<ConnectionMonitorResult>;
    updateTags(resourceGroupName: string, networkWatcherName: string, connectionMonitorName: string, parameters: TagsObject, options?: ConnectionMonitorsUpdateTagsOptionalParams): Promise<ConnectionMonitorsUpdateTagsResponse>;
}

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

// @public
export type ConnectionMonitorsCreateOrUpdateResponse = ConnectionMonitorResult;

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

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

// @public
export type ConnectionMonitorsGetResponse = ConnectionMonitorResult;

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

// @public
export type ConnectionMonitorsListResponse = ConnectionMonitorListResult;

// @public
export interface ConnectionMonitorSource {
    port?: number;
    resourceId: string;
}

// @public
export type ConnectionMonitorSourceStatus = string;

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

// @public
export interface ConnectionMonitorSuccessThreshold {
    checksFailedPercent?: number;
    roundTripTimeMs?: number;
}

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

// @public
export type ConnectionMonitorsUpdateTagsResponse = ConnectionMonitorResult;

// @public
export interface ConnectionMonitorTcpConfiguration {
    destinationPortBehavior?: DestinationPortBehavior;
    disableTraceRoute?: boolean;
    port?: number;
}

// @public
export interface ConnectionMonitorTestConfiguration {
    httpConfiguration?: ConnectionMonitorHttpConfiguration;
    icmpConfiguration?: ConnectionMonitorIcmpConfiguration;
    name: string;
    preferredIPVersion?: PreferredIPVersion;
    protocol: ConnectionMonitorTestConfigurationProtocol;
    successThreshold?: ConnectionMonitorSuccessThreshold;
    tcpConfiguration?: ConnectionMonitorTcpConfiguration;
    testFrequencySec?: number;
}

// @public
export type ConnectionMonitorTestConfigurationProtocol = string;

// @public
export interface ConnectionMonitorTestGroup {
    destinations: string[];
    disable?: boolean;
    name: string;
    sources: string[];
    testConfigurations: string[];
}

// @public
export type ConnectionMonitorType = string;

// @public
export interface ConnectionMonitorWorkspaceSettings {
    workspaceResourceId?: string;
}

// @public
export interface ConnectionResetSharedKey {
    keyLength: number;
}

// @public
export interface ConnectionSharedKey extends SubResource {
    value: string;
}

// @public
export interface ConnectionSharedKeyResult extends SubResource {
    name?: string;
    properties?: SharedKeyProperties;
    readonly type?: string;
}

// @public
export interface ConnectionSharedKeyResultList {
    nextLink?: string;
    value?: ConnectionSharedKeyResult[];
}

// @public
export type ConnectionState = string;

// @public
export interface ConnectionStateSnapshot {
    avgLatencyInMs?: number;
    connectionState?: ConnectionState;
    endTime?: Date;
    evaluationState?: EvaluationState;
    readonly hops?: ConnectivityHop[];
    maxLatencyInMs?: number;
    minLatencyInMs?: number;
    probesFailed?: number;
    probesSent?: number;
    startTime?: Date;
}

// @public
export type ConnectionStatus = string;

// @public
export interface ConnectivityConfiguration extends ChildResource {
    appliesToGroups?: ConnectivityGroupItem[];
    connectivityCapabilities?: ConnectivityConfigurationPropertiesConnectivityCapabilities;
    connectivityTopology?: ConnectivityTopology;
    deleteExistingPeering?: DeleteExistingPeering;
    description?: string;
    hubs?: Hub[];
    isGlobal?: IsGlobal;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface ConnectivityConfigurationListResult {
    nextLink?: string;
    value?: ConnectivityConfiguration[];
}

// @public
export interface ConnectivityConfigurationPropertiesConnectivityCapabilities {
    connectedGroupAddressOverlap: ConnectedGroupAddressOverlap;
    connectedGroupPrivateEndpointsScale: ConnectedGroupPrivateEndpointsScale;
    peeringEnforcement: PeeringEnforcement;
}

// @public
export interface ConnectivityConfigurations {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: ConnectivityConfigurationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: ConnectivityConfigurationsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, connectivityConfiguration: ConnectivityConfiguration, options?: ConnectivityConfigurationsCreateOrUpdateOptionalParams): Promise<ConnectivityConfigurationsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: ConnectivityConfigurationsGetOptionalParams): Promise<ConnectivityConfigurationsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: ConnectivityConfigurationsListOptionalParams): PagedAsyncIterableIterator<ConnectivityConfiguration>;
}

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

// @public
export type ConnectivityConfigurationsCreateOrUpdateResponse = ConnectivityConfiguration;

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

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

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

// @public
export type ConnectivityConfigurationsGetResponse = ConnectivityConfiguration;

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

// @public
export type ConnectivityConfigurationsListNextResponse = ConnectivityConfigurationListResult;

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

// @public
export type ConnectivityConfigurationsListResponse = ConnectivityConfigurationListResult;

// @public
export interface ConnectivityDestination {
    address?: string;
    port?: number;
    resourceId?: string;
}

// @public
export interface ConnectivityGroupItem {
    groupConnectivity: GroupConnectivity;
    isGlobal?: IsGlobal;
    networkGroupId: string;
    useHubGateway?: UseHubGateway;
}

// @public
export interface ConnectivityHop {
    readonly address?: string;
    readonly id?: string;
    readonly issues?: ConnectivityIssue[];
    readonly links?: HopLink[];
    readonly nextHopIds?: string[];
    readonly previousHopIds?: string[];
    readonly previousLinks?: HopLink[];
    readonly resourceId?: string;
    readonly type?: string;
}

// @public
export interface ConnectivityInformation {
    readonly avgLatencyInMs?: number;
    readonly connectionStatus?: ConnectionStatus;
    readonly hops?: ConnectivityHop[];
    readonly maxLatencyInMs?: number;
    readonly minLatencyInMs?: number;
    readonly probesFailed?: number;
    readonly probesSent?: number;
}

// @public
export interface ConnectivityIssue {
    readonly context?: {
        [propertyName: string]: string;
    }[];
    readonly origin?: Origin;
    readonly severity?: Severity;
    readonly type?: IssueType;
}

// @public
export interface ConnectivityParameters {
    destination: ConnectivityDestination;
    preferredIPVersion?: IPVersion;
    protocol?: Protocol;
    protocolConfiguration?: ProtocolConfiguration;
    source: ConnectivitySource;
}

// @public
export interface ConnectivitySource {
    port?: number;
    resourceId: string;
}

// @public
export type ConnectivityTopology = string;

// @public
export interface Container extends SubResource {
}

// @public
export interface ContainerNetworkInterface extends SubResource {
    container?: Container;
    readonly containerNetworkInterfaceConfiguration?: ContainerNetworkInterfaceConfiguration;
    readonly etag?: string;
    readonly ipConfigurations?: ContainerNetworkInterfaceIpConfiguration[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ContainerNetworkInterfaceConfiguration extends SubResource {
    containerNetworkInterfaces?: SubResource[];
    readonly etag?: string;
    ipConfigurations?: IPConfigurationProfile[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ContainerNetworkInterfaceIpConfiguration {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export type CoverageLevel = string;

// @public
export type CreatedByType = string;

// @public
export interface Criterion {
    asPath?: string[];
    community?: string[];
    matchCondition?: RouteMapMatchCondition;
    routePrefix?: string[];
}

// @public
export interface CrossTenantScopes {
    readonly managementGroups?: string[];
    readonly subscriptions?: string[];
    readonly tenantId?: string;
}

// @public
export interface CustomDnsConfigPropertiesFormat {
    fqdn?: string;
    ipAddresses?: string[];
}

// @public
export interface CustomIpPrefix extends Resource {
    asn?: string;
    authorizationMessage?: string;
    readonly childCustomIpPrefixes?: SubResource[];
    cidr?: string;
    commissionedState?: CommissionedState;
    customIpPrefixParent?: SubResource;
    readonly etag?: string;
    expressRouteAdvertise?: boolean;
    extendedLocation?: ExtendedLocation;
    readonly failedReason?: string;
    geo?: Geo;
    noInternetAdvertise?: boolean;
    prefixType?: CustomIpPrefixType;
    readonly provisioningState?: ProvisioningState;
    readonly publicIpPrefixes?: SubResource[];
    readonly resourceGuid?: string;
    signedMessage?: string;
    zones?: string[];
}

// @public
export interface CustomIPPrefixes {
    beginCreateOrUpdate(resourceGroupName: string, customIpPrefixName: string, parameters: CustomIpPrefix, options?: CustomIPPrefixesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<CustomIPPrefixesCreateOrUpdateResponse>, CustomIPPrefixesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, customIpPrefixName: string, parameters: CustomIpPrefix, options?: CustomIPPrefixesCreateOrUpdateOptionalParams): Promise<CustomIPPrefixesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, customIpPrefixName: string, options?: CustomIPPrefixesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, customIpPrefixName: string, options?: CustomIPPrefixesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, customIpPrefixName: string, options?: CustomIPPrefixesGetOptionalParams): Promise<CustomIPPrefixesGetResponse>;
    list(resourceGroupName: string, options?: CustomIPPrefixesListOptionalParams): PagedAsyncIterableIterator<CustomIpPrefix>;
    listAll(options?: CustomIPPrefixesListAllOptionalParams): PagedAsyncIterableIterator<CustomIpPrefix>;
    updateTags(resourceGroupName: string, customIpPrefixName: string, parameters: TagsObject, options?: CustomIPPrefixesUpdateTagsOptionalParams): Promise<CustomIPPrefixesUpdateTagsResponse>;
}

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

// @public
export type CustomIPPrefixesCreateOrUpdateResponse = CustomIpPrefix;

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

// @public
export interface CustomIPPrefixesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type CustomIPPrefixesGetResponse = CustomIpPrefix;

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

// @public
export type CustomIPPrefixesListAllNextResponse = CustomIpPrefixListResult;

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

// @public
export type CustomIPPrefixesListAllResponse = CustomIpPrefixListResult;

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

// @public
export type CustomIPPrefixesListNextResponse = CustomIpPrefixListResult;

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

// @public
export type CustomIPPrefixesListResponse = CustomIpPrefixListResult;

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

// @public
export type CustomIPPrefixesUpdateTagsResponse = CustomIpPrefix;

// @public
export interface CustomIpPrefixListResult {
    nextLink?: string;
    value?: CustomIpPrefix[];
}

// @public
export type CustomIpPrefixType = string;

// @public
export interface DdosCustomPolicies {
    beginCreateOrUpdate(resourceGroupName: string, ddosCustomPolicyName: string, parameters: DdosCustomPolicy, options?: DdosCustomPoliciesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DdosCustomPoliciesCreateOrUpdateResponse>, DdosCustomPoliciesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, ddosCustomPolicyName: string, parameters: DdosCustomPolicy, options?: DdosCustomPoliciesCreateOrUpdateOptionalParams): Promise<DdosCustomPoliciesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, ddosCustomPolicyName: string, options?: DdosCustomPoliciesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, ddosCustomPolicyName: string, options?: DdosCustomPoliciesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ddosCustomPolicyName: string, options?: DdosCustomPoliciesGetOptionalParams): Promise<DdosCustomPoliciesGetResponse>;
    updateTags(resourceGroupName: string, ddosCustomPolicyName: string, parameters: TagsObject, options?: DdosCustomPoliciesUpdateTagsOptionalParams): Promise<DdosCustomPoliciesUpdateTagsResponse>;
}

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

// @public
export type DdosCustomPoliciesCreateOrUpdateResponse = DdosCustomPolicy;

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

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

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

// @public
export type DdosCustomPoliciesGetResponse = DdosCustomPolicy;

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

// @public
export type DdosCustomPoliciesUpdateTagsResponse = DdosCustomPolicy;

// @public
export interface DdosCustomPolicy extends Resource {
    readonly etag?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

// @public
export interface DdosProtectionPlan {
    readonly etag?: string;
    readonly id?: string;
    location?: string;
    readonly name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly publicIPAddresses?: SubResource[];
    readonly resourceGuid?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
    readonly virtualNetworks?: SubResource[];
}

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

// @public
export interface DdosProtectionPlans {
    beginCreateOrUpdate(resourceGroupName: string, ddosProtectionPlanName: string, parameters: DdosProtectionPlan, options?: DdosProtectionPlansCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DdosProtectionPlansCreateOrUpdateResponse>, DdosProtectionPlansCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, ddosProtectionPlanName: string, parameters: DdosProtectionPlan, options?: DdosProtectionPlansCreateOrUpdateOptionalParams): Promise<DdosProtectionPlansCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, ddosProtectionPlanName: string, options?: DdosProtectionPlansDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, ddosProtectionPlanName: string, options?: DdosProtectionPlansDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ddosProtectionPlanName: string, options?: DdosProtectionPlansGetOptionalParams): Promise<DdosProtectionPlansGetResponse>;
    list(options?: DdosProtectionPlansListOptionalParams): PagedAsyncIterableIterator<DdosProtectionPlan>;
    listByResourceGroup(resourceGroupName: string, options?: DdosProtectionPlansListByResourceGroupOptionalParams): PagedAsyncIterableIterator<DdosProtectionPlan>;
    updateTags(resourceGroupName: string, ddosProtectionPlanName: string, parameters: TagsObject, options?: DdosProtectionPlansUpdateTagsOptionalParams): Promise<DdosProtectionPlansUpdateTagsResponse>;
}

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

// @public
export type DdosProtectionPlansCreateOrUpdateResponse = DdosProtectionPlan;

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

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

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

// @public
export type DdosProtectionPlansGetResponse = DdosProtectionPlan;

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

// @public
export type DdosProtectionPlansListByResourceGroupNextResponse = DdosProtectionPlanListResult;

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

// @public
export type DdosProtectionPlansListByResourceGroupResponse = DdosProtectionPlanListResult;

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

// @public
export type DdosProtectionPlansListNextResponse = DdosProtectionPlanListResult;

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

// @public
export type DdosProtectionPlansListResponse = DdosProtectionPlanListResult;

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

// @public
export type DdosProtectionPlansUpdateTagsResponse = DdosProtectionPlan;

// @public
export interface DdosSettings {
    ddosProtectionPlan?: SubResource;
    protectionMode?: DdosSettingsProtectionMode;
}

// @public
export type DdosSettingsProtectionMode = string;

// @public
export interface DefaultAdminRule extends BaseAdminRule {
    readonly access?: SecurityConfigurationRuleAccess;
    readonly description?: string;
    readonly destinationPortRanges?: string[];
    readonly destinations?: AddressPrefixItem[];
    readonly direction?: SecurityConfigurationRuleDirection;
    flag?: string;
    kind: "Default";
    readonly priority?: number;
    readonly protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly sourcePortRanges?: string[];
    readonly sources?: AddressPrefixItem[];
}

// @public
export interface DefaultSecurityRules {
    get(resourceGroupName: string, networkSecurityGroupName: string, defaultSecurityRuleName: string, options?: DefaultSecurityRulesGetOptionalParams): Promise<DefaultSecurityRulesGetResponse>;
    list(resourceGroupName: string, networkSecurityGroupName: string, options?: DefaultSecurityRulesListOptionalParams): PagedAsyncIterableIterator<SecurityRule>;
}

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

// @public
export type DefaultSecurityRulesGetResponse = SecurityRule;

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

// @public
export type DefaultSecurityRulesListNextResponse = SecurityRuleListResult;

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

// @public
export type DefaultSecurityRulesListResponse = SecurityRuleListResult;

// @public
export interface Delegation extends SubResource {
    readonly actions?: string[];
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    serviceName?: string;
    type?: string;
}

// @public
export interface DelegationProperties {
    readonly provisioningState?: ProvisioningState;
    serviceName?: string;
}

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

// @public
export type DeleteBastionShareableLinkByTokenResponse = NetworkManagementClientDeleteBastionShareableLinkByTokenHeaders;

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

// @public
export type DeleteExistingPeering = string;

// @public
export type DeleteOptions = string;

// @public
export type DeploymentStatus = string;

// @public
export type DestinationPortBehavior = string;

// @public
export interface DeviceProperties {
    deviceModel?: string;
    deviceVendor?: string;
    linkSpeedInMbps?: number;
}

// @public
export interface DhcpOptions {
    dnsServers?: string[];
}

// @public
export type DhGroup = string;

// @public
export interface Dimension {
    displayName?: string;
    internalName?: string;
    name?: string;
}

// @public
export type Direction = string;

// @public
export type DisableBgpRoutePropagation = string;

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

// @public
export type DisconnectActiveSessionsNextResponse = BastionSessionDeleteResult;

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

// @public
export type DisconnectActiveSessionsResponse = BastionSessionDeleteResult;

// @public
export interface DnsNameAvailabilityResult {
    available?: boolean;
}

// @public
export interface DnsSettings {
    enableProxy?: boolean;
    requireProxyForNetworkRules?: boolean;
    servers?: string[];
}

// @public
export interface DscpConfiguration extends Resource {
    readonly associatedNetworkInterfaces?: NetworkInterface[];
    destinationIpRanges?: QosIpRange[];
    destinationPortRanges?: QosPortRange[];
    readonly etag?: string;
    markings?: number[];
    protocol?: ProtocolType;
    readonly provisioningState?: ProvisioningState;
    readonly qosCollectionId?: string;
    qosDefinitionCollection?: QosDefinition[];
    readonly resourceGuid?: string;
    sourceIpRanges?: QosIpRange[];
    sourcePortRanges?: QosPortRange[];
}

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

// @public
export type DscpConfigurationCreateOrUpdateResponse = DscpConfiguration;

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

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

// @public
export type DscpConfigurationGetResponse = DscpConfiguration;

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

// @public
export type DscpConfigurationListAllNextResponse = DscpConfigurationListResult;

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

// @public
export type DscpConfigurationListAllResponse = DscpConfigurationListResult;

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

// @public
export type DscpConfigurationListNextResponse = DscpConfigurationListResult;

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

// @public
export type DscpConfigurationListResponse = DscpConfigurationListResult;

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

// @public
export interface DscpConfigurationOperations {
    beginCreateOrUpdate(resourceGroupName: string, dscpConfigurationName: string, parameters: DscpConfiguration, options?: DscpConfigurationCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DscpConfigurationCreateOrUpdateResponse>, DscpConfigurationCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, dscpConfigurationName: string, parameters: DscpConfiguration, options?: DscpConfigurationCreateOrUpdateOptionalParams): Promise<DscpConfigurationCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, dscpConfigurationName: string, options?: DscpConfigurationDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, dscpConfigurationName: string, options?: DscpConfigurationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, dscpConfigurationName: string, options?: DscpConfigurationGetOptionalParams): Promise<DscpConfigurationGetResponse>;
    list(resourceGroupName: string, options?: DscpConfigurationListOptionalParams): PagedAsyncIterableIterator<DscpConfiguration>;
    listAll(options?: DscpConfigurationListAllOptionalParams): PagedAsyncIterableIterator<DscpConfiguration>;
}

// @public
export type EffectiveAdminRuleKind = string;

// @public
export interface EffectiveBaseSecurityAdminRule {
    configurationDescription?: string;
    id?: string;
    kind: "Custom" | "Default";
    ruleCollectionAppliesToGroups?: NetworkManagerSecurityGroupItem[];
    ruleCollectionDescription?: string;
    ruleGroups?: ConfigurationGroup[];
}

// @public (undocumented)
export type EffectiveBaseSecurityAdminRuleUnion = EffectiveBaseSecurityAdminRule | EffectiveSecurityAdminRule | EffectiveDefaultSecurityAdminRule;

// @public
export interface EffectiveConnectivityConfiguration {
    appliesToGroups?: ConnectivityGroupItem[];
    configurationGroups?: ConfigurationGroup[];
    connectivityCapabilities?: ConnectivityConfigurationPropertiesConnectivityCapabilities;
    connectivityTopology?: ConnectivityTopology;
    deleteExistingPeering?: DeleteExistingPeering;
    description?: string;
    hubs?: Hub[];
    id?: string;
    isGlobal?: IsGlobal;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

// @public
export interface EffectiveDefaultSecurityAdminRule extends EffectiveBaseSecurityAdminRule {
    readonly access?: SecurityConfigurationRuleAccess;
    readonly description?: string;
    readonly destinationPortRanges?: string[];
    readonly destinations?: AddressPrefixItem[];
    readonly direction?: SecurityConfigurationRuleDirection;
    flag?: string;
    kind: "Default";
    readonly priority?: number;
    readonly protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly sourcePortRanges?: string[];
    readonly sources?: AddressPrefixItem[];
}

// @public
export interface EffectiveNetworkSecurityGroup {
    association?: EffectiveNetworkSecurityGroupAssociation;
    effectiveSecurityRules?: EffectiveNetworkSecurityRule[];
    networkSecurityGroup?: SubResource;
    tagMap?: string;
}

// @public
export interface EffectiveNetworkSecurityGroupAssociation {
    networkInterface?: SubResource;
    networkManager?: SubResource;
    subnet?: SubResource;
}

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

// @public
export interface EffectiveNetworkSecurityRule {
    access?: SecurityRuleAccess;
    destinationAddressPrefix?: string;
    destinationAddressPrefixes?: string[];
    destinationPortRange?: string;
    destinationPortRanges?: string[];
    direction?: SecurityRuleDirection;
    expandedDestinationAddressPrefix?: string[];
    expandedSourceAddressPrefix?: string[];
    name?: string;
    priority?: number;
    protocol?: EffectiveSecurityRuleProtocol;
    sourceAddressPrefix?: string;
    sourceAddressPrefixes?: string[];
    sourcePortRange?: string;
    sourcePortRanges?: string[];
}

// @public
export interface EffectiveRoute {
    addressPrefix?: string[];
    disableBgpRoutePropagation?: boolean;
    name?: string;
    nextHopIpAddress?: string[];
    nextHopType?: RouteNextHopType;
    source?: EffectiveRouteSource;
    state?: EffectiveRouteState;
}

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

// @public
export interface EffectiveRouteMapRoute {
    asPath?: string;
    bgpCommunities?: string;
    prefix?: string;
}

// @public
export interface EffectiveRouteMapRouteList {
    value?: EffectiveRouteMapRoute[];
}

// @public
export type EffectiveRouteSource = string;

// @public
export interface EffectiveRoutesParameters {
    resourceId?: string;
    virtualWanResourceType?: string;
}

// @public
export type EffectiveRouteState = string;

// @public
export interface EffectiveSecurityAdminRule extends EffectiveBaseSecurityAdminRule {
    access?: SecurityConfigurationRuleAccess;
    description?: string;
    destinationPortRanges?: string[];
    destinations?: AddressPrefixItem[];
    direction?: SecurityConfigurationRuleDirection;
    kind: "Custom";
    priority?: number;
    protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    sourcePortRanges?: string[];
    sources?: AddressPrefixItem[];
}

// @public
export type EffectiveSecurityRuleProtocol = string;

// @public
export interface EndpointServiceResult extends SubResource {
    readonly name?: string;
    readonly type?: string;
}

// @public
export interface EndpointServicesListResult {
    nextLink?: string;
    value?: EndpointServiceResult[];
}

// @public
export type EndpointType = string;

// @public
export interface ErrorAdditionalInfo {
    readonly info?: Record<string, unknown>;
    readonly type?: string;
}

// @public
export interface ErrorDetail {
    readonly additionalInfo?: ErrorAdditionalInfo[];
    readonly code?: string;
    readonly details?: ErrorDetail[];
    readonly message?: string;
    readonly target?: string;
}

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

// @public
export interface ErrorModel {
    code?: string;
    details?: ErrorDetails[];
    innerError?: string;
    message?: string;
    target?: string;
}

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

// @public
export interface EvaluatedNetworkSecurityGroup {
    appliedTo?: string;
    matchedRule?: MatchedRule;
    networkSecurityGroupId?: string;
    readonly rulesEvaluationResult?: NetworkSecurityRulesEvaluationResult[];
}

// @public
export type EvaluationState = string;

// @public
export interface ExceptionEntry {
    exceptionManagedRuleSets?: ExclusionManagedRuleSet[];
    matchVariable: ExceptionEntryMatchVariable;
    selector?: string;
    selectorMatchOperator?: ExceptionEntrySelectorMatchOperator;
    valueMatchOperator: ExceptionEntryValueMatchOperator;
    values?: string[];
}

// @public
export type ExceptionEntryMatchVariable = string;

// @public
export type ExceptionEntrySelectorMatchOperator = string;

// @public
export type ExceptionEntryValueMatchOperator = string;

// @public
export interface ExclusionManagedRule {
    ruleId: string;
}

// @public
export interface ExclusionManagedRuleGroup {
    ruleGroupName: string;
    rules?: ExclusionManagedRule[];
}

// @public
export interface ExclusionManagedRuleSet {
    ruleGroups?: ExclusionManagedRuleGroup[];
    ruleSetType: string;
    ruleSetVersion: string;
}

// @public
export interface ExplicitProxy {
    enableExplicitProxy?: boolean;
    enablePacFile?: boolean;
    httpPort?: number;
    httpsPort?: number;
    pacFile?: string;
    pacFilePort?: number;
}

// @public
export interface ExpressRouteCircuit extends Resource {
    allowClassicOperations?: boolean;
    authorizationKey?: string;
    authorizations?: ExpressRouteCircuitAuthorization[];
    readonly authorizationStatus?: string;
    bandwidthInGbps?: number;
    circuitProvisioningState?: string;
    enableDirectPortRateLimit?: boolean;
    readonly etag?: string;
    expressRoutePort?: SubResource;
    gatewayManagerEtag?: string;
    globalReachEnabled?: boolean;
    peerings?: ExpressRouteCircuitPeering[];
    readonly provisioningState?: ProvisioningState;
    serviceKey?: string;
    serviceProviderNotes?: string;
    serviceProviderProperties?: ExpressRouteCircuitServiceProviderProperties;
    serviceProviderProvisioningState?: ServiceProviderProvisioningState;
    sku?: ExpressRouteCircuitSku;
    readonly stag?: number;
}

// @public
export interface ExpressRouteCircuitArpTable {
    age?: number;
    interface?: string;
    ipAddress?: string;
    macAddress?: string;
}

// @public
export interface ExpressRouteCircuitAuthorization extends SubResource {
    authorizationKey?: string;
    authorizationUseStatus?: AuthorizationUseStatus;
    readonly connectionResourceUri?: string;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ExpressRouteCircuitAuthorizations {
    beginCreateOrUpdate(resourceGroupName: string, circuitName: string, authorizationName: string, authorizationParameters: ExpressRouteCircuitAuthorization, options?: ExpressRouteCircuitAuthorizationsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitAuthorizationsCreateOrUpdateResponse>, ExpressRouteCircuitAuthorizationsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, circuitName: string, authorizationName: string, authorizationParameters: ExpressRouteCircuitAuthorization, options?: ExpressRouteCircuitAuthorizationsCreateOrUpdateOptionalParams): Promise<ExpressRouteCircuitAuthorizationsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, circuitName: string, authorizationName: string, options?: ExpressRouteCircuitAuthorizationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, circuitName: string, authorizationName: string, options?: ExpressRouteCircuitAuthorizationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, circuitName: string, authorizationName: string, options?: ExpressRouteCircuitAuthorizationsGetOptionalParams): Promise<ExpressRouteCircuitAuthorizationsGetResponse>;
    list(resourceGroupName: string, circuitName: string, options?: ExpressRouteCircuitAuthorizationsListOptionalParams): PagedAsyncIterableIterator<ExpressRouteCircuitAuthorization>;
}

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

// @public
export type ExpressRouteCircuitAuthorizationsCreateOrUpdateResponse = ExpressRouteCircuitAuthorization;

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

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

// @public
export type ExpressRouteCircuitAuthorizationsGetResponse = ExpressRouteCircuitAuthorization;

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

// @public
export type ExpressRouteCircuitAuthorizationsListNextResponse = AuthorizationListResult;

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

// @public
export type ExpressRouteCircuitAuthorizationsListResponse = AuthorizationListResult;

// @public
export interface ExpressRouteCircuitConnection extends SubResource {
    addressPrefix?: string;
    authorizationKey?: string;
    readonly circuitConnectionStatus?: CircuitConnectionStatus;
    readonly etag?: string;
    expressRouteCircuitPeering?: SubResource;
    ipv6CircuitConnectionConfig?: Ipv6CircuitConnectionConfig;
    name?: string;
    peerExpressRouteCircuitPeering?: SubResource;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ExpressRouteCircuitConnectionListResult {
    nextLink?: string;
    value?: ExpressRouteCircuitConnection[];
}

// @public
export interface ExpressRouteCircuitConnections {
    beginCreateOrUpdate(resourceGroupName: string, circuitName: string, peeringName: string, connectionName: string, expressRouteCircuitConnectionParameters: ExpressRouteCircuitConnection, options?: ExpressRouteCircuitConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitConnectionsCreateOrUpdateResponse>, ExpressRouteCircuitConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, circuitName: string, peeringName: string, connectionName: string, expressRouteCircuitConnectionParameters: ExpressRouteCircuitConnection, options?: ExpressRouteCircuitConnectionsCreateOrUpdateOptionalParams): Promise<ExpressRouteCircuitConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, circuitName: string, peeringName: string, connectionName: string, options?: ExpressRouteCircuitConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, circuitName: string, peeringName: string, connectionName: string, options?: ExpressRouteCircuitConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, circuitName: string, peeringName: string, connectionName: string, options?: ExpressRouteCircuitConnectionsGetOptionalParams): Promise<ExpressRouteCircuitConnectionsGetResponse>;
    list(resourceGroupName: string, circuitName: string, peeringName: string, options?: ExpressRouteCircuitConnectionsListOptionalParams): PagedAsyncIterableIterator<ExpressRouteCircuitConnection>;
}

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

// @public
export type ExpressRouteCircuitConnectionsCreateOrUpdateResponse = ExpressRouteCircuitConnection;

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

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

// @public
export type ExpressRouteCircuitConnectionsGetResponse = ExpressRouteCircuitConnection;

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

// @public
export type ExpressRouteCircuitConnectionsListNextResponse = ExpressRouteCircuitConnectionListResult;

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

// @public
export type ExpressRouteCircuitConnectionsListResponse = ExpressRouteCircuitConnectionListResult;

// @public
export interface ExpressRouteCircuitListResult {
    nextLink?: string;
    value?: ExpressRouteCircuit[];
}

// @public
export interface ExpressRouteCircuitPeering extends SubResource {
    azureASN?: number;
    connections?: ExpressRouteCircuitConnection[];
    readonly etag?: string;
    expressRouteConnection?: ExpressRouteConnectionId;
    gatewayManagerEtag?: string;
    ipv6PeeringConfig?: Ipv6ExpressRouteCircuitPeeringConfig;
    readonly lastModifiedBy?: string;
    microsoftPeeringConfig?: ExpressRouteCircuitPeeringConfig;
    name?: string;
    peerASN?: number;
    readonly peeredConnections?: PeerExpressRouteCircuitConnection[];
    peeringType?: ExpressRoutePeeringType;
    primaryAzurePort?: string;
    primaryPeerAddressPrefix?: string;
    readonly provisioningState?: ProvisioningState;
    routeFilter?: SubResource;
    secondaryAzurePort?: string;
    secondaryPeerAddressPrefix?: string;
    sharedKey?: string;
    state?: ExpressRoutePeeringState;
    stats?: ExpressRouteCircuitStats;
    readonly type?: string;
    vlanId?: number;
}

// @public
export type ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = string;

// @public
export interface ExpressRouteCircuitPeeringConfig {
    advertisedCommunities?: string[];
    advertisedPublicPrefixes?: string[];
    readonly advertisedPublicPrefixesState?: ExpressRouteCircuitPeeringAdvertisedPublicPrefixState;
    advertisedPublicPrefixInfo?: AdvertisedPublicPrefixProperties[];
    customerASN?: number;
    legacyMode?: number;
    routingRegistryName?: string;
}

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

// @public
export interface ExpressRouteCircuitPeeringListResult {
    nextLink?: string;
    value?: ExpressRouteCircuitPeering[];
}

// @public
export interface ExpressRouteCircuitPeerings {
    beginCreateOrUpdate(resourceGroupName: string, circuitName: string, peeringName: string, peeringParameters: ExpressRouteCircuitPeering, options?: ExpressRouteCircuitPeeringsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitPeeringsCreateOrUpdateResponse>, ExpressRouteCircuitPeeringsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, circuitName: string, peeringName: string, peeringParameters: ExpressRouteCircuitPeering, options?: ExpressRouteCircuitPeeringsCreateOrUpdateOptionalParams): Promise<ExpressRouteCircuitPeeringsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, circuitName: string, peeringName: string, options?: ExpressRouteCircuitPeeringsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, circuitName: string, peeringName: string, options?: ExpressRouteCircuitPeeringsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, circuitName: string, peeringName: string, options?: ExpressRouteCircuitPeeringsGetOptionalParams): Promise<ExpressRouteCircuitPeeringsGetResponse>;
    list(resourceGroupName: string, circuitName: string, options?: ExpressRouteCircuitPeeringsListOptionalParams): PagedAsyncIterableIterator<ExpressRouteCircuitPeering>;
}

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

// @public
export type ExpressRouteCircuitPeeringsCreateOrUpdateResponse = ExpressRouteCircuitPeering;

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

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

// @public
export type ExpressRouteCircuitPeeringsGetResponse = ExpressRouteCircuitPeering;

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

// @public
export type ExpressRouteCircuitPeeringsListNextResponse = ExpressRouteCircuitPeeringListResult;

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

// @public
export type ExpressRouteCircuitPeeringsListResponse = ExpressRouteCircuitPeeringListResult;

// @public
export type ExpressRouteCircuitPeeringState = string;

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

// @public
export interface ExpressRouteCircuitRoutesTable {
    locPrf?: string;
    network?: string;
    nextHop?: string;
    path?: string;
    weight?: number;
}

// @public
export interface ExpressRouteCircuitRoutesTableSummary {
    as?: number;
    neighbor?: string;
    statePfxRcd?: string;
    upDown?: string;
    v?: number;
}

// @public
export interface ExpressRouteCircuits {
    beginCreateOrUpdate(resourceGroupName: string, circuitName: string, parameters: ExpressRouteCircuit, options?: ExpressRouteCircuitsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitsCreateOrUpdateResponse>, ExpressRouteCircuitsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, circuitName: string, parameters: ExpressRouteCircuit, options?: ExpressRouteCircuitsCreateOrUpdateOptionalParams): Promise<ExpressRouteCircuitsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, circuitName: string, options?: ExpressRouteCircuitsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, circuitName: string, options?: ExpressRouteCircuitsDeleteOptionalParams): Promise<void>;
    beginListArpTable(resourceGroupName: string, circuitName: string, peeringName: string, devicePath: string, options?: ExpressRouteCircuitsListArpTableOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitsListArpTableResponse>, ExpressRouteCircuitsListArpTableResponse>>;
    beginListArpTableAndWait(resourceGroupName: string, circuitName: string, peeringName: string, devicePath: string, options?: ExpressRouteCircuitsListArpTableOptionalParams): Promise<ExpressRouteCircuitsListArpTableResponse>;
    beginListRoutesTable(resourceGroupName: string, circuitName: string, peeringName: string, devicePath: string, options?: ExpressRouteCircuitsListRoutesTableOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitsListRoutesTableResponse>, ExpressRouteCircuitsListRoutesTableResponse>>;
    beginListRoutesTableAndWait(resourceGroupName: string, circuitName: string, peeringName: string, devicePath: string, options?: ExpressRouteCircuitsListRoutesTableOptionalParams): Promise<ExpressRouteCircuitsListRoutesTableResponse>;
    beginListRoutesTableSummary(resourceGroupName: string, circuitName: string, peeringName: string, devicePath: string, options?: ExpressRouteCircuitsListRoutesTableSummaryOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCircuitsListRoutesTableSummaryResponse>, ExpressRouteCircuitsListRoutesTableSummaryResponse>>;
    beginListRoutesTableSummaryAndWait(resourceGroupName: string, circuitName: string, peeringName: string, devicePath: string, options?: ExpressRouteCircuitsListRoutesTableSummaryOptionalParams): Promise<ExpressRouteCircuitsListRoutesTableSummaryResponse>;
    get(resourceGroupName: string, circuitName: string, options?: ExpressRouteCircuitsGetOptionalParams): Promise<ExpressRouteCircuitsGetResponse>;
    getPeeringStats(resourceGroupName: string, circuitName: string, peeringName: string, options?: ExpressRouteCircuitsGetPeeringStatsOptionalParams): Promise<ExpressRouteCircuitsGetPeeringStatsResponse>;
    getStats(resourceGroupName: string, circuitName: string, options?: ExpressRouteCircuitsGetStatsOptionalParams): Promise<ExpressRouteCircuitsGetStatsResponse>;
    list(resourceGroupName: string, options?: ExpressRouteCircuitsListOptionalParams): PagedAsyncIterableIterator<ExpressRouteCircuit>;
    listAll(options?: ExpressRouteCircuitsListAllOptionalParams): PagedAsyncIterableIterator<ExpressRouteCircuit>;
    updateTags(resourceGroupName: string, circuitName: string, parameters: TagsObject, options?: ExpressRouteCircuitsUpdateTagsOptionalParams): Promise<ExpressRouteCircuitsUpdateTagsResponse>;
}

// @public
export interface ExpressRouteCircuitsArpTableListResult {
    nextLink?: string;
    value?: ExpressRouteCircuitArpTable[];
}

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

// @public
export type ExpressRouteCircuitsCreateOrUpdateResponse = ExpressRouteCircuit;

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

// @public
export interface ExpressRouteCircuitServiceProviderProperties {
    bandwidthInMbps?: number;
    peeringLocation?: string;
    serviceProviderName?: string;
}

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

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

// @public
export type ExpressRouteCircuitsGetPeeringStatsResponse = ExpressRouteCircuitStats;

// @public
export type ExpressRouteCircuitsGetResponse = ExpressRouteCircuit;

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

// @public
export type ExpressRouteCircuitsGetStatsResponse = ExpressRouteCircuitStats;

// @public
export interface ExpressRouteCircuitSku {
    family?: ExpressRouteCircuitSkuFamily;
    name?: string;
    tier?: ExpressRouteCircuitSkuTier;
}

// @public
export type ExpressRouteCircuitSkuFamily = string;

// @public
export type ExpressRouteCircuitSkuTier = string;

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

// @public
export type ExpressRouteCircuitsListAllNextResponse = ExpressRouteCircuitListResult;

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

// @public
export type ExpressRouteCircuitsListAllResponse = ExpressRouteCircuitListResult;

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

// @public
export type ExpressRouteCircuitsListArpTableResponse = ExpressRouteCircuitsArpTableListResult;

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

// @public
export type ExpressRouteCircuitsListNextResponse = ExpressRouteCircuitListResult;

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

// @public
export type ExpressRouteCircuitsListResponse = ExpressRouteCircuitListResult;

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

// @public
export type ExpressRouteCircuitsListRoutesTableResponse = ExpressRouteCircuitsRoutesTableListResult;

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

// @public
export type ExpressRouteCircuitsListRoutesTableSummaryResponse = ExpressRouteCircuitsRoutesTableSummaryListResult;

// @public
export interface ExpressRouteCircuitsRoutesTableListResult {
    nextLink?: string;
    value?: ExpressRouteCircuitRoutesTable[];
}

// @public
export interface ExpressRouteCircuitsRoutesTableSummaryListResult {
    nextLink?: string;
    value?: ExpressRouteCircuitRoutesTableSummary[];
}

// @public
export interface ExpressRouteCircuitStats {
    primarybytesIn?: number;
    primarybytesOut?: number;
    secondarybytesIn?: number;
    secondarybytesOut?: number;
}

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

// @public
export type ExpressRouteCircuitsUpdateTagsResponse = ExpressRouteCircuit;

// @public
export interface ExpressRouteConnection extends SubResource {
    authorizationKey?: string;
    enableInternetSecurity?: boolean;
    enablePrivateLinkFastPath?: boolean;
    expressRouteCircuitPeering?: ExpressRouteCircuitPeeringId;
    expressRouteGatewayBypass?: boolean;
    name: string;
    readonly provisioningState?: ProvisioningState;
    routingConfiguration?: RoutingConfiguration;
    routingWeight?: number;
}

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

// @public
export interface ExpressRouteConnectionList {
    value?: ExpressRouteConnection[];
}

// @public
export interface ExpressRouteConnections {
    beginCreateOrUpdate(resourceGroupName: string, expressRouteGatewayName: string, connectionName: string, putExpressRouteConnectionParameters: ExpressRouteConnection, options?: ExpressRouteConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteConnectionsCreateOrUpdateResponse>, ExpressRouteConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, expressRouteGatewayName: string, connectionName: string, putExpressRouteConnectionParameters: ExpressRouteConnection, options?: ExpressRouteConnectionsCreateOrUpdateOptionalParams): Promise<ExpressRouteConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, expressRouteGatewayName: string, connectionName: string, options?: ExpressRouteConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, expressRouteGatewayName: string, connectionName: string, options?: ExpressRouteConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, expressRouteGatewayName: string, connectionName: string, options?: ExpressRouteConnectionsGetOptionalParams): Promise<ExpressRouteConnectionsGetResponse>;
    list(resourceGroupName: string, expressRouteGatewayName: string, options?: ExpressRouteConnectionsListOptionalParams): Promise<ExpressRouteConnectionsListResponse>;
}

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

// @public
export type ExpressRouteConnectionsCreateOrUpdateResponse = ExpressRouteConnection;

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

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

// @public
export type ExpressRouteConnectionsGetResponse = ExpressRouteConnection;

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

// @public
export type ExpressRouteConnectionsListResponse = ExpressRouteConnectionList;

// @public
export interface ExpressRouteCrossConnection extends Resource {
    readonly bandwidthInMbps?: number;
    readonly etag?: string;
    expressRouteCircuit?: ExpressRouteCircuitReference;
    readonly peeringLocation?: string;
    peerings?: ExpressRouteCrossConnectionPeering[];
    readonly primaryAzurePort?: string;
    readonly provisioningState?: ProvisioningState;
    readonly secondaryAzurePort?: string;
    serviceProviderNotes?: string;
    serviceProviderProvisioningState?: ServiceProviderProvisioningState;
    readonly sTag?: number;
}

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

// @public
export interface ExpressRouteCrossConnectionPeering extends SubResource {
    readonly azureASN?: number;
    readonly etag?: string;
    gatewayManagerEtag?: string;
    ipv6PeeringConfig?: Ipv6ExpressRouteCircuitPeeringConfig;
    readonly lastModifiedBy?: string;
    microsoftPeeringConfig?: ExpressRouteCircuitPeeringConfig;
    name?: string;
    peerASN?: number;
    peeringType?: ExpressRoutePeeringType;
    readonly primaryAzurePort?: string;
    primaryPeerAddressPrefix?: string;
    readonly provisioningState?: ProvisioningState;
    readonly secondaryAzurePort?: string;
    secondaryPeerAddressPrefix?: string;
    sharedKey?: string;
    state?: ExpressRoutePeeringState;
    vlanId?: number;
}

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

// @public
export interface ExpressRouteCrossConnectionPeerings {
    beginCreateOrUpdate(resourceGroupName: string, crossConnectionName: string, peeringName: string, peeringParameters: ExpressRouteCrossConnectionPeering, options?: ExpressRouteCrossConnectionPeeringsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCrossConnectionPeeringsCreateOrUpdateResponse>, ExpressRouteCrossConnectionPeeringsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, crossConnectionName: string, peeringName: string, peeringParameters: ExpressRouteCrossConnectionPeering, options?: ExpressRouteCrossConnectionPeeringsCreateOrUpdateOptionalParams): Promise<ExpressRouteCrossConnectionPeeringsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, crossConnectionName: string, peeringName: string, options?: ExpressRouteCrossConnectionPeeringsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, crossConnectionName: string, peeringName: string, options?: ExpressRouteCrossConnectionPeeringsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, crossConnectionName: string, peeringName: string, options?: ExpressRouteCrossConnectionPeeringsGetOptionalParams): Promise<ExpressRouteCrossConnectionPeeringsGetResponse>;
    list(resourceGroupName: string, crossConnectionName: string, options?: ExpressRouteCrossConnectionPeeringsListOptionalParams): PagedAsyncIterableIterator<ExpressRouteCrossConnectionPeering>;
}

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

// @public
export type ExpressRouteCrossConnectionPeeringsCreateOrUpdateResponse = ExpressRouteCrossConnectionPeering;

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

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

// @public
export type ExpressRouteCrossConnectionPeeringsGetResponse = ExpressRouteCrossConnectionPeering;

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

// @public
export type ExpressRouteCrossConnectionPeeringsListNextResponse = ExpressRouteCrossConnectionPeeringList;

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

// @public
export type ExpressRouteCrossConnectionPeeringsListResponse = ExpressRouteCrossConnectionPeeringList;

// @public
export interface ExpressRouteCrossConnectionRoutesTableSummary {
    asn?: number;
    neighbor?: string;
    stateOrPrefixesReceived?: string;
    upDown?: string;
}

// @public
export interface ExpressRouteCrossConnections {
    beginCreateOrUpdate(resourceGroupName: string, crossConnectionName: string, parameters: ExpressRouteCrossConnection, options?: ExpressRouteCrossConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCrossConnectionsCreateOrUpdateResponse>, ExpressRouteCrossConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, crossConnectionName: string, parameters: ExpressRouteCrossConnection, options?: ExpressRouteCrossConnectionsCreateOrUpdateOptionalParams): Promise<ExpressRouteCrossConnectionsCreateOrUpdateResponse>;
    beginListArpTable(resourceGroupName: string, crossConnectionName: string, peeringName: string, devicePath: string, options?: ExpressRouteCrossConnectionsListArpTableOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCrossConnectionsListArpTableResponse>, ExpressRouteCrossConnectionsListArpTableResponse>>;
    beginListArpTableAndWait(resourceGroupName: string, crossConnectionName: string, peeringName: string, devicePath: string, options?: ExpressRouteCrossConnectionsListArpTableOptionalParams): Promise<ExpressRouteCrossConnectionsListArpTableResponse>;
    beginListRoutesTable(resourceGroupName: string, crossConnectionName: string, peeringName: string, devicePath: string, options?: ExpressRouteCrossConnectionsListRoutesTableOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCrossConnectionsListRoutesTableResponse>, ExpressRouteCrossConnectionsListRoutesTableResponse>>;
    beginListRoutesTableAndWait(resourceGroupName: string, crossConnectionName: string, peeringName: string, devicePath: string, options?: ExpressRouteCrossConnectionsListRoutesTableOptionalParams): Promise<ExpressRouteCrossConnectionsListRoutesTableResponse>;
    beginListRoutesTableSummary(resourceGroupName: string, crossConnectionName: string, peeringName: string, devicePath: string, options?: ExpressRouteCrossConnectionsListRoutesTableSummaryOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteCrossConnectionsListRoutesTableSummaryResponse>, ExpressRouteCrossConnectionsListRoutesTableSummaryResponse>>;
    beginListRoutesTableSummaryAndWait(resourceGroupName: string, crossConnectionName: string, peeringName: string, devicePath: string, options?: ExpressRouteCrossConnectionsListRoutesTableSummaryOptionalParams): Promise<ExpressRouteCrossConnectionsListRoutesTableSummaryResponse>;
    get(resourceGroupName: string, crossConnectionName: string, options?: ExpressRouteCrossConnectionsGetOptionalParams): Promise<ExpressRouteCrossConnectionsGetResponse>;
    list(options?: ExpressRouteCrossConnectionsListOptionalParams): PagedAsyncIterableIterator<ExpressRouteCrossConnection>;
    listByResourceGroup(resourceGroupName: string, options?: ExpressRouteCrossConnectionsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ExpressRouteCrossConnection>;
    updateTags(resourceGroupName: string, crossConnectionName: string, crossConnectionParameters: TagsObject, options?: ExpressRouteCrossConnectionsUpdateTagsOptionalParams): Promise<ExpressRouteCrossConnectionsUpdateTagsResponse>;
}

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

// @public
export type ExpressRouteCrossConnectionsCreateOrUpdateResponse = ExpressRouteCrossConnection;

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

// @public
export type ExpressRouteCrossConnectionsGetResponse = ExpressRouteCrossConnection;

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

// @public
export type ExpressRouteCrossConnectionsListArpTableResponse = ExpressRouteCircuitsArpTableListResult;

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

// @public
export type ExpressRouteCrossConnectionsListByResourceGroupNextResponse = ExpressRouteCrossConnectionListResult;

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

// @public
export type ExpressRouteCrossConnectionsListByResourceGroupResponse = ExpressRouteCrossConnectionListResult;

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

// @public
export type ExpressRouteCrossConnectionsListNextResponse = ExpressRouteCrossConnectionListResult;

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

// @public
export type ExpressRouteCrossConnectionsListResponse = ExpressRouteCrossConnectionListResult;

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

// @public
export type ExpressRouteCrossConnectionsListRoutesTableResponse = ExpressRouteCircuitsRoutesTableListResult;

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

// @public
export type ExpressRouteCrossConnectionsListRoutesTableSummaryResponse = ExpressRouteCrossConnectionsRoutesTableSummaryListResult;

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

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

// @public
export type ExpressRouteCrossConnectionsUpdateTagsResponse = ExpressRouteCrossConnection;

// @public (undocumented)
export interface ExpressRouteFailoverCircuitResourceDetails {
    connectionName?: string;
    name?: string;
    nrpResourceUri?: string;
}

// @public (undocumented)
export interface ExpressRouteFailoverConnectionResourceDetails {
    lastUpdatedTime?: string;
    name?: string;
    nrpResourceUri?: string;
    status?: FailoverConnectionStatus;
}

// @public (undocumented)
export interface ExpressRouteFailoverRedundantRoute {
    peeringLocations?: string[];
    routes?: string[];
}

// @public
export interface ExpressRouteFailoverSingleTestDetails {
    endTimeUtc?: string;
    failoverConnectionDetails?: FailoverConnectionDetails[];
    nonRedundantRoutes?: string[];
    peeringLocation?: string;
    redundantRoutes?: ExpressRouteFailoverRedundantRoute[];
    startTimeUtc?: string;
    status?: FailoverTestStatusForSingleTest;
    wasSimulationSuccessful?: boolean;
}

// @public
export interface ExpressRouteFailoverStopApiParameters {
    details?: FailoverConnectionDetails[];
    peeringLocation?: string;
    wasSimulationSuccessful?: boolean;
}

// @public
export interface ExpressRouteFailoverTestDetails {
    circuits?: ExpressRouteFailoverCircuitResourceDetails[];
    connections?: ExpressRouteFailoverConnectionResourceDetails[];
    endTime?: string;
    issues?: string[];
    peeringLocation?: string;
    startTime?: string;
    status?: FailoverTestStatus;
    testGuid?: string;
    testType?: FailoverTestType;
}

// @public
export interface ExpressRouteGateway extends Resource {
    allowNonVirtualWanTraffic?: boolean;
    autoScaleConfiguration?: ExpressRouteGatewayPropertiesAutoScaleConfiguration;
    readonly etag?: string;
    expressRouteConnections?: ExpressRouteConnection[];
    readonly provisioningState?: ProvisioningState;
    virtualHub?: VirtualHubId;
}

// @public
export interface ExpressRouteGatewayList {
    value?: ExpressRouteGateway[];
}

// @public
export interface ExpressRouteGatewayPropertiesAutoScaleConfiguration {
    bounds?: ExpressRouteGatewayPropertiesAutoScaleConfigurationBounds;
}

// @public
export interface ExpressRouteGatewayPropertiesAutoScaleConfigurationBounds {
    max?: number;
    min?: number;
}

// @public
export interface ExpressRouteGateways {
    beginCreateOrUpdate(resourceGroupName: string, expressRouteGatewayName: string, putExpressRouteGatewayParameters: ExpressRouteGateway, options?: ExpressRouteGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteGatewaysCreateOrUpdateResponse>, ExpressRouteGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, expressRouteGatewayName: string, putExpressRouteGatewayParameters: ExpressRouteGateway, options?: ExpressRouteGatewaysCreateOrUpdateOptionalParams): Promise<ExpressRouteGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, expressRouteGatewayName: string, options?: ExpressRouteGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, expressRouteGatewayName: string, options?: ExpressRouteGatewaysDeleteOptionalParams): Promise<void>;
    beginUpdateTags(resourceGroupName: string, expressRouteGatewayName: string, expressRouteGatewayParameters: TagsObject, options?: ExpressRouteGatewaysUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRouteGatewaysUpdateTagsResponse>, ExpressRouteGatewaysUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, expressRouteGatewayName: string, expressRouteGatewayParameters: TagsObject, options?: ExpressRouteGatewaysUpdateTagsOptionalParams): Promise<ExpressRouteGatewaysUpdateTagsResponse>;
    get(resourceGroupName: string, expressRouteGatewayName: string, options?: ExpressRouteGatewaysGetOptionalParams): Promise<ExpressRouteGatewaysGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: ExpressRouteGatewaysListByResourceGroupOptionalParams): Promise<ExpressRouteGatewaysListByResourceGroupResponse>;
    listBySubscription(options?: ExpressRouteGatewaysListBySubscriptionOptionalParams): Promise<ExpressRouteGatewaysListBySubscriptionResponse>;
}

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

// @public
export type ExpressRouteGatewaysCreateOrUpdateResponse = ExpressRouteGateway;

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

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

// @public
export type ExpressRouteGatewaysGetResponse = ExpressRouteGateway;

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

// @public
export type ExpressRouteGatewaysListByResourceGroupResponse = ExpressRouteGatewayList;

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

// @public
export type ExpressRouteGatewaysListBySubscriptionResponse = ExpressRouteGatewayList;

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

// @public
export type ExpressRouteGatewaysUpdateTagsResponse = ExpressRouteGateway;

// @public
export interface ExpressRouteLink extends SubResource {
    adminState?: ExpressRouteLinkAdminState;
    readonly coloLocation?: string;
    readonly connectorType?: ExpressRouteLinkConnectorType;
    readonly etag?: string;
    readonly interfaceName?: string;
    macSecConfig?: ExpressRouteLinkMacSecConfig;
    name?: string;
    readonly patchPanelId?: string;
    readonly provisioningState?: ProvisioningState;
    readonly rackId?: string;
    readonly routerName?: string;
}

// @public
export type ExpressRouteLinkAdminState = string;

// @public
export type ExpressRouteLinkConnectorType = string;

// @public
export interface ExpressRouteLinkListResult {
    nextLink?: string;
    value?: ExpressRouteLink[];
}

// @public
export type ExpressRouteLinkMacSecCipher = string;

// @public
export interface ExpressRouteLinkMacSecConfig {
    cakSecretIdentifier?: string;
    cipher?: ExpressRouteLinkMacSecCipher;
    cknSecretIdentifier?: string;
    sciState?: ExpressRouteLinkMacSecSciState;
}

// @public
export type ExpressRouteLinkMacSecSciState = string;

// @public
export interface ExpressRouteLinks {
    get(resourceGroupName: string, expressRoutePortName: string, linkName: string, options?: ExpressRouteLinksGetOptionalParams): Promise<ExpressRouteLinksGetResponse>;
    list(resourceGroupName: string, expressRoutePortName: string, options?: ExpressRouteLinksListOptionalParams): PagedAsyncIterableIterator<ExpressRouteLink>;
}

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

// @public
export type ExpressRouteLinksGetResponse = ExpressRouteLink;

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

// @public
export type ExpressRouteLinksListNextResponse = ExpressRouteLinkListResult;

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

// @public
export type ExpressRouteLinksListResponse = ExpressRouteLinkListResult;

// @public
export type ExpressRoutePeeringState = string;

// @public
export type ExpressRoutePeeringType = string;

// @public
export interface ExpressRoutePort extends Resource {
    readonly allocationDate?: string;
    bandwidthInGbps?: number;
    billingType?: ExpressRoutePortsBillingType;
    readonly circuits?: SubResource[];
    encapsulation?: ExpressRoutePortsEncapsulation;
    readonly etag?: string;
    readonly etherType?: string;
    identity?: ManagedServiceIdentity;
    links?: ExpressRouteLink[];
    readonly mtu?: string;
    peeringLocation?: string;
    readonly provisionedBandwidthInGbps?: number;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

// @public
export interface ExpressRoutePortAuthorization extends SubResource {
    readonly authorizationKey?: string;
    readonly authorizationUseStatus?: ExpressRoutePortAuthorizationUseStatus;
    readonly circuitResourceUri?: string;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ExpressRoutePortAuthorizationListResult {
    nextLink?: string;
    value?: ExpressRoutePortAuthorization[];
}

// @public
export interface ExpressRoutePortAuthorizations {
    beginCreateOrUpdate(resourceGroupName: string, expressRoutePortName: string, authorizationName: string, authorizationParameters: ExpressRoutePortAuthorization, options?: ExpressRoutePortAuthorizationsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRoutePortAuthorizationsCreateOrUpdateResponse>, ExpressRoutePortAuthorizationsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, expressRoutePortName: string, authorizationName: string, authorizationParameters: ExpressRoutePortAuthorization, options?: ExpressRoutePortAuthorizationsCreateOrUpdateOptionalParams): Promise<ExpressRoutePortAuthorizationsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, expressRoutePortName: string, authorizationName: string, options?: ExpressRoutePortAuthorizationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, expressRoutePortName: string, authorizationName: string, options?: ExpressRoutePortAuthorizationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, expressRoutePortName: string, authorizationName: string, options?: ExpressRoutePortAuthorizationsGetOptionalParams): Promise<ExpressRoutePortAuthorizationsGetResponse>;
    list(resourceGroupName: string, expressRoutePortName: string, options?: ExpressRoutePortAuthorizationsListOptionalParams): PagedAsyncIterableIterator<ExpressRoutePortAuthorization>;
}

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

// @public
export type ExpressRoutePortAuthorizationsCreateOrUpdateResponse = ExpressRoutePortAuthorization;

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

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

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

// @public
export type ExpressRoutePortAuthorizationsGetResponse = ExpressRoutePortAuthorization;

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

// @public
export type ExpressRoutePortAuthorizationsListNextResponse = ExpressRoutePortAuthorizationListResult;

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

// @public
export type ExpressRoutePortAuthorizationsListResponse = ExpressRoutePortAuthorizationListResult;

// @public
export type ExpressRoutePortAuthorizationUseStatus = string;

// @public
export interface ExpressRoutePortListResult {
    nextLink?: string;
    value?: ExpressRoutePort[];
}

// @public
export interface ExpressRoutePorts {
    beginCreateOrUpdate(resourceGroupName: string, expressRoutePortName: string, parameters: ExpressRoutePort, options?: ExpressRoutePortsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExpressRoutePortsCreateOrUpdateResponse>, ExpressRoutePortsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, expressRoutePortName: string, parameters: ExpressRoutePort, options?: ExpressRoutePortsCreateOrUpdateOptionalParams): Promise<ExpressRoutePortsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, expressRoutePortName: string, options?: ExpressRoutePortsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, expressRoutePortName: string, options?: ExpressRoutePortsDeleteOptionalParams): Promise<void>;
    generateLOA(resourceGroupName: string, expressRoutePortName: string, request: GenerateExpressRoutePortsLOARequest, options?: ExpressRoutePortsGenerateLOAOptionalParams): Promise<ExpressRoutePortsGenerateLOAResponse>;
    get(resourceGroupName: string, expressRoutePortName: string, options?: ExpressRoutePortsGetOptionalParams): Promise<ExpressRoutePortsGetResponse>;
    list(options?: ExpressRoutePortsListOptionalParams): PagedAsyncIterableIterator<ExpressRoutePort>;
    listByResourceGroup(resourceGroupName: string, options?: ExpressRoutePortsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ExpressRoutePort>;
    updateTags(resourceGroupName: string, expressRoutePortName: string, parameters: TagsObject, options?: ExpressRoutePortsUpdateTagsOptionalParams): Promise<ExpressRoutePortsUpdateTagsResponse>;
}

// @public
export type ExpressRoutePortsBillingType = string;

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

// @public
export type ExpressRoutePortsCreateOrUpdateResponse = ExpressRoutePort;

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

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

// @public
export type ExpressRoutePortsEncapsulation = string;

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

// @public
export type ExpressRoutePortsGenerateLOAResponse = GenerateExpressRoutePortsLOAResult;

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

// @public
export type ExpressRoutePortsGetResponse = ExpressRoutePort;

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

// @public
export type ExpressRoutePortsListByResourceGroupNextResponse = ExpressRoutePortListResult;

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

// @public
export type ExpressRoutePortsListByResourceGroupResponse = ExpressRoutePortListResult;

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

// @public
export type ExpressRoutePortsListNextResponse = ExpressRoutePortListResult;

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

// @public
export type ExpressRoutePortsListResponse = ExpressRoutePortListResult;

// @public
export interface ExpressRoutePortsLocation extends Resource {
    readonly address?: string;
    availableBandwidths?: ExpressRoutePortsLocationBandwidths[];
    readonly contact?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface ExpressRoutePortsLocationBandwidths {
    readonly offerName?: string;
    readonly valueInGbps?: number;
}

// @public
export interface ExpressRoutePortsLocationListResult {
    nextLink?: string;
    value?: ExpressRoutePortsLocation[];
}

// @public
export interface ExpressRoutePortsLocations {
    get(locationName: string, options?: ExpressRoutePortsLocationsGetOptionalParams): Promise<ExpressRoutePortsLocationsGetResponse>;
    list(options?: ExpressRoutePortsLocationsListOptionalParams): PagedAsyncIterableIterator<ExpressRoutePortsLocation>;
}

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

// @public
export type ExpressRoutePortsLocationsGetResponse = ExpressRoutePortsLocation;

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

// @public
export type ExpressRoutePortsLocationsListNextResponse = ExpressRoutePortsLocationListResult;

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

// @public
export type ExpressRoutePortsLocationsListResponse = ExpressRoutePortsLocationListResult;

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

// @public
export type ExpressRoutePortsUpdateTagsResponse = ExpressRoutePort;

// @public
export interface ExpressRouteProviderPort extends Resource {
    readonly etag?: string;
    overprovisionFactor?: number;
    peeringLocation?: string;
    portBandwidthInMbps?: number;
    readonly portPairDescriptor?: string;
    readonly primaryAzurePort?: string;
    remainingBandwidthInMbps?: number;
    readonly secondaryAzurePort?: string;
    usedBandwidthInMbps?: number;
}

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

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

// @public
export type ExpressRouteProviderPortResponse = ExpressRouteProviderPort;

// @public
export interface ExpressRouteProviderPortsLocation {
    list(options?: ExpressRouteProviderPortsLocationListOptionalParams): Promise<ExpressRouteProviderPortsLocationListResponse>;
}

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

// @public
export type ExpressRouteProviderPortsLocationListResponse = ExpressRouteProviderPortListResult;

// @public
export interface ExpressRouteServiceProvider extends Resource {
    bandwidthsOffered?: ExpressRouteServiceProviderBandwidthsOffered[];
    peeringLocations?: string[];
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface ExpressRouteServiceProviderBandwidthsOffered {
    offerName?: string;
    valueInMbps?: number;
}

// @public
export interface ExpressRouteServiceProviderListResult {
    nextLink?: string;
    value?: ExpressRouteServiceProvider[];
}

// @public
export interface ExpressRouteServiceProviders {
    list(options?: ExpressRouteServiceProvidersListOptionalParams): PagedAsyncIterableIterator<ExpressRouteServiceProvider>;
}

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

// @public
export type ExpressRouteServiceProvidersListNextResponse = ExpressRouteServiceProviderListResult;

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

// @public
export type ExpressRouteServiceProvidersListResponse = ExpressRouteServiceProviderListResult;

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

// @public
export type ExtendedLocationTypes = string;

// @public (undocumented)
export interface FailoverConnectionDetails {
    failoverConnectionName?: string;
    failoverLocation?: string;
    isVerified?: boolean;
}

// @public
export type FailoverConnectionStatus = string;

// @public
export type FailoverTestStatus = string;

// @public
export type FailoverTestStatusForSingleTest = string;

// @public
export type FailoverTestType = string;

// @public
export interface FilterItems {
    field?: string;
    values?: string[];
}

// @public
export interface FirewallPacketCaptureParameters {
    durationInSeconds?: number;
    fileName?: string;
    filters?: AzureFirewallPacketCaptureRule[];
    flags?: AzureFirewallPacketCaptureFlags[];
    numberOfPacketsToCapture?: number;
    protocol?: AzureFirewallNetworkRuleProtocol;
    sasUrl?: string;
}

// @public
export interface FirewallPolicies {
    beginCreateOrUpdate(resourceGroupName: string, firewallPolicyName: string, parameters: FirewallPolicy, options?: FirewallPoliciesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<FirewallPoliciesCreateOrUpdateResponse>, FirewallPoliciesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, firewallPolicyName: string, parameters: FirewallPolicy, options?: FirewallPoliciesCreateOrUpdateOptionalParams): Promise<FirewallPoliciesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPoliciesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPoliciesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPoliciesGetOptionalParams): Promise<FirewallPoliciesGetResponse>;
    list(resourceGroupName: string, options?: FirewallPoliciesListOptionalParams): PagedAsyncIterableIterator<FirewallPolicy>;
    listAll(options?: FirewallPoliciesListAllOptionalParams): PagedAsyncIterableIterator<FirewallPolicy>;
    updateTags(resourceGroupName: string, firewallPolicyName: string, parameters: TagsObject, options?: FirewallPoliciesUpdateTagsOptionalParams): Promise<FirewallPoliciesUpdateTagsResponse>;
}

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

// @public
export type FirewallPoliciesCreateOrUpdateResponse = FirewallPolicy;

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

// @public
export interface FirewallPoliciesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type FirewallPoliciesGetResponse = FirewallPolicy;

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

// @public
export type FirewallPoliciesListAllNextResponse = FirewallPolicyListResult;

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

// @public
export type FirewallPoliciesListAllResponse = FirewallPolicyListResult;

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

// @public
export type FirewallPoliciesListNextResponse = FirewallPolicyListResult;

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

// @public
export type FirewallPoliciesListResponse = FirewallPolicyListResult;

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

// @public
export type FirewallPoliciesUpdateTagsResponse = FirewallPolicy;

// @public
export interface FirewallPolicy extends Resource {
    basePolicy?: SubResource;
    readonly childPolicies?: SubResource[];
    dnsSettings?: DnsSettings;
    readonly etag?: string;
    explicitProxy?: ExplicitProxy;
    readonly firewalls?: SubResource[];
    identity?: ManagedServiceIdentity;
    insights?: FirewallPolicyInsights;
    intrusionDetection?: FirewallPolicyIntrusionDetection;
    readonly provisioningState?: ProvisioningState;
    readonly ruleCollectionGroups?: SubResource[];
    readonly size?: string;
    sku?: FirewallPolicySku;
    snat?: FirewallPolicySnat;
    sql?: FirewallPolicySQL;
    threatIntelMode?: AzureFirewallThreatIntelMode;
    threatIntelWhitelist?: FirewallPolicyThreatIntelWhitelist;
    transportSecurity?: FirewallPolicyTransportSecurity;
}

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

// @public
export interface FirewallPolicyDeployments {
    beginDeploy(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyDeploymentsDeployOptionalParams): Promise<SimplePollerLike<OperationState<FirewallPolicyDeploymentsDeployResponse>, FirewallPolicyDeploymentsDeployResponse>>;
    beginDeployAndWait(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyDeploymentsDeployOptionalParams): Promise<FirewallPolicyDeploymentsDeployResponse>;
}

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

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

// @public
export type FirewallPolicyDeploymentsDeployResponse = FirewallPolicyDeploymentsDeployHeaders;

// @public
export interface FirewallPolicyDraft extends Resource {
    basePolicy?: SubResource;
    dnsSettings?: DnsSettings;
    explicitProxy?: ExplicitProxy;
    insights?: FirewallPolicyInsights;
    intrusionDetection?: FirewallPolicyIntrusionDetection;
    snat?: FirewallPolicySnat;
    sql?: FirewallPolicySQL;
    threatIntelMode?: AzureFirewallThreatIntelMode;
    threatIntelWhitelist?: FirewallPolicyThreatIntelWhitelist;
}

// @public
export interface FirewallPolicyDrafts {
    createOrUpdate(resourceGroupName: string, firewallPolicyName: string, parameters: FirewallPolicyDraft, options?: FirewallPolicyDraftsCreateOrUpdateOptionalParams): Promise<FirewallPolicyDraftsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyDraftsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyDraftsGetOptionalParams): Promise<FirewallPolicyDraftsGetResponse>;
}

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

// @public
export type FirewallPolicyDraftsCreateOrUpdateResponse = FirewallPolicyDraft;

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

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

// @public
export type FirewallPolicyDraftsGetResponse = FirewallPolicyDraft;

// @public
export interface FirewallPolicyFilterRuleCollection extends FirewallPolicyRuleCollection {
    action?: FirewallPolicyFilterRuleCollectionAction;
    ruleCollectionType: "FirewallPolicyFilterRuleCollection";
    rules?: FirewallPolicyRuleUnion[];
}

// @public
export interface FirewallPolicyFilterRuleCollectionAction {
    type?: FirewallPolicyFilterRuleCollectionActionType;
}

// @public
export type FirewallPolicyFilterRuleCollectionActionType = string;

// @public
export interface FirewallPolicyHttpHeaderToInsert {
    headerName?: string;
    headerValue?: string;
}

// @public
export type FirewallPolicyIdpsQuerySortOrder = string;

// @public
export type FirewallPolicyIdpsSignatureDirection = 0 | 1 | 2 | 3 | 4 | 5;

// @public
export type FirewallPolicyIdpsSignatureMode = 0 | 1 | 2;

// @public
export interface FirewallPolicyIdpsSignatures {
    list(resourceGroupName: string, firewallPolicyName: string, parameters: IdpsQueryObject, options?: FirewallPolicyIdpsSignaturesListOptionalParams): Promise<FirewallPolicyIdpsSignaturesListResponse>;
}

// @public
export type FirewallPolicyIdpsSignatureSeverity = 1 | 2 | 3;

// @public
export interface FirewallPolicyIdpsSignaturesFilterValues {
    list(resourceGroupName: string, firewallPolicyName: string, parameters: SignatureOverridesFilterValuesQuery, options?: FirewallPolicyIdpsSignaturesFilterValuesListOptionalParams): Promise<FirewallPolicyIdpsSignaturesFilterValuesListResponse>;
}

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

// @public
export type FirewallPolicyIdpsSignaturesFilterValuesListResponse = SignatureOverridesFilterValuesResponse;

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

// @public
export type FirewallPolicyIdpsSignaturesListResponse = QueryResults;

// @public
export interface FirewallPolicyIdpsSignaturesOverrides {
    get(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyIdpsSignaturesOverridesGetOptionalParams): Promise<FirewallPolicyIdpsSignaturesOverridesGetResponse>;
    list(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyIdpsSignaturesOverridesListOptionalParams): Promise<FirewallPolicyIdpsSignaturesOverridesListResponse>;
    patch(resourceGroupName: string, firewallPolicyName: string, parameters: SignaturesOverrides, options?: FirewallPolicyIdpsSignaturesOverridesPatchOptionalParams): Promise<FirewallPolicyIdpsSignaturesOverridesPatchResponse>;
    put(resourceGroupName: string, firewallPolicyName: string, parameters: SignaturesOverrides, options?: FirewallPolicyIdpsSignaturesOverridesPutOptionalParams): Promise<FirewallPolicyIdpsSignaturesOverridesPutResponse>;
}

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

// @public
export type FirewallPolicyIdpsSignaturesOverridesGetResponse = SignaturesOverrides;

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

// @public
export type FirewallPolicyIdpsSignaturesOverridesListResponse = SignaturesOverridesList;

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

// @public
export type FirewallPolicyIdpsSignaturesOverridesPatchResponse = SignaturesOverrides;

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

// @public
export type FirewallPolicyIdpsSignaturesOverridesPutResponse = SignaturesOverrides;

// @public
export interface FirewallPolicyInsights {
    isEnabled?: boolean;
    logAnalyticsResources?: FirewallPolicyLogAnalyticsResources;
    retentionDays?: number;
}

// @public
export interface FirewallPolicyIntrusionDetection {
    configuration?: FirewallPolicyIntrusionDetectionConfiguration;
    mode?: FirewallPolicyIntrusionDetectionStateType;
    profile?: FirewallPolicyIntrusionDetectionProfileType;
}

// @public
export interface FirewallPolicyIntrusionDetectionBypassTrafficSpecifications {
    description?: string;
    destinationAddresses?: string[];
    destinationIpGroups?: string[];
    destinationPorts?: string[];
    name?: string;
    protocol?: FirewallPolicyIntrusionDetectionProtocol;
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
}

// @public
export interface FirewallPolicyIntrusionDetectionConfiguration {
    bypassTrafficSettings?: FirewallPolicyIntrusionDetectionBypassTrafficSpecifications[];
    privateRanges?: string[];
    signatureOverrides?: FirewallPolicyIntrusionDetectionSignatureSpecification[];
}

// @public
export type FirewallPolicyIntrusionDetectionProfileType = string;

// @public
export type FirewallPolicyIntrusionDetectionProtocol = string;

// @public
export interface FirewallPolicyIntrusionDetectionSignatureSpecification {
    id?: string;
    mode?: FirewallPolicyIntrusionDetectionStateType;
}

// @public
export type FirewallPolicyIntrusionDetectionStateType = string;

// @public
export interface FirewallPolicyListResult {
    nextLink?: string;
    value?: FirewallPolicy[];
}

// @public
export interface FirewallPolicyLogAnalyticsResources {
    defaultWorkspaceId?: SubResource;
    workspaces?: FirewallPolicyLogAnalyticsWorkspace[];
}

// @public
export interface FirewallPolicyLogAnalyticsWorkspace {
    region?: string;
    workspaceId?: SubResource;
}

// @public
export interface FirewallPolicyNatRuleCollection extends FirewallPolicyRuleCollection {
    action?: FirewallPolicyNatRuleCollectionAction;
    ruleCollectionType: "FirewallPolicyNatRuleCollection";
    rules?: FirewallPolicyRuleUnion[];
}

// @public
export interface FirewallPolicyNatRuleCollectionAction {
    type?: FirewallPolicyNatRuleCollectionActionType;
}

// @public
export type FirewallPolicyNatRuleCollectionActionType = string;

// @public
export interface FirewallPolicyRule {
    description?: string;
    name?: string;
    ruleType: "ApplicationRule" | "NatRule" | "NetworkRule";
}

// @public
export interface FirewallPolicyRuleApplicationProtocol {
    port?: number;
    protocolType?: FirewallPolicyRuleApplicationProtocolType;
}

// @public
export type FirewallPolicyRuleApplicationProtocolType = string;

// @public
export interface FirewallPolicyRuleCollection {
    name?: string;
    priority?: number;
    ruleCollectionType: "FirewallPolicyNatRuleCollection" | "FirewallPolicyFilterRuleCollection";
}

// @public
export interface FirewallPolicyRuleCollectionGroup extends SubResource {
    readonly etag?: string;
    name?: string;
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    ruleCollections?: FirewallPolicyRuleCollectionUnion[];
    readonly size?: string;
    readonly type?: string;
}

// @public
export interface FirewallPolicyRuleCollectionGroupDraft extends SubResource {
    name?: string;
    priority?: number;
    ruleCollections?: FirewallPolicyRuleCollectionUnion[];
    readonly size?: string;
    readonly type?: string;
}

// @public
export interface FirewallPolicyRuleCollectionGroupDrafts {
    createOrUpdate(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, parameters: FirewallPolicyRuleCollectionGroupDraft, options?: FirewallPolicyRuleCollectionGroupDraftsCreateOrUpdateOptionalParams): Promise<FirewallPolicyRuleCollectionGroupDraftsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, options?: FirewallPolicyRuleCollectionGroupDraftsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, options?: FirewallPolicyRuleCollectionGroupDraftsGetOptionalParams): Promise<FirewallPolicyRuleCollectionGroupDraftsGetResponse>;
}

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

// @public
export type FirewallPolicyRuleCollectionGroupDraftsCreateOrUpdateResponse = FirewallPolicyRuleCollectionGroupDraft;

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

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

// @public
export type FirewallPolicyRuleCollectionGroupDraftsGetResponse = FirewallPolicyRuleCollectionGroupDraft;

// @public
export interface FirewallPolicyRuleCollectionGroupListResult {
    nextLink?: string;
    value?: FirewallPolicyRuleCollectionGroup[];
}

// @public
export interface FirewallPolicyRuleCollectionGroups {
    beginCreateOrUpdate(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, parameters: FirewallPolicyRuleCollectionGroup, options?: FirewallPolicyRuleCollectionGroupsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<FirewallPolicyRuleCollectionGroupsCreateOrUpdateResponse>, FirewallPolicyRuleCollectionGroupsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, parameters: FirewallPolicyRuleCollectionGroup, options?: FirewallPolicyRuleCollectionGroupsCreateOrUpdateOptionalParams): Promise<FirewallPolicyRuleCollectionGroupsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, options?: FirewallPolicyRuleCollectionGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, options?: FirewallPolicyRuleCollectionGroupsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, firewallPolicyName: string, ruleCollectionGroupName: string, options?: FirewallPolicyRuleCollectionGroupsGetOptionalParams): Promise<FirewallPolicyRuleCollectionGroupsGetResponse>;
    list(resourceGroupName: string, firewallPolicyName: string, options?: FirewallPolicyRuleCollectionGroupsListOptionalParams): PagedAsyncIterableIterator<FirewallPolicyRuleCollectionGroup>;
}

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

// @public
export type FirewallPolicyRuleCollectionGroupsCreateOrUpdateResponse = FirewallPolicyRuleCollectionGroup;

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

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

// @public
export type FirewallPolicyRuleCollectionGroupsGetResponse = FirewallPolicyRuleCollectionGroup;

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

// @public
export type FirewallPolicyRuleCollectionGroupsListNextResponse = FirewallPolicyRuleCollectionGroupListResult;

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

// @public
export type FirewallPolicyRuleCollectionGroupsListResponse = FirewallPolicyRuleCollectionGroupListResult;

// @public
export type FirewallPolicyRuleCollectionType = string;

// @public (undocumented)
export type FirewallPolicyRuleCollectionUnion = FirewallPolicyRuleCollection | FirewallPolicyNatRuleCollection | FirewallPolicyFilterRuleCollection;

// @public
export type FirewallPolicyRuleNetworkProtocol = string;

// @public
export type FirewallPolicyRuleType = string;

// @public (undocumented)
export type FirewallPolicyRuleUnion = FirewallPolicyRule | ApplicationRule | NatRule | NetworkRule;

// @public
export interface FirewallPolicySku {
    tier?: FirewallPolicySkuTier;
}

// @public
export type FirewallPolicySkuTier = string;

// @public
export interface FirewallPolicySnat {
    autoLearnPrivateRanges?: AutoLearnPrivateRangesMode;
    privateRanges?: string[];
}

// @public
export interface FirewallPolicySQL {
    allowSqlRedirect?: boolean;
}

// @public
export interface FirewallPolicyThreatIntelWhitelist {
    fqdns?: string[];
    ipAddresses?: string[];
}

// @public
export interface FirewallPolicyTransportSecurity {
    certificateAuthority?: FirewallPolicyCertificateAuthority;
}

// @public
export interface FlowLog extends Resource {
    enabled?: boolean;
    enabledFilteringCriteria?: string;
    readonly etag?: string;
    flowAnalyticsConfiguration?: TrafficAnalyticsProperties;
    format?: FlowLogFormatParameters;
    identity?: ManagedServiceIdentity;
    readonly provisioningState?: ProvisioningState;
    retentionPolicy?: RetentionPolicyParameters;
    storageId?: string;
    readonly targetResourceGuid?: string;
    targetResourceId?: string;
}

// @public
export interface FlowLogFormatParameters {
    type?: FlowLogFormatType;
    version?: number;
}

// @public
export type FlowLogFormatType = string;

// @public
export interface FlowLogInformation {
    enabled: boolean;
    enabledFilteringCriteria?: string;
    flowAnalyticsConfiguration?: TrafficAnalyticsProperties;
    format?: FlowLogFormatParameters;
    identity?: ManagedServiceIdentity;
    retentionPolicy?: RetentionPolicyParameters;
    storageId: string;
    targetResourceId: string;
}

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

// @public
export interface FlowLogs {
    beginCreateOrUpdate(resourceGroupName: string, networkWatcherName: string, flowLogName: string, parameters: FlowLog, options?: FlowLogsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<FlowLogsCreateOrUpdateResponse>, FlowLogsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkWatcherName: string, flowLogName: string, parameters: FlowLog, options?: FlowLogsCreateOrUpdateOptionalParams): Promise<FlowLogsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkWatcherName: string, flowLogName: string, options?: FlowLogsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkWatcherName: string, flowLogName: string, options?: FlowLogsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkWatcherName: string, flowLogName: string, options?: FlowLogsGetOptionalParams): Promise<FlowLogsGetResponse>;
    list(resourceGroupName: string, networkWatcherName: string, options?: FlowLogsListOptionalParams): PagedAsyncIterableIterator<FlowLog>;
    updateTags(resourceGroupName: string, networkWatcherName: string, flowLogName: string, parameters: TagsObject, options?: FlowLogsUpdateTagsOptionalParams): Promise<FlowLogsUpdateTagsResponse>;
}

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

// @public
export type FlowLogsCreateOrUpdateResponse = FlowLog;

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

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

// @public
export type FlowLogsGetResponse = FlowLog;

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

// @public
export type FlowLogsListNextResponse = FlowLogListResult;

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

// @public
export type FlowLogsListResponse = FlowLogListResult;

// @public
export interface FlowLogStatusParameters {
    targetResourceId: string;
}

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

// @public
export type FlowLogsUpdateTagsResponse = FlowLog;

// @public
export interface FrontendIPConfiguration extends SubResource {
    readonly etag?: string;
    gatewayLoadBalancer?: SubResource;
    readonly inboundNatPools?: SubResource[];
    readonly inboundNatRules?: SubResource[];
    readonly loadBalancingRules?: SubResource[];
    name?: string;
    readonly outboundRules?: SubResource[];
    privateIPAddress?: string;
    privateIPAddressVersion?: IPVersion;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: PublicIPAddress;
    publicIPPrefix?: SubResource;
    subnet?: Subnet;
    readonly type?: string;
    zones?: string[];
}

// @public
export interface GatewayCustomBgpIpAddressIpConfiguration {
    customBgpIpAddress: string;
    ipConfigurationId: string;
}

// @public
export interface GatewayLoadBalancerTunnelInterface {
    identifier?: number;
    port?: number;
    protocol?: GatewayLoadBalancerTunnelProtocol;
    type?: GatewayLoadBalancerTunnelInterfaceType;
}

// @public
export type GatewayLoadBalancerTunnelInterfaceType = string;

// @public
export type GatewayLoadBalancerTunnelProtocol = string;

// @public
export interface GatewayResiliencyInformation {
    components?: ResiliencyRecommendationComponents[];
    lastComputedTime?: Date;
    maxScoreFromRecommendations?: string;
    minScoreFromRecommendations?: string;
    nextEligibleComputeTime?: Date;
    overallScore?: string;
    scoreChange?: string;
}

// @public
export interface GatewayResiliencyRecommendation {
    callToActionLink?: string;
    callToActionText?: string;
    recommendationId?: string;
    recommendationText?: string;
    recommendationTitle?: string;
    severity?: string;
}

// @public
export interface GatewayRoute {
    readonly asPath?: string;
    readonly localAddress?: string;
    readonly network?: string;
    readonly nextHop?: string;
    readonly origin?: string;
    readonly sourcePeer?: string;
    readonly weight?: number;
}

// @public
export interface GatewayRouteListResult {
    value?: GatewayRoute[];
}

// @public (undocumented)
export interface GatewayRouteSet {
    details?: {
        [propertyName: string]: RouteSourceDetails[];
    };
    locations?: string[];
    name?: string;
}

// @public
export interface GatewayRouteSetsInformation {
    circuitsMetadataMap?: {
        [propertyName: string]: CircuitMetadataMap;
    };
    lastComputedTime?: Date;
    nextEligibleComputeTime?: Date;
    routeSets?: GatewayRouteSet[];
    routeSetVersion?: string;
}

// @public
export interface GenerateExpressRoutePortsLOARequest {
    customerName: string;
}

// @public
export interface GenerateExpressRoutePortsLOAResult {
    encodedContent?: string;
}

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

// @public
export type GeneratevirtualwanvpnserverconfigurationvpnprofileResponse = VpnProfileResponse;

// @public
export type Geo = string;

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

// @public
export type GetActiveSessionsNextResponse = BastionActiveSessionListResult;

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

// @public
export type GetActiveSessionsResponse = BastionActiveSessionListResult;

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

// @public
export type GetBastionShareableLinkNextResponse = BastionShareableLinkListResult;

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

// @public
export type GetBastionShareableLinkResponse = BastionShareableLinkListResult;

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

// @public
export interface GetInboundRoutesParameters {
    connectionType?: string;
    resourceUri?: string;
}

// @public
export interface GetOutboundRoutesParameters {
    connectionType?: string;
    resourceUri?: string;
}

// @public
export interface GetVpnSitesConfigurationRequest {
    outputBlobSasUrl: string;
    vpnSites?: string[];
}

// @public
export interface GroupByUserSession {
    groupByVariables: GroupByVariable[];
}

// @public
export interface GroupByVariable {
    variableName: ApplicationGatewayFirewallUserSessionVariable;
}

// @public
export type GroupConnectivity = string;

// @public
export type GroupMemberType = string;

// @public
export interface HeaderValueMatcher {
    ignoreCase?: boolean;
    negate?: boolean;
    pattern?: string;
}

// @public
export interface HopLink {
    readonly context?: {
        [propertyName: string]: string;
    };
    readonly issues?: ConnectivityIssue[];
    readonly linkType?: string;
    readonly nextHopId?: string;
    readonly resourceId?: string;
    readonly roundTripTimeAvg?: number;
    readonly roundTripTimeMax?: number;
    readonly roundTripTimeMin?: number;
}

// @public
export interface HttpConfiguration {
    headers?: HttpHeader[];
    method?: HttpMethod;
    validStatusCodes?: number[];
}

// @public
export type HttpConfigurationMethod = string;

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

// @public
export type HttpMethod = string;

// @public
export interface Hub {
    resourceId?: string;
    resourceType?: string;
}

// @public
export type HubBgpConnectionStatus = string;

// @public
export interface HubIPAddresses {
    privateIPAddress?: string;
    publicIPs?: HubPublicIPAddresses;
}

// @public
export interface HubIpConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    privateIPAddress?: string;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: PublicIPAddress;
    subnet?: Subnet;
    readonly type?: string;
}

// @public
export interface HubPublicIPAddresses {
    addresses?: AzureFirewallPublicIPAddress[];
    count?: number;
}

// @public
export interface HubRoute {
    destinations: string[];
    destinationType: string;
    name: string;
    nextHop: string;
    nextHopType: string;
}

// @public
export interface HubRouteTable extends SubResource {
    readonly associatedConnections?: string[];
    readonly etag?: string;
    labels?: string[];
    name?: string;
    readonly propagatingConnections?: string[];
    readonly provisioningState?: ProvisioningState;
    routes?: HubRoute[];
    readonly type?: string;
}

// @public
export interface HubRouteTables {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, routeTableName: string, routeTableParameters: HubRouteTable, options?: HubRouteTablesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<HubRouteTablesCreateOrUpdateResponse>, HubRouteTablesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, routeTableName: string, routeTableParameters: HubRouteTable, options?: HubRouteTablesCreateOrUpdateOptionalParams): Promise<HubRouteTablesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, routeTableName: string, options?: HubRouteTablesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, routeTableName: string, options?: HubRouteTablesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, routeTableName: string, options?: HubRouteTablesGetOptionalParams): Promise<HubRouteTablesGetResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: HubRouteTablesListOptionalParams): PagedAsyncIterableIterator<HubRouteTable>;
}

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

// @public
export type HubRouteTablesCreateOrUpdateResponse = HubRouteTable;

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

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

// @public
export type HubRouteTablesGetResponse = HubRouteTable;

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

// @public
export type HubRouteTablesListNextResponse = ListHubRouteTablesResult;

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

// @public
export type HubRouteTablesListResponse = ListHubRouteTablesResult;

// @public
export type HubRoutingPreference = string;

// @public
export interface HubVirtualNetworkConnection extends SubResource {
    allowHubToRemoteVnetTransit?: boolean;
    allowRemoteVnetToUseHubVnetGateways?: boolean;
    enableInternetSecurity?: boolean;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    remoteVirtualNetwork?: SubResource;
    routingConfiguration?: RoutingConfiguration;
}

// @public
export interface HubVirtualNetworkConnections {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, connectionName: string, hubVirtualNetworkConnectionParameters: HubVirtualNetworkConnection, options?: HubVirtualNetworkConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<HubVirtualNetworkConnectionsCreateOrUpdateResponse>, HubVirtualNetworkConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, connectionName: string, hubVirtualNetworkConnectionParameters: HubVirtualNetworkConnection, options?: HubVirtualNetworkConnectionsCreateOrUpdateOptionalParams): Promise<HubVirtualNetworkConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, connectionName: string, options?: HubVirtualNetworkConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, connectionName: string, options?: HubVirtualNetworkConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, connectionName: string, options?: HubVirtualNetworkConnectionsGetOptionalParams): Promise<HubVirtualNetworkConnectionsGetResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: HubVirtualNetworkConnectionsListOptionalParams): PagedAsyncIterableIterator<HubVirtualNetworkConnection>;
}

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

// @public
export type HubVirtualNetworkConnectionsCreateOrUpdateResponse = HubVirtualNetworkConnection;

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

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

// @public
export type HubVirtualNetworkConnectionsGetResponse = HubVirtualNetworkConnection;

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

// @public
export type HubVirtualNetworkConnectionsListNextResponse = ListHubVirtualNetworkConnectionsResult;

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

// @public
export type HubVirtualNetworkConnectionsListResponse = ListHubVirtualNetworkConnectionsResult;

// @public
export type HubVirtualNetworkConnectionStatus = string;

// @public
export interface IdpsQueryObject {
    filters?: FilterItems[];
    orderBy?: OrderBy;
    resultsPerPage?: number;
    search?: string;
    skip?: number;
}

// @public
export type IkeEncryption = string;

// @public
export type IkeIntegrity = string;

// @public
export interface InboundNatPool extends SubResource {
    backendPort?: number;
    enableFloatingIP?: boolean;
    enableTcpReset?: boolean;
    readonly etag?: string;
    frontendIPConfiguration?: SubResource;
    frontendPortRangeEnd?: number;
    frontendPortRangeStart?: number;
    idleTimeoutInMinutes?: number;
    name?: string;
    protocol?: TransportProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface InboundNatRule extends SubResource {
    backendAddressPool?: SubResource;
    readonly backendIPConfiguration?: NetworkInterfaceIPConfiguration;
    backendPort?: number;
    enableFloatingIP?: boolean;
    enableTcpReset?: boolean;
    readonly etag?: string;
    frontendIPConfiguration?: SubResource;
    frontendPort?: number;
    frontendPortRangeEnd?: number;
    frontendPortRangeStart?: number;
    idleTimeoutInMinutes?: number;
    name?: string;
    protocol?: TransportProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

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

// @public
export interface InboundNatRulePortMapping {
    readonly backendPort?: number;
    readonly frontendPort?: number;
    readonly inboundNatRuleName?: string;
    readonly protocol?: TransportProtocol;
}

// @public
export interface InboundNatRules {
    beginCreateOrUpdate(resourceGroupName: string, loadBalancerName: string, inboundNatRuleName: string, inboundNatRuleParameters: InboundNatRule, options?: InboundNatRulesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<InboundNatRulesCreateOrUpdateResponse>, InboundNatRulesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, loadBalancerName: string, inboundNatRuleName: string, inboundNatRuleParameters: InboundNatRule, options?: InboundNatRulesCreateOrUpdateOptionalParams): Promise<InboundNatRulesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, loadBalancerName: string, inboundNatRuleName: string, options?: InboundNatRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, loadBalancerName: string, inboundNatRuleName: string, options?: InboundNatRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, loadBalancerName: string, inboundNatRuleName: string, options?: InboundNatRulesGetOptionalParams): Promise<InboundNatRulesGetResponse>;
    list(resourceGroupName: string, loadBalancerName: string, options?: InboundNatRulesListOptionalParams): PagedAsyncIterableIterator<InboundNatRule>;
}

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

// @public
export type InboundNatRulesCreateOrUpdateResponse = InboundNatRule;

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

// @public
export interface InboundNatRulesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type InboundNatRulesGetResponse = InboundNatRule;

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

// @public
export type InboundNatRulesListNextResponse = InboundNatRuleListResult;

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

// @public
export type InboundNatRulesListResponse = InboundNatRuleListResult;

// @public
export interface InboundSecurityRule extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    rules?: InboundSecurityRules[];
    ruleType?: InboundSecurityRuleType;
    readonly type?: string;
}

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

// @public
export type InboundSecurityRuleCreateOrUpdateResponse = InboundSecurityRule;

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

// @public
export type InboundSecurityRuleGetResponse = InboundSecurityRule;

// @public
export interface InboundSecurityRuleOperations {
    beginCreateOrUpdate(resourceGroupName: string, networkVirtualApplianceName: string, ruleCollectionName: string, parameters: InboundSecurityRule, options?: InboundSecurityRuleCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<InboundSecurityRuleCreateOrUpdateResponse>, InboundSecurityRuleCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkVirtualApplianceName: string, ruleCollectionName: string, parameters: InboundSecurityRule, options?: InboundSecurityRuleCreateOrUpdateOptionalParams): Promise<InboundSecurityRuleCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkVirtualApplianceName: string, ruleCollectionName: string, options?: InboundSecurityRuleGetOptionalParams): Promise<InboundSecurityRuleGetResponse>;
}

// @public
export interface InboundSecurityRules {
    appliesOn?: string[];
    destinationPortRange?: number;
    destinationPortRanges?: string[];
    name?: string;
    protocol?: InboundSecurityRulesProtocol;
    sourceAddressPrefix?: string;
}

// @public
export type InboundSecurityRulesProtocol = string;

// @public
export type InboundSecurityRuleType = string;

// @public
export interface IntentContent {
    // (undocumented)
    description?: string;
    destinationResourceId: string;
    ipTraffic: IPTraffic;
    sourceResourceId: string;
}

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

// @public
export interface IPAddressAvailabilityResult {
    available?: boolean;
    availableIPAddresses?: string[];
    isPlatformReserved?: boolean;
}

// @public
export interface IpAllocation extends Resource {
    allocationTags?: {
        [propertyName: string]: string;
    };
    readonly etag?: string;
    ipamAllocationId?: string;
    prefix?: string;
    prefixLength?: number;
    prefixType?: IPVersion;
    readonly subnet?: SubResource;
    typePropertiesType?: IpAllocationType;
    readonly virtualNetwork?: SubResource;
}

// @public
export interface IpAllocationListResult {
    nextLink?: string;
    value?: IpAllocation[];
}

// @public
export type IPAllocationMethod = string;

// @public
export interface IpAllocations {
    beginCreateOrUpdate(resourceGroupName: string, ipAllocationName: string, parameters: IpAllocation, options?: IpAllocationsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<IpAllocationsCreateOrUpdateResponse>, IpAllocationsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, ipAllocationName: string, parameters: IpAllocation, options?: IpAllocationsCreateOrUpdateOptionalParams): Promise<IpAllocationsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, ipAllocationName: string, options?: IpAllocationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, ipAllocationName: string, options?: IpAllocationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ipAllocationName: string, options?: IpAllocationsGetOptionalParams): Promise<IpAllocationsGetResponse>;
    list(options?: IpAllocationsListOptionalParams): PagedAsyncIterableIterator<IpAllocation>;
    listByResourceGroup(resourceGroupName: string, options?: IpAllocationsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<IpAllocation>;
    updateTags(resourceGroupName: string, ipAllocationName: string, parameters: TagsObject, options?: IpAllocationsUpdateTagsOptionalParams): Promise<IpAllocationsUpdateTagsResponse>;
}

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

// @public
export type IpAllocationsCreateOrUpdateResponse = IpAllocation;

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

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

// @public
export interface IpAllocationsGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type IpAllocationsGetResponse = IpAllocation;

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

// @public
export type IpAllocationsListByResourceGroupNextResponse = IpAllocationListResult;

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

// @public
export type IpAllocationsListByResourceGroupResponse = IpAllocationListResult;

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

// @public
export type IpAllocationsListNextResponse = IpAllocationListResult;

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

// @public
export type IpAllocationsListResponse = IpAllocationListResult;

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

// @public
export type IpAllocationsUpdateTagsResponse = IpAllocation;

// @public
export type IpAllocationType = string;

// @public
export interface IpamPool extends CommonTrackedResource {
    readonly etag?: string;
    properties: IpamPoolProperties;
}

// @public
export interface IpamPoolList {
    nextLink?: string;
    // (undocumented)
    value?: IpamPool[];
}

// @public
export interface IpamPoolPrefixAllocation {
    readonly allocatedAddressPrefixes?: string[];
    id?: string;
    numberOfIpAddresses?: string;
}

// @public
export interface IpamPoolProperties {
    addressPrefixes: string[];
    // (undocumented)
    description?: string;
    displayName?: string;
    readonly ipAddressType?: IpType[];
    parentPoolName?: string;
    provisioningState?: ProvisioningState;
}

// @public
export interface IpamPools {
    beginCreate(resourceGroupName: string, networkManagerName: string, poolName: string, body: IpamPool, options?: IpamPoolsCreateOptionalParams): Promise<SimplePollerLike<OperationState<IpamPoolsCreateResponse>, IpamPoolsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, networkManagerName: string, poolName: string, body: IpamPool, options?: IpamPoolsCreateOptionalParams): Promise<IpamPoolsCreateResponse>;
    beginDelete(resourceGroupName: string, networkManagerName: string, poolName: string, options?: IpamPoolsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<IpamPoolsDeleteResponse>, IpamPoolsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, poolName: string, options?: IpamPoolsDeleteOptionalParams): Promise<IpamPoolsDeleteResponse>;
    get(resourceGroupName: string, networkManagerName: string, poolName: string, options?: IpamPoolsGetOptionalParams): Promise<IpamPoolsGetResponse>;
    getPoolUsage(resourceGroupName: string, networkManagerName: string, poolName: string, options?: IpamPoolsGetPoolUsageOptionalParams): Promise<IpamPoolsGetPoolUsageResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: IpamPoolsListOptionalParams): PagedAsyncIterableIterator<IpamPool>;
    listAssociatedResources(resourceGroupName: string, networkManagerName: string, poolName: string, options?: IpamPoolsListAssociatedResourcesOptionalParams): PagedAsyncIterableIterator<PoolAssociation>;
    update(resourceGroupName: string, networkManagerName: string, poolName: string, options?: IpamPoolsUpdateOptionalParams): Promise<IpamPoolsUpdateResponse>;
}

// @public
export interface IpamPoolsCreateHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
}

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

// @public
export type IpamPoolsCreateResponse = IpamPool;

// @public
export interface IpamPoolsDeleteHeaders {
    // (undocumented)
    location?: string;
}

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

// @public
export type IpamPoolsDeleteResponse = IpamPoolsDeleteHeaders;

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

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

// @public
export type IpamPoolsGetPoolUsageResponse = PoolUsage;

// @public
export type IpamPoolsGetResponse = IpamPool;

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

// @public
export type IpamPoolsListAssociatedResourcesNextResponse = PoolAssociationList;

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

// @public
export type IpamPoolsListAssociatedResourcesResponse = PoolAssociationList;

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

// @public
export type IpamPoolsListNextResponse = IpamPoolList;

// @public
export interface IpamPoolsListOptionalParams extends coreClient.OperationOptions {
    skip?: number;
    skipToken?: string;
    sortKey?: string;
    sortValue?: string;
    top?: number;
}

// @public
export type IpamPoolsListResponse = IpamPoolList;

// @public
export interface IpamPoolsUpdateOptionalParams extends coreClient.OperationOptions {
    body?: IpamPoolUpdate;
    ifMatch?: string;
}

// @public
export type IpamPoolsUpdateResponse = IpamPool;

// @public
export interface IpamPoolUpdate {
    properties?: IpamPoolUpdateProperties;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface IpamPoolUpdateProperties {
    // (undocumented)
    description?: string;
    displayName?: string;
}

// @public
export interface IPConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    privateIPAddress?: string;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: PublicIPAddress;
    subnet?: Subnet;
}

// @public
export interface IPConfigurationBgpPeeringAddress {
    customBgpIpAddresses?: string[];
    readonly defaultBgpIpAddresses?: string[];
    ipconfigurationId?: string;
    readonly tunnelIpAddresses?: string[];
}

// @public
export interface IPConfigurationProfile extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    subnet?: Subnet;
    readonly type?: string;
}

// @public
export type IpFlowProtocol = string;

// @public
export interface IpGroup extends Resource {
    readonly etag?: string;
    readonly firewallPolicies?: SubResource[];
    readonly firewalls?: SubResource[];
    ipAddresses?: string[];
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface IpGroupListResult {
    nextLink?: string;
    value?: IpGroup[];
}

// @public
export interface IpGroups {
    beginCreateOrUpdate(resourceGroupName: string, ipGroupsName: string, parameters: IpGroup, options?: IpGroupsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<IpGroupsCreateOrUpdateResponse>, IpGroupsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, ipGroupsName: string, parameters: IpGroup, options?: IpGroupsCreateOrUpdateOptionalParams): Promise<IpGroupsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, ipGroupsName: string, options?: IpGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, ipGroupsName: string, options?: IpGroupsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ipGroupsName: string, options?: IpGroupsGetOptionalParams): Promise<IpGroupsGetResponse>;
    list(options?: IpGroupsListOptionalParams): PagedAsyncIterableIterator<IpGroup>;
    listByResourceGroup(resourceGroupName: string, options?: IpGroupsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<IpGroup>;
    updateGroups(resourceGroupName: string, ipGroupsName: string, parameters: TagsObject, options?: IpGroupsUpdateGroupsOptionalParams): Promise<IpGroupsUpdateGroupsResponse>;
}

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

// @public
export type IpGroupsCreateOrUpdateResponse = IpGroup;

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

// @public
export interface IpGroupsGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type IpGroupsGetResponse = IpGroup;

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

// @public
export type IpGroupsListByResourceGroupNextResponse = IpGroupListResult;

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

// @public
export type IpGroupsListByResourceGroupResponse = IpGroupListResult;

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

// @public
export type IpGroupsListNextResponse = IpGroupListResult;

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

// @public
export type IpGroupsListResponse = IpGroupListResult;

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

// @public
export type IpGroupsUpdateGroupsResponse = IpGroup;

// @public
export interface IPPrefixesList {
    ipPrefixes?: string[];
}

// @public (undocumented)
export interface IPRule {
    addressPrefix?: string;
}

// @public
export type IpsecEncryption = string;

// @public
export type IpsecIntegrity = string;

// @public
export interface IpsecPolicy {
    dhGroup: DhGroup;
    ikeEncryption: IkeEncryption;
    ikeIntegrity: IkeIntegrity;
    ipsecEncryption: IpsecEncryption;
    ipsecIntegrity: IpsecIntegrity;
    pfsGroup: PfsGroup;
    saDataSizeKilobytes: number;
    saLifeTimeSeconds: number;
}

// @public
export interface IpTag {
    ipTagType?: string;
    tag?: string;
}

// @public
export interface IPTraffic {
    destinationIps: string[];
    destinationPorts: string[];
    // (undocumented)
    protocols: NetworkProtocol[];
    sourceIps: string[];
    sourcePorts: string[];
}

// @public
export type IpType = string;

// @public
export interface Ipv6CircuitConnectionConfig {
    addressPrefix?: string;
    readonly circuitConnectionStatus?: CircuitConnectionStatus;
}

// @public
export interface Ipv6ExpressRouteCircuitPeeringConfig {
    microsoftPeeringConfig?: ExpressRouteCircuitPeeringConfig;
    primaryPeerAddressPrefix?: string;
    routeFilter?: SubResource;
    secondaryPeerAddressPrefix?: string;
    state?: ExpressRouteCircuitPeeringState;
}

// @public
export type IPVersion = string;

// @public
export type IsGlobal = string;

// @public
export type IssueType = string;

// @public
export type IsWorkloadProtected = string;

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

// @public
export enum KnownAccessRuleDirection {
    Inbound = "Inbound",
    Outbound = "Outbound"
}

// @public
export enum KnownActionType {
    Allow = "Allow",
    AnomalyScoring = "AnomalyScoring",
    Block = "Block",
    JSChallenge = "JSChallenge",
    Log = "Log"
}

// @public
export enum KnownAddressPrefixType {
    IPPrefix = "IPPrefix",
    NetworkGroup = "NetworkGroup",
    ServiceTag = "ServiceTag"
}

// @public
export enum KnownAddressSpaceAggregationOption {
    Manual = "Manual",
    None = "None"
}

// @public
export enum KnownAdminRuleKind {
    Custom = "Custom",
    Default = "Default"
}

// @public
export enum KnownAdminState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownAdvertisedPublicPrefixPropertiesValidationState {
    AsnValidationFailed = "AsnValidationFailed",
    CertificateMissingInRoutingRegistry = "CertificateMissingInRoutingRegistry",
    Configured = "Configured",
    Configuring = "Configuring",
    InvalidSignatureEncoding = "InvalidSignatureEncoding",
    ManualValidationNeeded = "ManualValidationNeeded",
    NotConfigured = "NotConfigured",
    SignatureVerificationFailed = "SignatureVerificationFailed",
    ValidationFailed = "ValidationFailed",
    ValidationNeeded = "ValidationNeeded"
}

// @public
export enum KnownApplicationGatewayBackendHealthServerHealth {
    Down = "Down",
    Draining = "Draining",
    Partial = "Partial",
    Unknown = "Unknown",
    Up = "Up"
}

// @public
export enum KnownApplicationGatewayClientRevocationOptions {
    None = "None",
    Ocsp = "OCSP"
}

// @public
export enum KnownApplicationGatewayCookieBasedAffinity {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownApplicationGatewayCustomErrorStatusCode {
    HttpStatus400 = "HttpStatus400",
    HttpStatus403 = "HttpStatus403",
    HttpStatus404 = "HttpStatus404",
    HttpStatus405 = "HttpStatus405",
    HttpStatus408 = "HttpStatus408",
    HttpStatus500 = "HttpStatus500",
    HttpStatus502 = "HttpStatus502",
    HttpStatus503 = "HttpStatus503",
    HttpStatus504 = "HttpStatus504"
}

// @public
export enum KnownApplicationGatewayFirewallMode {
    Detection = "Detection",
    Prevention = "Prevention"
}

// @public
export enum KnownApplicationGatewayFirewallRateLimitDuration {
    FiveMins = "FiveMins",
    OneMin = "OneMin"
}

// @public
export enum KnownApplicationGatewayFirewallUserSessionVariable {
    ClientAddr = "ClientAddr",
    ClientAddrXFFHeader = "ClientAddrXFFHeader",
    GeoLocation = "GeoLocation",
    GeoLocationXFFHeader = "GeoLocationXFFHeader",
    None = "None"
}

// @public
export enum KnownApplicationGatewayLoadDistributionAlgorithm {
    IpHash = "IpHash",
    LeastConnections = "LeastConnections",
    RoundRobin = "RoundRobin"
}

// @public
export enum KnownApplicationGatewayOperationalState {
    Running = "Running",
    Starting = "Starting",
    Stopped = "Stopped",
    Stopping = "Stopping"
}

// @public
export enum KnownApplicationGatewayProtocol {
    Http = "Http",
    Https = "Https",
    Tcp = "Tcp",
    Tls = "Tls"
}

// @public
export enum KnownApplicationGatewayRedirectType {
    Found = "Found",
    Permanent = "Permanent",
    SeeOther = "SeeOther",
    Temporary = "Temporary"
}

// @public
export enum KnownApplicationGatewayRequestRoutingRuleType {
    Basic = "Basic",
    PathBasedRouting = "PathBasedRouting"
}

// @public
export enum KnownApplicationGatewayRuleSetStatusOptions {
    Deprecated = "Deprecated",
    GA = "GA",
    Preview = "Preview",
    Supported = "Supported"
}

// @public
export enum KnownApplicationGatewaySkuFamily {
    Generation1 = "Generation_1",
    Generation2 = "Generation_2"
}

// @public
export enum KnownApplicationGatewaySkuName {
    Basic = "Basic",
    StandardLarge = "Standard_Large",
    StandardMedium = "Standard_Medium",
    StandardSmall = "Standard_Small",
    StandardV2 = "Standard_v2",
    WAFLarge = "WAF_Large",
    WAFMedium = "WAF_Medium",
    WAFV2 = "WAF_v2"
}

// @public
export enum KnownApplicationGatewaySslCipherSuite {
    TLSDHEDSSWith3DESEDECBCSHA = "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA",
    TLSDHEDSSWithAES128CBCSHA = "TLS_DHE_DSS_WITH_AES_128_CBC_SHA",
    TLSDHEDSSWithAES128CBCSHA256 = "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256",
    TLSDHEDSSWithAES256CBCSHA = "TLS_DHE_DSS_WITH_AES_256_CBC_SHA",
    TLSDHEDSSWithAES256CBCSHA256 = "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256",
    TLSDHERSAWithAES128CBCSHA = "TLS_DHE_RSA_WITH_AES_128_CBC_SHA",
    TLSDHERSAWithAES128GCMSHA256 = "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256",
    TLSDHERSAWithAES256CBCSHA = "TLS_DHE_RSA_WITH_AES_256_CBC_SHA",
    TLSDHERSAWithAES256GCMSHA384 = "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384",
    TLSEcdheEcdsaWithAES128CBCSHA = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
    TLSEcdheEcdsaWithAES128CBCSHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
    TLSEcdheEcdsaWithAES128GCMSHA256 = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
    TLSEcdheEcdsaWithAES256CBCSHA = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
    TLSEcdheEcdsaWithAES256CBCSHA384 = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
    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",
    TLSRSAWith3DESEDECBCSHA = "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
    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 KnownApplicationGatewaySslPolicyName {
    AppGwSslPolicy20150501 = "AppGwSslPolicy20150501",
    AppGwSslPolicy20170401 = "AppGwSslPolicy20170401",
    AppGwSslPolicy20170401S = "AppGwSslPolicy20170401S",
    AppGwSslPolicy20220101 = "AppGwSslPolicy20220101",
    AppGwSslPolicy20220101S = "AppGwSslPolicy20220101S"
}

// @public
export enum KnownApplicationGatewaySslPolicyType {
    Custom = "Custom",
    CustomV2 = "CustomV2",
    Predefined = "Predefined"
}

// @public
export enum KnownApplicationGatewaySslProtocol {
    TLSv10 = "TLSv1_0",
    TLSv11 = "TLSv1_1",
    TLSv12 = "TLSv1_2",
    TLSv13 = "TLSv1_3"
}

// @public
export enum KnownApplicationGatewayTier {
    Basic = "Basic",
    Standard = "Standard",
    StandardV2 = "Standard_v2",
    WAF = "WAF",
    WAFV2 = "WAF_v2"
}

// @public
export enum KnownApplicationGatewayTierTypes {
    Standard = "Standard",
    StandardV2 = "Standard_v2",
    WAF = "WAF",
    WAFV2 = "WAF_v2"
}

// @public
export enum KnownApplicationGatewayWafRuleActionTypes {
    Allow = "Allow",
    AnomalyScoring = "AnomalyScoring",
    Block = "Block",
    Log = "Log",
    None = "None"
}

// @public
export enum KnownApplicationGatewayWafRuleSensitivityTypes {
    High = "High",
    Low = "Low",
    Medium = "Medium",
    None = "None"
}

// @public
export enum KnownApplicationGatewayWafRuleStateTypes {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownAssociationAccessMode {
    Audit = "Audit",
    Enforced = "Enforced",
    Learning = "Learning"
}

// @public
export enum KnownAssociationType {
    Associated = "Associated",
    Contains = "Contains"
}

// @public
export enum KnownAuthenticationMethod {
    EapmschaPv2 = "EAPMSCHAPv2",
    Eaptls = "EAPTLS"
}

// @public
export enum KnownAuthorizationUseStatus {
    Available = "Available",
    InUse = "InUse"
}

// @public
export enum KnownAutoLearnPrivateRangesMode {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownAzureFirewallApplicationRuleProtocolType {
    Http = "Http",
    Https = "Https",
    Mssql = "Mssql"
}

// @public
export enum KnownAzureFirewallNatRCActionType {
    Dnat = "Dnat",
    Snat = "Snat"
}

// @public
export enum KnownAzureFirewallNetworkRuleProtocol {
    Any = "Any",
    Icmp = "ICMP",
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownAzureFirewallPacketCaptureFlagsType {
    Ack = "ack",
    Fin = "fin",
    Push = "push",
    Rst = "rst",
    Syn = "syn",
    Urg = "urg"
}

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

// @public
export enum KnownAzureFirewallSkuName {
    AzfwHub = "AZFW_Hub",
    AzfwVnet = "AZFW_VNet"
}

// @public
export enum KnownAzureFirewallSkuTier {
    Basic = "Basic",
    Premium = "Premium",
    Standard = "Standard"
}

// @public
export enum KnownAzureFirewallThreatIntelMode {
    Alert = "Alert",
    Deny = "Deny",
    Off = "Off"
}

// @public
export enum KnownBastionConnectProtocol {
    RDP = "RDP",
    SSH = "SSH"
}

// @public
export enum KnownBastionHostSkuName {
    Basic = "Basic",
    Developer = "Developer",
    Premium = "Premium",
    Standard = "Standard"
}

// @public
export enum KnownBgpPeerState {
    Connected = "Connected",
    Connecting = "Connecting",
    Idle = "Idle",
    Stopped = "Stopped",
    Unknown = "Unknown"
}

// @public
export enum KnownCircuitConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    Disconnected = "Disconnected"
}

// @public
export enum KnownCommissionedState {
    Commissioned = "Commissioned",
    CommissionedNoInternetAdvertise = "CommissionedNoInternetAdvertise",
    Commissioning = "Commissioning",
    Decommissioning = "Decommissioning",
    Deprovisioned = "Deprovisioned",
    Deprovisioning = "Deprovisioning",
    Provisioned = "Provisioned",
    Provisioning = "Provisioning"
}

// @public
export enum KnownConfigurationType {
    Connectivity = "Connectivity",
    Routing = "Routing",
    SecurityAdmin = "SecurityAdmin",
    SecurityUser = "SecurityUser"
}

// @public
export enum KnownConnectedGroupAddressOverlap {
    Allowed = "Allowed",
    Disallowed = "Disallowed"
}

// @public
export enum KnownConnectedGroupPrivateEndpointsScale {
    HighScale = "HighScale",
    Standard = "Standard"
}

// @public
export enum KnownConnectionMonitorEndpointFilterItemType {
    AgentAddress = "AgentAddress"
}

// @public
export enum KnownConnectionMonitorEndpointFilterType {
    Include = "Include"
}

// @public
export enum KnownConnectionMonitorSourceStatus {
    Active = "Active",
    Inactive = "Inactive",
    Unknown = "Unknown"
}

// @public
export enum KnownConnectionMonitorTestConfigurationProtocol {
    Http = "Http",
    Icmp = "Icmp",
    Tcp = "Tcp"
}

// @public
export enum KnownConnectionMonitorType {
    MultiEndpoint = "MultiEndpoint",
    SingleSourceDestination = "SingleSourceDestination"
}

// @public
export enum KnownConnectionState {
    Reachable = "Reachable",
    Unknown = "Unknown",
    Unreachable = "Unreachable"
}

// @public
export enum KnownConnectionStatus {
    Connected = "Connected",
    Degraded = "Degraded",
    Disconnected = "Disconnected",
    Unknown = "Unknown"
}

// @public
export enum KnownConnectivityTopology {
    HubAndSpoke = "HubAndSpoke",
    Mesh = "Mesh"
}

// @public
export enum KnownCoverageLevel {
    AboveAverage = "AboveAverage",
    Average = "Average",
    BelowAverage = "BelowAverage",
    Default = "Default",
    Full = "Full",
    Low = "Low"
}

// @public
export enum KnownCreatedByType {
    Application = "Application",
    Key = "Key",
    ManagedIdentity = "ManagedIdentity",
    User = "User"
}

// @public
export enum KnownCustomIpPrefixType {
    Child = "Child",
    Parent = "Parent",
    Singular = "Singular"
}

// @public
export enum KnownDdosSettingsProtectionMode {
    Disabled = "Disabled",
    Enabled = "Enabled",
    VirtualNetworkInherited = "VirtualNetworkInherited"
}

// @public
export enum KnownDeleteExistingPeering {
    False = "False",
    True = "True"
}

// @public
export enum KnownDeleteOptions {
    Delete = "Delete",
    Detach = "Detach"
}

// @public
export enum KnownDeploymentStatus {
    Deployed = "Deployed",
    Deploying = "Deploying",
    Failed = "Failed",
    NotStarted = "NotStarted"
}

// @public
export enum KnownDestinationPortBehavior {
    ListenIfAvailable = "ListenIfAvailable",
    None = "None"
}

// @public
export enum KnownDhGroup {
    DHGroup1 = "DHGroup1",
    DHGroup14 = "DHGroup14",
    DHGroup2 = "DHGroup2",
    DHGroup2048 = "DHGroup2048",
    DHGroup24 = "DHGroup24",
    ECP256 = "ECP256",
    ECP384 = "ECP384",
    None = "None"
}

// @public
export enum KnownDirection {
    Inbound = "Inbound",
    Outbound = "Outbound"
}

// @public
export enum KnownDisableBgpRoutePropagation {
    False = "False",
    True = "True"
}

// @public
export enum KnownEffectiveAdminRuleKind {
    Custom = "Custom",
    Default = "Default"
}

// @public
export enum KnownEffectiveRouteSource {
    Default = "Default",
    Unknown = "Unknown",
    User = "User",
    VirtualNetworkGateway = "VirtualNetworkGateway"
}

// @public
export enum KnownEffectiveRouteState {
    Active = "Active",
    Invalid = "Invalid"
}

// @public
export enum KnownEffectiveSecurityRuleProtocol {
    All = "All",
    Tcp = "Tcp",
    Udp = "Udp"
}

// @public
export enum KnownEndpointType {
    AzureArcNetwork = "AzureArcNetwork",
    AzureArcVM = "AzureArcVM",
    AzureSubnet = "AzureSubnet",
    AzureVM = "AzureVM",
    AzureVmss = "AzureVMSS",
    AzureVNet = "AzureVNet",
    ExternalAddress = "ExternalAddress",
    MMAWorkspaceMachine = "MMAWorkspaceMachine",
    MMAWorkspaceNetwork = "MMAWorkspaceNetwork"
}

// @public
export enum KnownEvaluationState {
    Completed = "Completed",
    InProgress = "InProgress",
    NotStarted = "NotStarted"
}

// @public
export enum KnownExceptionEntryMatchVariable {
    RemoteAddr = "RemoteAddr",
    RequestHeader = "RequestHeader",
    RequestURI = "RequestURI"
}

// @public
export enum KnownExceptionEntrySelectorMatchOperator {
    Contains = "Contains",
    EndsWith = "EndsWith",
    Equals = "Equals",
    StartsWith = "StartsWith"
}

// @public
export enum KnownExceptionEntryValueMatchOperator {
    Contains = "Contains",
    EndsWith = "EndsWith",
    Equals = "Equals",
    IPMatch = "IPMatch",
    StartsWith = "StartsWith"
}

// @public
export enum KnownExpressRouteCircuitPeeringAdvertisedPublicPrefixState {
    Configured = "Configured",
    Configuring = "Configuring",
    NotConfigured = "NotConfigured",
    ValidationNeeded = "ValidationNeeded"
}

// @public
export enum KnownExpressRouteCircuitPeeringState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownExpressRouteCircuitSkuFamily {
    MeteredData = "MeteredData",
    UnlimitedData = "UnlimitedData"
}

// @public
export enum KnownExpressRouteCircuitSkuTier {
    Basic = "Basic",
    Local = "Local",
    Premium = "Premium",
    Standard = "Standard"
}

// @public
export enum KnownExpressRouteLinkAdminState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownExpressRouteLinkConnectorType {
    LC = "LC",
    SC = "SC"
}

// @public
export enum KnownExpressRouteLinkMacSecCipher {
    GcmAes128 = "GcmAes128",
    GcmAes256 = "GcmAes256",
    GcmAesXpn128 = "GcmAesXpn128",
    GcmAesXpn256 = "GcmAesXpn256"
}

// @public
export enum KnownExpressRouteLinkMacSecSciState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownExpressRoutePeeringState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownExpressRoutePeeringType {
    AzurePrivatePeering = "AzurePrivatePeering",
    AzurePublicPeering = "AzurePublicPeering",
    MicrosoftPeering = "MicrosoftPeering"
}

// @public
export enum KnownExpressRoutePortAuthorizationUseStatus {
    Available = "Available",
    InUse = "InUse"
}

// @public
export enum KnownExpressRoutePortsBillingType {
    MeteredData = "MeteredData",
    UnlimitedData = "UnlimitedData"
}

// @public
export enum KnownExpressRoutePortsEncapsulation {
    Dot1Q = "Dot1Q",
    QinQ = "QinQ"
}

// @public
export enum KnownExtendedLocationTypes {
    EdgeZone = "EdgeZone"
}

// @public
export enum KnownFailoverConnectionStatus {
    Connected = "Connected",
    Disconnected = "Disconnected"
}

// @public
export enum KnownFailoverTestStatus {
    Completed = "Completed",
    Expired = "Expired",
    Invalid = "Invalid",
    NotStarted = "NotStarted",
    Running = "Running",
    StartFailed = "StartFailed",
    Starting = "Starting",
    StopFailed = "StopFailed",
    Stopping = "Stopping"
}

// @public
export enum KnownFailoverTestStatusForSingleTest {
    Completed = "Completed",
    Expired = "Expired",
    Invalid = "Invalid",
    NotStarted = "NotStarted",
    Running = "Running",
    StartFailed = "StartFailed",
    Starting = "Starting",
    StopFailed = "StopFailed",
    Stopping = "Stopping"
}

// @public
export enum KnownFailoverTestType {
    All = "All",
    MultiSiteFailover = "MultiSiteFailover",
    SingleSiteFailover = "SingleSiteFailover"
}

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

// @public
export enum KnownFirewallPolicyIdpsQuerySortOrder {
    Ascending = "Ascending",
    Descending = "Descending"
}

// @public
export enum KnownFirewallPolicyIntrusionDetectionProfileType {
    Advanced = "Advanced",
    Basic = "Basic",
    Extended = "Extended",
    Standard = "Standard"
}

// @public
export enum KnownFirewallPolicyIntrusionDetectionProtocol {
    ANY = "ANY",
    Icmp = "ICMP",
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownFirewallPolicyIntrusionDetectionStateType {
    Alert = "Alert",
    Deny = "Deny",
    Off = "Off"
}

// @public
export enum KnownFirewallPolicyNatRuleCollectionActionType {
    Dnat = "DNAT"
}

// @public
export enum KnownFirewallPolicyRuleApplicationProtocolType {
    Http = "Http",
    Https = "Https"
}

// @public
export enum KnownFirewallPolicyRuleCollectionType {
    FirewallPolicyFilterRuleCollection = "FirewallPolicyFilterRuleCollection",
    FirewallPolicyNatRuleCollection = "FirewallPolicyNatRuleCollection"
}

// @public
export enum KnownFirewallPolicyRuleNetworkProtocol {
    Any = "Any",
    Icmp = "ICMP",
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownFirewallPolicyRuleType {
    ApplicationRule = "ApplicationRule",
    NatRule = "NatRule",
    NetworkRule = "NetworkRule"
}

// @public
export enum KnownFirewallPolicySkuTier {
    Basic = "Basic",
    Premium = "Premium",
    Standard = "Standard"
}

// @public
export enum KnownFlowLogFormatType {
    Json = "JSON"
}

// @public
export enum KnownGatewayLoadBalancerTunnelInterfaceType {
    External = "External",
    Internal = "Internal",
    None = "None"
}

// @public
export enum KnownGatewayLoadBalancerTunnelProtocol {
    Native = "Native",
    None = "None",
    Vxlan = "VXLAN"
}

// @public
export enum KnownGeo {
    Afri = "AFRI",
    Apac = "APAC",
    AQ = "AQ",
    Euro = "EURO",
    Global = "GLOBAL",
    Latam = "LATAM",
    ME = "ME",
    NAM = "NAM",
    Oceania = "OCEANIA"
}

// @public
export enum KnownGroupConnectivity {
    DirectlyConnected = "DirectlyConnected",
    None = "None"
}

// @public
export enum KnownGroupMemberType {
    Subnet = "Subnet",
    VirtualNetwork = "VirtualNetwork"
}

// @public
export enum KnownHttpConfigurationMethod {
    Get = "Get",
    Post = "Post"
}

// @public
export enum KnownHttpMethod {
    Get = "Get"
}

// @public
export enum KnownHubBgpConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    NotConnected = "NotConnected",
    Unknown = "Unknown"
}

// @public
export enum KnownHubRoutingPreference {
    ASPath = "ASPath",
    ExpressRoute = "ExpressRoute",
    VpnGateway = "VpnGateway"
}

// @public
export enum KnownHubVirtualNetworkConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    NotConnected = "NotConnected",
    Unknown = "Unknown"
}

// @public
export enum KnownIkeEncryption {
    AES128 = "AES128",
    AES192 = "AES192",
    AES256 = "AES256",
    DES = "DES",
    DES3 = "DES3",
    Gcmaes128 = "GCMAES128",
    Gcmaes256 = "GCMAES256"
}

// @public
export enum KnownIkeIntegrity {
    Gcmaes128 = "GCMAES128",
    Gcmaes256 = "GCMAES256",
    MD5 = "MD5",
    SHA1 = "SHA1",
    SHA256 = "SHA256",
    SHA384 = "SHA384"
}

// @public
export enum KnownInboundSecurityRulesProtocol {
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownInboundSecurityRuleType {
    AutoExpire = "AutoExpire",
    Permanent = "Permanent"
}

// @public
export enum KnownIPAllocationMethod {
    Dynamic = "Dynamic",
    Static = "Static"
}

// @public
export enum KnownIpAllocationType {
    Hypernet = "Hypernet",
    Undefined = "Undefined"
}

// @public
export enum KnownIpFlowProtocol {
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownIpsecEncryption {
    AES128 = "AES128",
    AES192 = "AES192",
    AES256 = "AES256",
    DES = "DES",
    DES3 = "DES3",
    Gcmaes128 = "GCMAES128",
    Gcmaes192 = "GCMAES192",
    Gcmaes256 = "GCMAES256",
    None = "None"
}

// @public
export enum KnownIpsecIntegrity {
    Gcmaes128 = "GCMAES128",
    Gcmaes192 = "GCMAES192",
    Gcmaes256 = "GCMAES256",
    MD5 = "MD5",
    SHA1 = "SHA1",
    SHA256 = "SHA256"
}

// @public
export enum KnownIpType {
    IPv4 = "IPv4",
    IPv6 = "IPv6"
}

// @public
export enum KnownIPVersion {
    IPv4 = "IPv4",
    IPv6 = "IPv6"
}

// @public
export enum KnownIsGlobal {
    False = "False",
    True = "True"
}

// @public
export enum KnownIssueType {
    AgentStopped = "AgentStopped",
    DnsResolution = "DnsResolution",
    GuestFirewall = "GuestFirewall",
    NetworkSecurityRule = "NetworkSecurityRule",
    Platform = "Platform",
    PortThrottled = "PortThrottled",
    SocketBind = "SocketBind",
    Unknown = "Unknown",
    UserDefinedRoute = "UserDefinedRoute"
}

// @public
export enum KnownIsWorkloadProtected {
    False = "False",
    True = "True"
}

// @public
export enum KnownLoadBalancerBackendAddressAdminState {
    Down = "Down",
    None = "None",
    Up = "Up"
}

// @public
export enum KnownLoadBalancerOutboundRuleProtocol {
    All = "All",
    Tcp = "Tcp",
    Udp = "Udp"
}

// @public
export enum KnownLoadBalancerSkuName {
    Basic = "Basic",
    Gateway = "Gateway",
    Standard = "Standard"
}

// @public
export enum KnownLoadBalancerSkuTier {
    Global = "Global",
    Regional = "Regional"
}

// @public
export enum KnownLoadDistribution {
    Default = "Default",
    SourceIP = "SourceIP",
    SourceIPProtocol = "SourceIPProtocol"
}

// @public
export enum KnownManagedRuleEnabledState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownNatGatewaySkuName {
    Standard = "Standard",
    StandardV2 = "StandardV2"
}

// @public
export enum KnownNetworkIntentPolicyBasedService {
    All = "All",
    AllowRulesOnly = "AllowRulesOnly",
    None = "None"
}

// @public
export enum KnownNetworkInterfaceAuxiliaryMode {
    AcceleratedConnections = "AcceleratedConnections",
    Floating = "Floating",
    MaxConnections = "MaxConnections",
    None = "None"
}

// @public
export enum KnownNetworkInterfaceAuxiliarySku {
    A1 = "A1",
    A2 = "A2",
    A4 = "A4",
    A8 = "A8",
    None = "None"
}

// @public
export enum KnownNetworkInterfaceMigrationPhase {
    Abort = "Abort",
    Commit = "Commit",
    Committed = "Committed",
    None = "None",
    Prepare = "Prepare"
}

// @public
export enum KnownNetworkInterfaceNicType {
    Elastic = "Elastic",
    Standard = "Standard"
}

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

// @public
export enum KnownNetworkProtocol {
    Any = "Any",
    Icmp = "ICMP",
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownNextHopType {
    HyperNetGateway = "HyperNetGateway",
    Internet = "Internet",
    None = "None",
    VirtualAppliance = "VirtualAppliance",
    VirtualNetworkGateway = "VirtualNetworkGateway",
    VnetLocal = "VnetLocal"
}

// @public
export enum KnownNextStep {
    Continue = "Continue",
    Terminate = "Terminate",
    Unknown = "Unknown"
}

// @public
export enum KnownNicTypeInRequest {
    PrivateNic = "PrivateNic",
    PublicNic = "PublicNic"
}

// @public
export enum KnownNicTypeInResponse {
    AdditionalNic = "AdditionalNic",
    PrivateNic = "PrivateNic",
    PublicNic = "PublicNic"
}

// @public
export enum KnownNspLinkProvisioningState {
    Accepted = "Accepted",
    Creating = "Creating",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating",
    WaitForRemoteCompletion = "WaitForRemoteCompletion"
}

// @public
export enum KnownNspLinkStatus {
    Approved = "Approved",
    Disconnected = "Disconnected",
    Pending = "Pending",
    Rejected = "Rejected"
}

// @public
export enum KnownNspProvisioningState {
    Accepted = "Accepted",
    Creating = "Creating",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownOfficeTrafficCategory {
    All = "All",
    None = "None",
    Optimize = "Optimize",
    OptimizeAndAllow = "OptimizeAndAllow"
}

// @public
export enum KnownOrigin {
    Inbound = "Inbound",
    Local = "Local",
    Outbound = "Outbound"
}

// @public
export enum KnownOutputType {
    Workspace = "Workspace"
}

// @public
export enum KnownOwaspCrsExclusionEntryMatchVariable {
    RequestArgKeys = "RequestArgKeys",
    RequestArgNames = "RequestArgNames",
    RequestArgValues = "RequestArgValues",
    RequestCookieKeys = "RequestCookieKeys",
    RequestCookieNames = "RequestCookieNames",
    RequestCookieValues = "RequestCookieValues",
    RequestHeaderKeys = "RequestHeaderKeys",
    RequestHeaderNames = "RequestHeaderNames",
    RequestHeaderValues = "RequestHeaderValues"
}

// @public
export enum KnownOwaspCrsExclusionEntrySelectorMatchOperator {
    Contains = "Contains",
    EndsWith = "EndsWith",
    Equals = "Equals",
    EqualsAny = "EqualsAny",
    StartsWith = "StartsWith"
}

// @public
export enum KnownPcError {
    AgentStopped = "AgentStopped",
    CaptureFailed = "CaptureFailed",
    InternalError = "InternalError",
    LocalFileFailed = "LocalFileFailed",
    StorageFailed = "StorageFailed"
}

// @public
export enum KnownPcProtocol {
    Any = "Any",
    TCP = "TCP",
    UDP = "UDP"
}

// @public
export enum KnownPcStatus {
    Error = "Error",
    NotStarted = "NotStarted",
    Running = "Running",
    Stopped = "Stopped",
    Unknown = "Unknown"
}

// @public
export enum KnownPeeringEnforcement {
    Enforced = "Enforced",
    Unenforced = "Unenforced"
}

// @public
export enum KnownPfsGroup {
    ECP256 = "ECP256",
    ECP384 = "ECP384",
    None = "None",
    PFS1 = "PFS1",
    PFS14 = "PFS14",
    PFS2 = "PFS2",
    PFS2048 = "PFS2048",
    PFS24 = "PFS24",
    Pfsmm = "PFSMM"
}

// @public
export enum KnownPreferredIPVersion {
    IPv4 = "IPv4",
    IPv6 = "IPv6"
}

// @public
export enum KnownPreferredRoutingGateway {
    ExpressRoute = "ExpressRoute",
    None = "None",
    VpnGateway = "VpnGateway"
}

// @public
export enum KnownPrivateEndpointVNetPolicies {
    Basic = "Basic",
    Disabled = "Disabled"
}

// @public
export enum KnownProbeNoHealthyBackendsBehavior {
    AllProbedDown = "AllProbedDown",
    AllProbedUp = "AllProbedUp"
}

// @public
export enum KnownProbeProtocol {
    Http = "Http",
    Https = "Https",
    Tcp = "Tcp"
}

// @public
export enum KnownProcessorArchitecture {
    Amd64 = "Amd64",
    X86 = "X86"
}

// @public
export enum KnownProtocol {
    Http = "Http",
    Https = "Https",
    Icmp = "Icmp",
    Tcp = "Tcp"
}

// @public
export enum KnownProtocolType {
    Ah = "Ah",
    All = "All",
    DoNotUse = "DoNotUse",
    Esp = "Esp",
    Gre = "Gre",
    Icmp = "Icmp",
    Tcp = "Tcp",
    Udp = "Udp",
    Vxlan = "Vxlan"
}

// @public
export enum KnownProvisioningState {
    Canceled = "Canceled",
    Creating = "Creating",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownPublicIPAddressMigrationPhase {
    Abort = "Abort",
    Commit = "Commit",
    Committed = "Committed",
    None = "None",
    Prepare = "Prepare"
}

// @public
export enum KnownPublicIPAddressSkuName {
    Basic = "Basic",
    Standard = "Standard",
    StandardV2 = "StandardV2"
}

// @public
export enum KnownPublicIPAddressSkuTier {
    Global = "Global",
    Regional = "Regional"
}

// @public
export enum KnownPublicIPPrefixSkuName {
    Standard = "Standard",
    StandardV2 = "StandardV2"
}

// @public
export enum KnownPublicIPPrefixSkuTier {
    Global = "Global",
    Regional = "Regional"
}

// @public
export enum KnownResiliencyModel {
    MultiHomed = "MultiHomed",
    SingleHomed = "SingleHomed"
}

// @public
export enum KnownRouteFilterRuleType {
    Community = "Community"
}

// @public
export enum KnownRouteMapActionType {
    Add = "Add",
    Drop = "Drop",
    Remove = "Remove",
    Replace = "Replace",
    Unknown = "Unknown"
}

// @public
export enum KnownRouteMapMatchCondition {
    Contains = "Contains",
    Equals = "Equals",
    NotContains = "NotContains",
    NotEquals = "NotEquals",
    Unknown = "Unknown"
}

// @public
export enum KnownRouteNextHopType {
    Internet = "Internet",
    None = "None",
    VirtualAppliance = "VirtualAppliance",
    VirtualNetworkGateway = "VirtualNetworkGateway",
    VnetLocal = "VnetLocal"
}

// @public
export enum KnownRoutingRuleDestinationType {
    AddressPrefix = "AddressPrefix",
    ServiceTag = "ServiceTag"
}

// @public
export enum KnownRoutingRuleNextHopType {
    Internet = "Internet",
    NoNextHop = "NoNextHop",
    VirtualAppliance = "VirtualAppliance",
    VirtualNetworkGateway = "VirtualNetworkGateway",
    VnetLocal = "VnetLocal"
}

// @public
export enum KnownRoutingState {
    Failed = "Failed",
    None = "None",
    Provisioned = "Provisioned",
    Provisioning = "Provisioning"
}

// @public
export enum KnownScopeConnectionState {
    Conflict = "Conflict",
    Connected = "Connected",
    Pending = "Pending",
    Rejected = "Rejected",
    Revoked = "Revoked"
}

// @public
export enum KnownScrubbingRuleEntryMatchOperator {
    Equals = "Equals",
    EqualsAny = "EqualsAny"
}

// @public
export enum KnownScrubbingRuleEntryMatchVariable {
    RequestArgNames = "RequestArgNames",
    RequestCookieNames = "RequestCookieNames",
    RequestHeaderNames = "RequestHeaderNames",
    RequestIPAddress = "RequestIPAddress",
    RequestJsonArgNames = "RequestJSONArgNames",
    RequestPostArgNames = "RequestPostArgNames"
}

// @public
export enum KnownScrubbingRuleEntryState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

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

// @public
export enum KnownSecurityConfigurationRuleDirection {
    Inbound = "Inbound",
    Outbound = "Outbound"
}

// @public
export enum KnownSecurityConfigurationRuleProtocol {
    Ah = "Ah",
    Any = "Any",
    Esp = "Esp",
    Icmp = "Icmp",
    Tcp = "Tcp",
    Udp = "Udp"
}

// @public
export enum KnownSecurityPartnerProviderConnectionStatus {
    Connected = "Connected",
    NotConnected = "NotConnected",
    PartiallyConnected = "PartiallyConnected",
    Unknown = "Unknown"
}

// @public
export enum KnownSecurityProviderName {
    Checkpoint = "Checkpoint",
    IBoss = "IBoss",
    ZScaler = "ZScaler"
}

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

// @public
export enum KnownSecurityRuleDirection {
    Inbound = "Inbound",
    Outbound = "Outbound"
}

// @public
export enum KnownSecurityRuleProtocol {
    Ah = "Ah",
    Asterisk = "*",
    Esp = "Esp",
    Icmp = "Icmp",
    Tcp = "Tcp",
    Udp = "Udp"
}

// @public
export enum KnownSensitivityType {
    High = "High",
    Low = "Low",
    Medium = "Medium",
    None = "None"
}

// @public
export enum KnownServiceProviderProvisioningState {
    Deprovisioning = "Deprovisioning",
    NotProvisioned = "NotProvisioned",
    Provisioned = "Provisioned",
    Provisioning = "Provisioning"
}

// @public
export enum KnownSeverity {
    Error = "Error",
    Warning = "Warning"
}

// @public
export enum KnownSharingScope {
    DelegatedServices = "DelegatedServices",
    Tenant = "Tenant"
}

// @public
export enum KnownSyncMode {
    Automatic = "Automatic",
    Manual = "Manual"
}

// @public
export enum KnownSyncRemoteAddressSpace {
    True = "true"
}

// @public
export enum KnownTransportProtocol {
    All = "All",
    Tcp = "Tcp",
    Udp = "Udp"
}

// @public
export enum KnownTunnelConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    NotConnected = "NotConnected",
    Unknown = "Unknown"
}

// @public
export enum KnownUsageUnit {
    Count = "Count"
}

// @public
export enum KnownUseHubGateway {
    False = "False",
    True = "True"
}

// @public
export enum KnownVerbosityLevel {
    Full = "Full",
    Minimum = "Minimum",
    Normal = "Normal"
}

// @public
export enum KnownVirtualNetworkEncryptionEnforcement {
    AllowUnencrypted = "AllowUnencrypted",
    DropUnencrypted = "DropUnencrypted"
}

// @public
export enum KnownVirtualNetworkGatewayConnectionMode {
    Default = "Default",
    InitiatorOnly = "InitiatorOnly",
    ResponderOnly = "ResponderOnly"
}

// @public
export enum KnownVirtualNetworkGatewayConnectionProtocol {
    IKEv1 = "IKEv1",
    IKEv2 = "IKEv2"
}

// @public
export enum KnownVirtualNetworkGatewayConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    NotConnected = "NotConnected",
    Unknown = "Unknown"
}

// @public
export enum KnownVirtualNetworkGatewayConnectionType {
    ExpressRoute = "ExpressRoute",
    IPsec = "IPsec",
    Vnet2Vnet = "Vnet2Vnet",
    VPNClient = "VPNClient"
}

// @public
export enum KnownVirtualNetworkGatewayMigrationPhase {
    Abort = "Abort",
    AbortSucceeded = "AbortSucceeded",
    Commit = "Commit",
    CommitSucceeded = "CommitSucceeded",
    Execute = "Execute",
    ExecuteSucceeded = "ExecuteSucceeded",
    None = "None",
    Prepare = "Prepare",
    PrepareSucceeded = "PrepareSucceeded"
}

// @public
export enum KnownVirtualNetworkGatewayMigrationState {
    Failed = "Failed",
    InProgress = "InProgress",
    None = "None",
    Succeeded = "Succeeded"
}

// @public
export enum KnownVirtualNetworkGatewayMigrationType {
    UpgradeDeploymentToStandardIP = "UpgradeDeploymentToStandardIP"
}

// @public
export enum KnownVirtualNetworkGatewaySkuName {
    Basic = "Basic",
    ErGw1AZ = "ErGw1AZ",
    ErGw2AZ = "ErGw2AZ",
    ErGw3AZ = "ErGw3AZ",
    ErGwScale = "ErGwScale",
    HighPerformance = "HighPerformance",
    Standard = "Standard",
    UltraPerformance = "UltraPerformance",
    VpnGw1 = "VpnGw1",
    VpnGw1AZ = "VpnGw1AZ",
    VpnGw2 = "VpnGw2",
    VpnGw2AZ = "VpnGw2AZ",
    VpnGw3 = "VpnGw3",
    VpnGw3AZ = "VpnGw3AZ",
    VpnGw4 = "VpnGw4",
    VpnGw4AZ = "VpnGw4AZ",
    VpnGw5 = "VpnGw5",
    VpnGw5AZ = "VpnGw5AZ"
}

// @public
export enum KnownVirtualNetworkGatewaySkuTier {
    Basic = "Basic",
    ErGw1AZ = "ErGw1AZ",
    ErGw2AZ = "ErGw2AZ",
    ErGw3AZ = "ErGw3AZ",
    ErGwScale = "ErGwScale",
    HighPerformance = "HighPerformance",
    Standard = "Standard",
    UltraPerformance = "UltraPerformance",
    VpnGw1 = "VpnGw1",
    VpnGw1AZ = "VpnGw1AZ",
    VpnGw2 = "VpnGw2",
    VpnGw2AZ = "VpnGw2AZ",
    VpnGw3 = "VpnGw3",
    VpnGw3AZ = "VpnGw3AZ",
    VpnGw4 = "VpnGw4",
    VpnGw4AZ = "VpnGw4AZ",
    VpnGw5 = "VpnGw5",
    VpnGw5AZ = "VpnGw5AZ"
}

// @public
export enum KnownVirtualNetworkGatewayType {
    ExpressRoute = "ExpressRoute",
    LocalGateway = "LocalGateway",
    Vpn = "Vpn"
}

// @public
export enum KnownVirtualNetworkPeeringLevel {
    FullyInSync = "FullyInSync",
    LocalAndRemoteNotInSync = "LocalAndRemoteNotInSync",
    LocalNotInSync = "LocalNotInSync",
    RemoteNotInSync = "RemoteNotInSync"
}

// @public
export enum KnownVirtualNetworkPeeringState {
    Connected = "Connected",
    Disconnected = "Disconnected",
    Initiated = "Initiated"
}

// @public
export enum KnownVirtualNetworkPrivateEndpointNetworkPolicies {
    Disabled = "Disabled",
    Enabled = "Enabled",
    NetworkSecurityGroupEnabled = "NetworkSecurityGroupEnabled",
    RouteTableEnabled = "RouteTableEnabled"
}

// @public
export enum KnownVirtualNetworkPrivateLinkServiceNetworkPolicies {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownVirtualWanSecurityProviderType {
    External = "External",
    Native = "Native"
}

// @public
export enum KnownVnetLocalRouteOverrideCriteria {
    Contains = "Contains",
    Equal = "Equal"
}

// @public
export enum KnownVpnAuthenticationType {
    AAD = "AAD",
    Certificate = "Certificate",
    Radius = "Radius"
}

// @public
export enum KnownVpnClientProtocol {
    IkeV2 = "IkeV2",
    OpenVPN = "OpenVPN",
    Sstp = "SSTP"
}

// @public
export enum KnownVpnConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    NotConnected = "NotConnected",
    Unknown = "Unknown"
}

// @public
export enum KnownVpnGatewayGeneration {
    Generation1 = "Generation1",
    Generation2 = "Generation2",
    None = "None"
}

// @public
export enum KnownVpnGatewayTunnelingProtocol {
    IkeV2 = "IkeV2",
    OpenVPN = "OpenVPN"
}

// @public
export enum KnownVpnLinkConnectionMode {
    Default = "Default",
    InitiatorOnly = "InitiatorOnly",
    ResponderOnly = "ResponderOnly"
}

// @public
export enum KnownVpnNatRuleMode {
    EgressSnat = "EgressSnat",
    IngressSnat = "IngressSnat"
}

// @public
export enum KnownVpnNatRuleType {
    Dynamic = "Dynamic",
    Static = "Static"
}

// @public
export enum KnownVpnPolicyMemberAttributeType {
    AADGroupId = "AADGroupId",
    CertificateGroupId = "CertificateGroupId",
    RadiusAzureGroupId = "RadiusAzureGroupId"
}

// @public
export enum KnownVpnType {
    PolicyBased = "PolicyBased",
    RouteBased = "RouteBased"
}

// @public
export enum KnownWebApplicationFirewallAction {
    Allow = "Allow",
    Block = "Block",
    JSChallenge = "JSChallenge",
    Log = "Log"
}

// @public
export enum KnownWebApplicationFirewallEnabledState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownWebApplicationFirewallMatchVariable {
    PostArgs = "PostArgs",
    QueryString = "QueryString",
    RemoteAddr = "RemoteAddr",
    RequestBody = "RequestBody",
    RequestCookies = "RequestCookies",
    RequestHeaders = "RequestHeaders",
    RequestMethod = "RequestMethod",
    RequestUri = "RequestUri"
}

// @public
export enum KnownWebApplicationFirewallMode {
    Detection = "Detection",
    Prevention = "Prevention"
}

// @public
export enum KnownWebApplicationFirewallOperator {
    Any = "Any",
    BeginsWith = "BeginsWith",
    Contains = "Contains",
    EndsWith = "EndsWith",
    Equal = "Equal",
    GeoMatch = "GeoMatch",
    GreaterThan = "GreaterThan",
    GreaterThanOrEqual = "GreaterThanOrEqual",
    IPMatch = "IPMatch",
    LessThan = "LessThan",
    LessThanOrEqual = "LessThanOrEqual",
    Regex = "Regex"
}

// @public
export enum KnownWebApplicationFirewallPolicyResourceState {
    Creating = "Creating",
    Deleting = "Deleting",
    Disabled = "Disabled",
    Disabling = "Disabling",
    Enabled = "Enabled",
    Enabling = "Enabling"
}

// @public
export enum KnownWebApplicationFirewallRuleType {
    Invalid = "Invalid",
    MatchRule = "MatchRule",
    RateLimitRule = "RateLimitRule"
}

// @public
export enum KnownWebApplicationFirewallScrubbingState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownWebApplicationFirewallState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownWebApplicationFirewallTransform {
    HtmlEntityDecode = "HtmlEntityDecode",
    Lowercase = "Lowercase",
    RemoveNulls = "RemoveNulls",
    Trim = "Trim",
    Uppercase = "Uppercase",
    UrlDecode = "UrlDecode",
    UrlEncode = "UrlEncode"
}

// @public
export interface ListActiveConnectivityConfigurationsOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ListActiveConnectivityConfigurationsResponse = ActiveConnectivityConfigurationsListResult;

// @public
export interface ListActiveSecurityAdminRulesOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ListActiveSecurityAdminRulesResponse = ActiveSecurityAdminRulesListResult;

// @public
export interface ListHubRouteTablesResult {
    nextLink?: string;
    value?: HubRouteTable[];
}

// @public
export interface ListHubVirtualNetworkConnectionsResult {
    nextLink?: string;
    value?: HubVirtualNetworkConnection[];
}

// @public
export interface ListNetworkManagerEffectiveConnectivityConfigurationsOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ListNetworkManagerEffectiveConnectivityConfigurationsResponse = NetworkManagerEffectiveConnectivityConfigurationListResult;

// @public
export interface ListNetworkManagerEffectiveSecurityAdminRulesOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ListNetworkManagerEffectiveSecurityAdminRulesResponse = NetworkManagerEffectiveSecurityAdminRulesListResult;

// @public
export interface ListP2SVpnGatewaysResult {
    nextLink?: string;
    value?: P2SVpnGateway[];
}

// @public
export interface ListRouteMapsResult {
    nextLink?: string;
    value?: RouteMap[];
}

// @public
export interface ListRoutingIntentResult {
    nextLink?: string;
    value?: RoutingIntent[];
}

// @public
export interface ListVirtualHubBgpConnectionResults {
    nextLink?: string;
    value?: BgpConnection[];
}

// @public
export interface ListVirtualHubIpConfigurationResults {
    nextLink?: string;
    value?: HubIpConfiguration[];
}

// @public
export interface ListVirtualHubRouteTableV2SResult {
    nextLink?: string;
    value?: VirtualHubRouteTableV2[];
}

// @public
export interface ListVirtualHubsResult {
    nextLink?: string;
    value?: VirtualHub[];
}

// @public
export interface ListVirtualNetworkGatewayNatRulesResult {
    nextLink?: string;
    value?: VirtualNetworkGatewayNatRule[];
}

// @public
export interface ListVirtualWANsResult {
    nextLink?: string;
    value?: VirtualWAN[];
}

// @public
export interface ListVpnConnectionsResult {
    nextLink?: string;
    value?: VpnConnection[];
}

// @public
export interface ListVpnGatewayNatRulesResult {
    nextLink?: string;
    value?: VpnGatewayNatRule[];
}

// @public
export interface ListVpnGatewaysResult {
    nextLink?: string;
    value?: VpnGateway[];
}

// @public
export interface ListVpnServerConfigurationPolicyGroupsResult {
    nextLink?: string;
    value?: VpnServerConfigurationPolicyGroup[];
}

// @public
export interface ListVpnServerConfigurationsResult {
    nextLink?: string;
    value?: VpnServerConfiguration[];
}

// @public
export interface ListVpnSiteLinkConnectionsResult {
    nextLink?: string;
    value?: VpnSiteLinkConnection[];
}

// @public
export interface ListVpnSiteLinksResult {
    nextLink?: string;
    value?: VpnSiteLink[];
}

// @public
export interface ListVpnSitesResult {
    nextLink?: string;
    value?: VpnSite[];
}

// @public
export interface LoadBalancer extends Resource {
    backendAddressPools?: BackendAddressPool[];
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    frontendIPConfigurations?: FrontendIPConfiguration[];
    inboundNatPools?: InboundNatPool[];
    inboundNatRules?: InboundNatRule[];
    loadBalancingRules?: LoadBalancingRule[];
    outboundRules?: OutboundRule[];
    probes?: Probe[];
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    sku?: LoadBalancerSku;
}

// @public
export interface LoadBalancerBackendAddress {
    adminState?: LoadBalancerBackendAddressAdminState;
    readonly inboundNatRulesPortMapping?: NatRulePortMapping[];
    ipAddress?: string;
    loadBalancerFrontendIPConfiguration?: SubResource;
    name?: string;
    readonly networkInterfaceIPConfiguration?: SubResource;
    subnet?: SubResource;
    virtualNetwork?: SubResource;
}

// @public
export type LoadBalancerBackendAddressAdminState = string;

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

// @public
export interface LoadBalancerBackendAddressPools {
    beginCreateOrUpdate(resourceGroupName: string, loadBalancerName: string, backendAddressPoolName: string, parameters: BackendAddressPool, options?: LoadBalancerBackendAddressPoolsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<LoadBalancerBackendAddressPoolsCreateOrUpdateResponse>, LoadBalancerBackendAddressPoolsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, loadBalancerName: string, backendAddressPoolName: string, parameters: BackendAddressPool, options?: LoadBalancerBackendAddressPoolsCreateOrUpdateOptionalParams): Promise<LoadBalancerBackendAddressPoolsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, loadBalancerName: string, backendAddressPoolName: string, options?: LoadBalancerBackendAddressPoolsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, loadBalancerName: string, backendAddressPoolName: string, options?: LoadBalancerBackendAddressPoolsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, loadBalancerName: string, backendAddressPoolName: string, options?: LoadBalancerBackendAddressPoolsGetOptionalParams): Promise<LoadBalancerBackendAddressPoolsGetResponse>;
    list(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancerBackendAddressPoolsListOptionalParams): PagedAsyncIterableIterator<BackendAddressPool>;
}

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

// @public
export type LoadBalancerBackendAddressPoolsCreateOrUpdateResponse = BackendAddressPool;

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

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

// @public
export type LoadBalancerBackendAddressPoolsGetResponse = BackendAddressPool;

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

// @public
export type LoadBalancerBackendAddressPoolsListNextResponse = LoadBalancerBackendAddressPoolListResult;

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

// @public
export type LoadBalancerBackendAddressPoolsListResponse = LoadBalancerBackendAddressPoolListResult;

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

// @public
export interface LoadBalancerFrontendIPConfigurations {
    get(resourceGroupName: string, loadBalancerName: string, frontendIPConfigurationName: string, options?: LoadBalancerFrontendIPConfigurationsGetOptionalParams): Promise<LoadBalancerFrontendIPConfigurationsGetResponse>;
    list(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancerFrontendIPConfigurationsListOptionalParams): PagedAsyncIterableIterator<FrontendIPConfiguration>;
}

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

// @public
export type LoadBalancerFrontendIPConfigurationsGetResponse = FrontendIPConfiguration;

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

// @public
export type LoadBalancerFrontendIPConfigurationsListNextResponse = LoadBalancerFrontendIPConfigurationListResult;

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

// @public
export type LoadBalancerFrontendIPConfigurationsListResponse = LoadBalancerFrontendIPConfigurationListResult;

// @public
export interface LoadBalancerHealthPerRule {
    down?: number;
    loadBalancerBackendAddresses?: LoadBalancerHealthPerRulePerBackendAddress[];
    up?: number;
}

// @public
export interface LoadBalancerHealthPerRulePerBackendAddress {
    ipAddress?: string;
    networkInterfaceIPConfigurationId?: string;
    reason?: string;
    state?: string;
}

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

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

// @public
export interface LoadBalancerLoadBalancingRules {
    beginHealth(groupName: string, loadBalancerName: string, loadBalancingRuleName: string, options?: LoadBalancerLoadBalancingRulesHealthOptionalParams): Promise<SimplePollerLike<OperationState<LoadBalancerLoadBalancingRulesHealthResponse>, LoadBalancerLoadBalancingRulesHealthResponse>>;
    beginHealthAndWait(groupName: string, loadBalancerName: string, loadBalancingRuleName: string, options?: LoadBalancerLoadBalancingRulesHealthOptionalParams): Promise<LoadBalancerLoadBalancingRulesHealthResponse>;
    get(resourceGroupName: string, loadBalancerName: string, loadBalancingRuleName: string, options?: LoadBalancerLoadBalancingRulesGetOptionalParams): Promise<LoadBalancerLoadBalancingRulesGetResponse>;
    list(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancerLoadBalancingRulesListOptionalParams): PagedAsyncIterableIterator<LoadBalancingRule>;
}

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

// @public
export type LoadBalancerLoadBalancingRulesGetResponse = LoadBalancingRule;

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

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

// @public
export type LoadBalancerLoadBalancingRulesHealthResponse = LoadBalancerHealthPerRule;

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

// @public
export type LoadBalancerLoadBalancingRulesListNextResponse = LoadBalancerLoadBalancingRuleListResult;

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

// @public
export type LoadBalancerLoadBalancingRulesListResponse = LoadBalancerLoadBalancingRuleListResult;

// @public
export interface LoadBalancerNetworkInterfaces {
    list(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancerNetworkInterfacesListOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
}

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

// @public
export type LoadBalancerNetworkInterfacesListNextResponse = NetworkInterfaceListResult;

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

// @public
export type LoadBalancerNetworkInterfacesListResponse = NetworkInterfaceListResult;

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

// @public
export type LoadBalancerOutboundRuleProtocol = string;

// @public
export interface LoadBalancerOutboundRules {
    get(resourceGroupName: string, loadBalancerName: string, outboundRuleName: string, options?: LoadBalancerOutboundRulesGetOptionalParams): Promise<LoadBalancerOutboundRulesGetResponse>;
    list(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancerOutboundRulesListOptionalParams): PagedAsyncIterableIterator<OutboundRule>;
}

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

// @public
export type LoadBalancerOutboundRulesGetResponse = OutboundRule;

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

// @public
export type LoadBalancerOutboundRulesListNextResponse = LoadBalancerOutboundRuleListResult;

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

// @public
export type LoadBalancerOutboundRulesListResponse = LoadBalancerOutboundRuleListResult;

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

// @public
export interface LoadBalancerProbes {
    get(resourceGroupName: string, loadBalancerName: string, probeName: string, options?: LoadBalancerProbesGetOptionalParams): Promise<LoadBalancerProbesGetResponse>;
    list(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancerProbesListOptionalParams): PagedAsyncIterableIterator<Probe>;
}

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

// @public
export type LoadBalancerProbesGetResponse = Probe;

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

// @public
export type LoadBalancerProbesListNextResponse = LoadBalancerProbeListResult;

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

// @public
export type LoadBalancerProbesListResponse = LoadBalancerProbeListResult;

// @public
export interface LoadBalancers {
    beginCreateOrUpdate(resourceGroupName: string, loadBalancerName: string, parameters: LoadBalancer, options?: LoadBalancersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<LoadBalancersCreateOrUpdateResponse>, LoadBalancersCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, loadBalancerName: string, parameters: LoadBalancer, options?: LoadBalancersCreateOrUpdateOptionalParams): Promise<LoadBalancersCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancersDeleteOptionalParams): Promise<void>;
    beginListInboundNatRulePortMappings(groupName: string, loadBalancerName: string, backendPoolName: string, parameters: QueryInboundNatRulePortMappingRequest, options?: LoadBalancersListInboundNatRulePortMappingsOptionalParams): Promise<SimplePollerLike<OperationState<LoadBalancersListInboundNatRulePortMappingsResponse>, LoadBalancersListInboundNatRulePortMappingsResponse>>;
    beginListInboundNatRulePortMappingsAndWait(groupName: string, loadBalancerName: string, backendPoolName: string, parameters: QueryInboundNatRulePortMappingRequest, options?: LoadBalancersListInboundNatRulePortMappingsOptionalParams): Promise<LoadBalancersListInboundNatRulePortMappingsResponse>;
    beginSwapPublicIpAddresses(location: string, parameters: LoadBalancerVipSwapRequest, options?: LoadBalancersSwapPublicIpAddressesOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginSwapPublicIpAddressesAndWait(location: string, parameters: LoadBalancerVipSwapRequest, options?: LoadBalancersSwapPublicIpAddressesOptionalParams): Promise<void>;
    get(resourceGroupName: string, loadBalancerName: string, options?: LoadBalancersGetOptionalParams): Promise<LoadBalancersGetResponse>;
    list(resourceGroupName: string, options?: LoadBalancersListOptionalParams): PagedAsyncIterableIterator<LoadBalancer>;
    listAll(options?: LoadBalancersListAllOptionalParams): PagedAsyncIterableIterator<LoadBalancer>;
    migrateToIpBased(groupName: string, loadBalancerName: string, options?: LoadBalancersMigrateToIpBasedOptionalParams): Promise<LoadBalancersMigrateToIpBasedResponse>;
    updateTags(resourceGroupName: string, loadBalancerName: string, parameters: TagsObject, options?: LoadBalancersUpdateTagsOptionalParams): Promise<LoadBalancersUpdateTagsResponse>;
}

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

// @public
export type LoadBalancersCreateOrUpdateResponse = LoadBalancer;

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

// @public
export interface LoadBalancersGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type LoadBalancersGetResponse = LoadBalancer;

// @public
export interface LoadBalancerSku {
    name?: LoadBalancerSkuName;
    tier?: LoadBalancerSkuTier;
}

// @public
export type LoadBalancerSkuName = string;

// @public
export type LoadBalancerSkuTier = string;

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

// @public
export type LoadBalancersListAllNextResponse = LoadBalancerListResult;

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

// @public
export type LoadBalancersListAllResponse = LoadBalancerListResult;

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

// @public
export type LoadBalancersListInboundNatRulePortMappingsResponse = BackendAddressInboundNatRulePortMappings;

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

// @public
export type LoadBalancersListNextResponse = LoadBalancerListResult;

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

// @public
export type LoadBalancersListResponse = LoadBalancerListResult;

// @public
export interface LoadBalancersMigrateToIpBasedOptionalParams extends coreClient.OperationOptions {
    parameters?: MigrateLoadBalancerToIpBasedRequest;
}

// @public
export type LoadBalancersMigrateToIpBasedResponse = MigratedPools;

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

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

// @public
export type LoadBalancersUpdateTagsResponse = LoadBalancer;

// @public
export interface LoadBalancerVipSwapRequest {
    frontendIPConfigurations?: LoadBalancerVipSwapRequestFrontendIPConfiguration[];
}

// @public
export interface LoadBalancerVipSwapRequestFrontendIPConfiguration {
    id?: string;
    publicIPAddress?: SubResource;
}

// @public
export interface LoadBalancingRule extends SubResource {
    backendAddressPool?: SubResource;
    backendAddressPools?: SubResource[];
    backendPort?: number;
    disableOutboundSnat?: boolean;
    enableConnectionTracking?: boolean;
    enableFloatingIP?: boolean;
    enableTcpReset?: boolean;
    readonly etag?: string;
    frontendIPConfiguration?: SubResource;
    frontendPort?: number;
    idleTimeoutInMinutes?: number;
    loadDistribution?: LoadDistribution;
    name?: string;
    probe?: SubResource;
    protocol?: TransportProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export type LoadDistribution = string;

// @public
export interface LocalNetworkGateway extends Resource {
    bgpSettings?: BgpSettings;
    readonly etag?: string;
    fqdn?: string;
    gatewayIpAddress?: string;
    localNetworkAddressSpace?: AddressSpace;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

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

// @public
export interface LocalNetworkGateways {
    beginCreateOrUpdate(resourceGroupName: string, localNetworkGatewayName: string, parameters: LocalNetworkGateway, options?: LocalNetworkGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<LocalNetworkGatewaysCreateOrUpdateResponse>, LocalNetworkGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, localNetworkGatewayName: string, parameters: LocalNetworkGateway, options?: LocalNetworkGatewaysCreateOrUpdateOptionalParams): Promise<LocalNetworkGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, localNetworkGatewayName: string, options?: LocalNetworkGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, localNetworkGatewayName: string, options?: LocalNetworkGatewaysDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, localNetworkGatewayName: string, options?: LocalNetworkGatewaysGetOptionalParams): Promise<LocalNetworkGatewaysGetResponse>;
    list(resourceGroupName: string, options?: LocalNetworkGatewaysListOptionalParams): PagedAsyncIterableIterator<LocalNetworkGateway>;
    updateTags(resourceGroupName: string, localNetworkGatewayName: string, parameters: TagsObject, options?: LocalNetworkGatewaysUpdateTagsOptionalParams): Promise<LocalNetworkGatewaysUpdateTagsResponse>;
}

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

// @public
export type LocalNetworkGatewaysCreateOrUpdateResponse = LocalNetworkGateway;

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

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

// @public
export type LocalNetworkGatewaysGetResponse = LocalNetworkGateway;

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

// @public
export type LocalNetworkGatewaysListNextResponse = LocalNetworkGatewayListResult;

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

// @public
export type LocalNetworkGatewaysListResponse = LocalNetworkGatewayListResult;

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

// @public
export type LocalNetworkGatewaysUpdateTagsResponse = LocalNetworkGateway;

// @public
export interface LogSpecification {
    blobDuration?: string;
    displayName?: string;
    name?: string;
}

// @public
export type ManagedRuleEnabledState = string;

// @public
export interface ManagedRuleGroupOverride {
    ruleGroupName: string;
    rules?: ManagedRuleOverride[];
}

// @public
export interface ManagedRuleOverride {
    action?: ActionType;
    ruleId: string;
    sensitivity?: SensitivityType;
    state?: ManagedRuleEnabledState;
}

// @public
export interface ManagedRulesDefinition {
    exceptions?: ExceptionEntry[];
    exclusions?: OwaspCrsExclusionEntry[];
    managedRuleSets: ManagedRuleSet[];
}

// @public
export interface ManagedRuleSet {
    readonly computedDisabledRules?: ManagedRuleSetRuleGroup[];
    ruleGroupOverrides?: ManagedRuleGroupOverride[];
    ruleSetType: string;
    ruleSetVersion: string;
}

// @public
export interface ManagedRuleSetRuleGroup {
    ruleGroupName: string;
    rules?: string[];
}

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

// @public
export interface ManagementGroupNetworkManagerConnections {
    createOrUpdate(managementGroupId: string, networkManagerConnectionName: string, parameters: NetworkManagerConnection, options?: ManagementGroupNetworkManagerConnectionsCreateOrUpdateOptionalParams): Promise<ManagementGroupNetworkManagerConnectionsCreateOrUpdateResponse>;
    delete(managementGroupId: string, networkManagerConnectionName: string, options?: ManagementGroupNetworkManagerConnectionsDeleteOptionalParams): Promise<void>;
    get(managementGroupId: string, networkManagerConnectionName: string, options?: ManagementGroupNetworkManagerConnectionsGetOptionalParams): Promise<ManagementGroupNetworkManagerConnectionsGetResponse>;
    list(managementGroupId: string, options?: ManagementGroupNetworkManagerConnectionsListOptionalParams): PagedAsyncIterableIterator<NetworkManagerConnection>;
}

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

// @public
export type ManagementGroupNetworkManagerConnectionsCreateOrUpdateResponse = NetworkManagerConnection;

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

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

// @public
export type ManagementGroupNetworkManagerConnectionsGetResponse = NetworkManagerConnection;

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

// @public
export type ManagementGroupNetworkManagerConnectionsListNextResponse = NetworkManagerConnectionListResult;

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

// @public
export type ManagementGroupNetworkManagerConnectionsListResponse = NetworkManagerConnectionListResult;

// @public
export interface MatchCondition {
    matchValues: string[];
    matchVariables: MatchVariable[];
    negationConditon?: boolean;
    operator: WebApplicationFirewallOperator;
    transforms?: WebApplicationFirewallTransform[];
}

// @public
export interface MatchedRule {
    action?: string;
    ruleName?: string;
}

// @public
export interface MatchVariable {
    selector?: string;
    variableName: WebApplicationFirewallMatchVariable;
}

// @public
export interface MetricSpecification {
    aggregationType?: string;
    availabilities?: Availability[];
    dimensions?: Dimension[];
    displayDescription?: string;
    displayName?: string;
    enableRegionalMdmAccount?: boolean;
    fillGapWithZero?: boolean;
    isInternal?: boolean;
    metricFilterPattern?: string;
    name?: string;
    resourceIdDimensionNameOverride?: string;
    sourceMdmAccount?: string;
    sourceMdmNamespace?: string;
    unit?: string;
}

// @public
export interface MigratedPools {
    migratedPools?: string[];
}

// @public
export interface MigrateLoadBalancerToIpBasedRequest {
    pools?: string[];
}

// @public
export interface NatGateway extends Resource {
    readonly etag?: string;
    idleTimeoutInMinutes?: number;
    readonly provisioningState?: ProvisioningState;
    publicIpAddresses?: SubResource[];
    publicIpAddressesV6?: SubResource[];
    publicIpPrefixes?: SubResource[];
    publicIpPrefixesV6?: SubResource[];
    readonly resourceGuid?: string;
    sku?: NatGatewaySku;
    sourceVirtualNetwork?: SubResource;
    readonly subnets?: SubResource[];
    zones?: string[];
}

// @public
export interface NatGatewayListResult {
    nextLink?: string;
    value?: NatGateway[];
}

// @public
export interface NatGateways {
    beginCreateOrUpdate(resourceGroupName: string, natGatewayName: string, parameters: NatGateway, options?: NatGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NatGatewaysCreateOrUpdateResponse>, NatGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, natGatewayName: string, parameters: NatGateway, options?: NatGatewaysCreateOrUpdateOptionalParams): Promise<NatGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, natGatewayName: string, options?: NatGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, natGatewayName: string, options?: NatGatewaysDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, natGatewayName: string, options?: NatGatewaysGetOptionalParams): Promise<NatGatewaysGetResponse>;
    list(resourceGroupName: string, options?: NatGatewaysListOptionalParams): PagedAsyncIterableIterator<NatGateway>;
    listAll(options?: NatGatewaysListAllOptionalParams): PagedAsyncIterableIterator<NatGateway>;
    updateTags(resourceGroupName: string, natGatewayName: string, parameters: TagsObject, options?: NatGatewaysUpdateTagsOptionalParams): Promise<NatGatewaysUpdateTagsResponse>;
}

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

// @public
export type NatGatewaysCreateOrUpdateResponse = NatGateway;

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

// @public
export interface NatGatewaysGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NatGatewaysGetResponse = NatGateway;

// @public
export interface NatGatewaySku {
    name?: NatGatewaySkuName;
}

// @public
export type NatGatewaySkuName = string;

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

// @public
export type NatGatewaysListAllNextResponse = NatGatewayListResult;

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

// @public
export type NatGatewaysListAllResponse = NatGatewayListResult;

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

// @public
export type NatGatewaysListNextResponse = NatGatewayListResult;

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

// @public
export type NatGatewaysListResponse = NatGatewayListResult;

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

// @public
export type NatGatewaysUpdateTagsResponse = NatGateway;

// @public
export interface NatRule extends FirewallPolicyRule {
    destinationAddresses?: string[];
    destinationPorts?: string[];
    ipProtocols?: FirewallPolicyRuleNetworkProtocol[];
    ruleType: "NatRule";
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
    translatedAddress?: string;
    translatedFqdn?: string;
    translatedPort?: string;
}

// @public
export interface NatRulePortMapping {
    backendPort?: number;
    frontendPort?: number;
    inboundNatRuleName?: string;
}

// @public
export interface NatRules {
    beginCreateOrUpdate(resourceGroupName: string, gatewayName: string, natRuleName: string, natRuleParameters: VpnGatewayNatRule, options?: NatRulesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NatRulesCreateOrUpdateResponse>, NatRulesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, gatewayName: string, natRuleName: string, natRuleParameters: VpnGatewayNatRule, options?: NatRulesCreateOrUpdateOptionalParams): Promise<NatRulesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, gatewayName: string, natRuleName: string, options?: NatRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, gatewayName: string, natRuleName: string, options?: NatRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, gatewayName: string, natRuleName: string, options?: NatRulesGetOptionalParams): Promise<NatRulesGetResponse>;
    listByVpnGateway(resourceGroupName: string, gatewayName: string, options?: NatRulesListByVpnGatewayOptionalParams): PagedAsyncIterableIterator<VpnGatewayNatRule>;
}

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

// @public
export type NatRulesCreateOrUpdateResponse = VpnGatewayNatRule;

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

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

// @public
export type NatRulesGetResponse = VpnGatewayNatRule;

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

// @public
export type NatRulesListByVpnGatewayNextResponse = ListVpnGatewayNatRulesResult;

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

// @public
export type NatRulesListByVpnGatewayResponse = ListVpnGatewayNatRulesResult;

// @public
export interface NetworkConfigurationDiagnosticParameters {
    profiles: NetworkConfigurationDiagnosticProfile[];
    targetResourceId: string;
    verbosityLevel?: VerbosityLevel;
}

// @public
export interface NetworkConfigurationDiagnosticProfile {
    destination: string;
    destinationPort: string;
    direction: Direction;
    protocol: string;
    source: string;
}

// @public
export interface NetworkConfigurationDiagnosticResponse {
    readonly results?: NetworkConfigurationDiagnosticResult[];
}

// @public
export interface NetworkConfigurationDiagnosticResult {
    networkSecurityGroupResult?: NetworkSecurityGroupResult;
    profile?: NetworkConfigurationDiagnosticProfile;
}

// @public
export interface NetworkGroup extends ChildResource {
    description?: string;
    memberType?: GroupMemberType;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface NetworkGroupListResult {
    nextLink?: string;
    value?: NetworkGroup[];
}

// @public
export interface NetworkGroups {
    beginDelete(resourceGroupName: string, networkManagerName: string, networkGroupName: string, options?: NetworkGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, networkGroupName: string, options?: NetworkGroupsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, networkGroupName: string, parameters: NetworkGroup, options?: NetworkGroupsCreateOrUpdateOptionalParams): Promise<NetworkGroupsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, networkGroupName: string, options?: NetworkGroupsGetOptionalParams): Promise<NetworkGroupsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: NetworkGroupsListOptionalParams): PagedAsyncIterableIterator<NetworkGroup>;
}

// @public
export interface NetworkGroupsCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface NetworkGroupsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type NetworkGroupsCreateOrUpdateResponse = NetworkGroupsCreateOrUpdateHeaders & NetworkGroup;

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

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

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

// @public
export type NetworkGroupsGetResponse = NetworkGroup;

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

// @public
export type NetworkGroupsListNextResponse = NetworkGroupListResult;

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

// @public
export type NetworkGroupsListResponse = NetworkGroupListResult;

// @public
export interface NetworkIntentPolicy extends Resource {
    readonly etag?: string;
}

// @public
export type NetworkIntentPolicyBasedService = string;

// @public
export interface NetworkIntentPolicyConfiguration {
    networkIntentPolicyName?: string;
    sourceNetworkIntentPolicy?: NetworkIntentPolicy;
}

// @public
export interface NetworkInterface extends Resource {
    auxiliaryMode?: NetworkInterfaceAuxiliaryMode;
    auxiliarySku?: NetworkInterfaceAuxiliarySku;
    readonly defaultOutboundConnectivityEnabled?: boolean;
    disableTcpStateTracking?: boolean;
    dnsSettings?: NetworkInterfaceDnsSettings;
    readonly dscpConfiguration?: SubResource;
    enableAcceleratedNetworking?: boolean;
    enableIPForwarding?: boolean;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    readonly hostedWorkloads?: string[];
    ipConfigurations?: NetworkInterfaceIPConfiguration[];
    readonly macAddress?: string;
    migrationPhase?: NetworkInterfaceMigrationPhase;
    networkSecurityGroup?: NetworkSecurityGroup;
    nicType?: NetworkInterfaceNicType;
    readonly primary?: boolean;
    readonly privateEndpoint?: PrivateEndpoint;
    privateLinkService?: PrivateLinkService;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly tapConfigurations?: NetworkInterfaceTapConfiguration[];
    readonly virtualMachine?: SubResource;
    readonly vnetEncryptionSupported?: boolean;
    workloadType?: string;
}

// @public
export interface NetworkInterfaceAssociation {
    readonly id?: string;
    securityRules?: SecurityRule[];
}

// @public
export type NetworkInterfaceAuxiliaryMode = string;

// @public
export type NetworkInterfaceAuxiliarySku = string;

// @public
export interface NetworkInterfaceDnsSettings {
    readonly appliedDnsServers?: string[];
    dnsServers?: string[];
    internalDnsNameLabel?: string;
    readonly internalDomainNameSuffix?: string;
    readonly internalFqdn?: string;
}

// @public
export interface NetworkInterfaceIPConfiguration extends SubResource {
    applicationGatewayBackendAddressPools?: ApplicationGatewayBackendAddressPool[];
    applicationSecurityGroups?: ApplicationSecurityGroup[];
    readonly etag?: string;
    gatewayLoadBalancer?: SubResource;
    loadBalancerBackendAddressPools?: BackendAddressPool[];
    loadBalancerInboundNatRules?: InboundNatRule[];
    name?: string;
    primary?: boolean;
    privateIPAddress?: string;
    privateIPAddressPrefixLength?: number;
    privateIPAddressVersion?: IPVersion;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly privateLinkConnectionProperties?: NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: PublicIPAddress;
    subnet?: Subnet;
    type?: string;
    virtualNetworkTaps?: VirtualNetworkTap[];
}

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

// @public
export interface NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties {
    readonly fqdns?: string[];
    readonly groupId?: string;
    readonly requiredMemberName?: string;
}

// @public
export interface NetworkInterfaceIPConfigurations {
    get(resourceGroupName: string, networkInterfaceName: string, ipConfigurationName: string, options?: NetworkInterfaceIPConfigurationsGetOptionalParams): Promise<NetworkInterfaceIPConfigurationsGetResponse>;
    list(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfaceIPConfigurationsListOptionalParams): PagedAsyncIterableIterator<NetworkInterfaceIPConfiguration>;
}

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

// @public
export type NetworkInterfaceIPConfigurationsGetResponse = NetworkInterfaceIPConfiguration;

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

// @public
export type NetworkInterfaceIPConfigurationsListNextResponse = NetworkInterfaceIPConfigurationListResult;

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

// @public
export type NetworkInterfaceIPConfigurationsListResponse = NetworkInterfaceIPConfigurationListResult;

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

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

// @public
export interface NetworkInterfaceLoadBalancers {
    list(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfaceLoadBalancersListOptionalParams): PagedAsyncIterableIterator<LoadBalancer>;
}

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

// @public
export type NetworkInterfaceLoadBalancersListNextResponse = NetworkInterfaceLoadBalancerListResult;

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

// @public
export type NetworkInterfaceLoadBalancersListResponse = NetworkInterfaceLoadBalancerListResult;

// @public
export type NetworkInterfaceMigrationPhase = string;

// @public
export type NetworkInterfaceNicType = string;

// @public
export interface NetworkInterfaces {
    beginCreateOrUpdate(resourceGroupName: string, networkInterfaceName: string, parameters: NetworkInterface, options?: NetworkInterfacesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfacesCreateOrUpdateResponse>, NetworkInterfacesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkInterfaceName: string, parameters: NetworkInterface, options?: NetworkInterfacesCreateOrUpdateOptionalParams): Promise<NetworkInterfacesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesDeleteOptionalParams): Promise<void>;
    beginGetEffectiveRouteTable(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesGetEffectiveRouteTableOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfacesGetEffectiveRouteTableResponse>, NetworkInterfacesGetEffectiveRouteTableResponse>>;
    beginGetEffectiveRouteTableAndWait(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesGetEffectiveRouteTableOptionalParams): Promise<NetworkInterfacesGetEffectiveRouteTableResponse>;
    beginListEffectiveNetworkSecurityGroups(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesListEffectiveNetworkSecurityGroupsOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfacesListEffectiveNetworkSecurityGroupsResponse>, NetworkInterfacesListEffectiveNetworkSecurityGroupsResponse>>;
    beginListEffectiveNetworkSecurityGroupsAndWait(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesListEffectiveNetworkSecurityGroupsOptionalParams): Promise<NetworkInterfacesListEffectiveNetworkSecurityGroupsResponse>;
    get(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesGetOptionalParams): Promise<NetworkInterfacesGetResponse>;
    getCloudServiceNetworkInterface(resourceGroupName: string, cloudServiceName: string, roleInstanceName: string, networkInterfaceName: string, options?: NetworkInterfacesGetCloudServiceNetworkInterfaceOptionalParams): Promise<NetworkInterfacesGetCloudServiceNetworkInterfaceResponse>;
    getVirtualMachineScaleSetIpConfiguration(resourceGroupName: string, virtualMachineScaleSetName: string, virtualmachineIndex: string, networkInterfaceName: string, ipConfigurationName: string, options?: NetworkInterfacesGetVirtualMachineScaleSetIpConfigurationOptionalParams): Promise<NetworkInterfacesGetVirtualMachineScaleSetIpConfigurationResponse>;
    getVirtualMachineScaleSetNetworkInterface(resourceGroupName: string, virtualMachineScaleSetName: string, virtualmachineIndex: string, networkInterfaceName: string, options?: NetworkInterfacesGetVirtualMachineScaleSetNetworkInterfaceOptionalParams): Promise<NetworkInterfacesGetVirtualMachineScaleSetNetworkInterfaceResponse>;
    list(resourceGroupName: string, options?: NetworkInterfacesListOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
    listAll(options?: NetworkInterfacesListAllOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
    listCloudServiceNetworkInterfaces(resourceGroupName: string, cloudServiceName: string, options?: NetworkInterfacesListCloudServiceNetworkInterfacesOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
    listCloudServiceRoleInstanceNetworkInterfaces(resourceGroupName: string, cloudServiceName: string, roleInstanceName: string, options?: NetworkInterfacesListCloudServiceRoleInstanceNetworkInterfacesOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
    listVirtualMachineScaleSetIpConfigurations(resourceGroupName: string, virtualMachineScaleSetName: string, virtualmachineIndex: string, networkInterfaceName: string, options?: NetworkInterfacesListVirtualMachineScaleSetIpConfigurationsOptionalParams): PagedAsyncIterableIterator<NetworkInterfaceIPConfiguration>;
    listVirtualMachineScaleSetNetworkInterfaces(resourceGroupName: string, virtualMachineScaleSetName: string, options?: NetworkInterfacesListVirtualMachineScaleSetNetworkInterfacesOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
    listVirtualMachineScaleSetVMNetworkInterfaces(resourceGroupName: string, virtualMachineScaleSetName: string, virtualmachineIndex: string, options?: NetworkInterfacesListVirtualMachineScaleSetVMNetworkInterfacesOptionalParams): PagedAsyncIterableIterator<NetworkInterface>;
    updateTags(resourceGroupName: string, networkInterfaceName: string, parameters: TagsObject, options?: NetworkInterfacesUpdateTagsOptionalParams): Promise<NetworkInterfacesUpdateTagsResponse>;
}

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

// @public
export type NetworkInterfacesCreateOrUpdateResponse = NetworkInterface;

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

// @public
export interface NetworkInterfacesGetCloudServiceNetworkInterfaceOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkInterfacesGetCloudServiceNetworkInterfaceResponse = NetworkInterface;

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

// @public
export type NetworkInterfacesGetEffectiveRouteTableResponse = EffectiveRouteListResult;

// @public
export interface NetworkInterfacesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkInterfacesGetResponse = NetworkInterface;

// @public
export interface NetworkInterfacesGetVirtualMachineScaleSetIpConfigurationOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkInterfacesGetVirtualMachineScaleSetIpConfigurationResponse = NetworkInterfaceIPConfiguration;

// @public
export interface NetworkInterfacesGetVirtualMachineScaleSetNetworkInterfaceOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkInterfacesGetVirtualMachineScaleSetNetworkInterfaceResponse = NetworkInterface;

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

// @public
export type NetworkInterfacesListAllNextResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListAllResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListCloudServiceNetworkInterfacesNextResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListCloudServiceNetworkInterfacesResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListCloudServiceRoleInstanceNetworkInterfacesNextResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListCloudServiceRoleInstanceNetworkInterfacesResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListEffectiveNetworkSecurityGroupsResponse = EffectiveNetworkSecurityGroupListResult;

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

// @public
export type NetworkInterfacesListNextResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListVirtualMachineScaleSetIpConfigurationsNextResponse = NetworkInterfaceIPConfigurationListResult;

// @public
export interface NetworkInterfacesListVirtualMachineScaleSetIpConfigurationsOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkInterfacesListVirtualMachineScaleSetIpConfigurationsResponse = NetworkInterfaceIPConfigurationListResult;

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

// @public
export type NetworkInterfacesListVirtualMachineScaleSetNetworkInterfacesNextResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListVirtualMachineScaleSetNetworkInterfacesResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListVirtualMachineScaleSetVMNetworkInterfacesNextResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesListVirtualMachineScaleSetVMNetworkInterfacesResponse = NetworkInterfaceListResult;

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

// @public
export type NetworkInterfacesUpdateTagsResponse = NetworkInterface;

// @public
export interface NetworkInterfaceTapConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
    virtualNetworkTap?: VirtualNetworkTap;
}

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

// @public
export interface NetworkInterfaceTapConfigurations {
    beginCreateOrUpdate(resourceGroupName: string, networkInterfaceName: string, tapConfigurationName: string, tapConfigurationParameters: NetworkInterfaceTapConfiguration, options?: NetworkInterfaceTapConfigurationsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfaceTapConfigurationsCreateOrUpdateResponse>, NetworkInterfaceTapConfigurationsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkInterfaceName: string, tapConfigurationName: string, tapConfigurationParameters: NetworkInterfaceTapConfiguration, options?: NetworkInterfaceTapConfigurationsCreateOrUpdateOptionalParams): Promise<NetworkInterfaceTapConfigurationsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkInterfaceName: string, tapConfigurationName: string, options?: NetworkInterfaceTapConfigurationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkInterfaceName: string, tapConfigurationName: string, options?: NetworkInterfaceTapConfigurationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkInterfaceName: string, tapConfigurationName: string, options?: NetworkInterfaceTapConfigurationsGetOptionalParams): Promise<NetworkInterfaceTapConfigurationsGetResponse>;
    list(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfaceTapConfigurationsListOptionalParams): PagedAsyncIterableIterator<NetworkInterfaceTapConfiguration>;
}

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

// @public
export type NetworkInterfaceTapConfigurationsCreateOrUpdateResponse = NetworkInterfaceTapConfiguration;

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

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

// @public
export type NetworkInterfaceTapConfigurationsGetResponse = NetworkInterfaceTapConfiguration;

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

// @public
export type NetworkInterfaceTapConfigurationsListNextResponse = NetworkInterfaceTapConfigurationListResult;

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

// @public
export type NetworkInterfaceTapConfigurationsListResponse = NetworkInterfaceTapConfigurationListResult;

// @public (undocumented)
export class NetworkManagementClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: NetworkManagementClientOptionalParams);
    constructor(credentials: coreAuth.TokenCredential, options?: NetworkManagementClientOptionalParams);
    // (undocumented)
    adminRuleCollections: AdminRuleCollections;
    // (undocumented)
    adminRules: AdminRules;
    // (undocumented)
    applicationGatewayPrivateEndpointConnections: ApplicationGatewayPrivateEndpointConnections;
    // (undocumented)
    applicationGatewayPrivateLinkResources: ApplicationGatewayPrivateLinkResources;
    // (undocumented)
    applicationGateways: ApplicationGateways;
    // (undocumented)
    applicationGatewayWafDynamicManifests: ApplicationGatewayWafDynamicManifests;
    // (undocumented)
    applicationGatewayWafDynamicManifestsDefault: ApplicationGatewayWafDynamicManifestsDefault;
    // (undocumented)
    applicationSecurityGroups: ApplicationSecurityGroups;
    // (undocumented)
    availableDelegations: AvailableDelegations;
    // (undocumented)
    availableEndpointServices: AvailableEndpointServices;
    // (undocumented)
    availablePrivateEndpointTypes: AvailablePrivateEndpointTypes;
    // (undocumented)
    availableResourceGroupDelegations: AvailableResourceGroupDelegations;
    // (undocumented)
    availableServiceAliases: AvailableServiceAliases;
    // (undocumented)
    azureFirewallFqdnTags: AzureFirewallFqdnTags;
    // (undocumented)
    azureFirewalls: AzureFirewalls;
    // (undocumented)
    bastionHosts: BastionHosts;
    beginDeleteBastionShareableLink(resourceGroupName: string, bastionHostName: string, bslRequest: BastionShareableLinkListRequest, options?: DeleteBastionShareableLinkOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteBastionShareableLinkAndWait(resourceGroupName: string, bastionHostName: string, bslRequest: BastionShareableLinkListRequest, options?: DeleteBastionShareableLinkOptionalParams): Promise<void>;
    beginDeleteBastionShareableLinkByToken(resourceGroupName: string, bastionHostName: string, bslTokenRequest: BastionShareableLinkTokenListRequest, options?: DeleteBastionShareableLinkByTokenOptionalParams): Promise<SimplePollerLike<OperationState<DeleteBastionShareableLinkByTokenResponse>, DeleteBastionShareableLinkByTokenResponse>>;
    beginDeleteBastionShareableLinkByTokenAndWait(resourceGroupName: string, bastionHostName: string, bslTokenRequest: BastionShareableLinkTokenListRequest, options?: DeleteBastionShareableLinkByTokenOptionalParams): Promise<DeleteBastionShareableLinkByTokenResponse>;
    beginGeneratevirtualwanvpnserverconfigurationvpnprofile(resourceGroupName: string, virtualWANName: string, vpnClientParams: VirtualWanVpnProfileParameters, options?: GeneratevirtualwanvpnserverconfigurationvpnprofileOptionalParams): Promise<SimplePollerLike<OperationState<GeneratevirtualwanvpnserverconfigurationvpnprofileResponse>, GeneratevirtualwanvpnserverconfigurationvpnprofileResponse>>;
    beginGeneratevirtualwanvpnserverconfigurationvpnprofileAndWait(resourceGroupName: string, virtualWANName: string, vpnClientParams: VirtualWanVpnProfileParameters, options?: GeneratevirtualwanvpnserverconfigurationvpnprofileOptionalParams): Promise<GeneratevirtualwanvpnserverconfigurationvpnprofileResponse>;
    beginListActiveSessionsAndWait(resourceGroupName: string, bastionHostName: string, options?: GetActiveSessionsOptionalParams): PagedAsyncIterableIterator<BastionActiveSession>;
    beginListPutBastionShareableLinkAndWait(resourceGroupName: string, bastionHostName: string, bslRequest: BastionShareableLinkListRequest, options?: PutBastionShareableLinkOptionalParams): PagedAsyncIterableIterator<BastionShareableLink>;
    // (undocumented)
    bgpServiceCommunities: BgpServiceCommunities;
    checkDnsNameAvailability(location: string, domainNameLabel: string, options?: CheckDnsNameAvailabilityOptionalParams): Promise<CheckDnsNameAvailabilityResponse>;
    // (undocumented)
    configurationPolicyGroups: ConfigurationPolicyGroups;
    // (undocumented)
    connectionMonitors: ConnectionMonitors;
    // (undocumented)
    connectivityConfigurations: ConnectivityConfigurations;
    // (undocumented)
    customIPPrefixes: CustomIPPrefixes;
    // (undocumented)
    ddosCustomPolicies: DdosCustomPolicies;
    // (undocumented)
    ddosProtectionPlans: DdosProtectionPlans;
    // (undocumented)
    defaultSecurityRules: DefaultSecurityRules;
    // (undocumented)
    dscpConfigurationOperations: DscpConfigurationOperations;
    // (undocumented)
    expressRouteCircuitAuthorizations: ExpressRouteCircuitAuthorizations;
    // (undocumented)
    expressRouteCircuitConnections: ExpressRouteCircuitConnections;
    // (undocumented)
    expressRouteCircuitPeerings: ExpressRouteCircuitPeerings;
    // (undocumented)
    expressRouteCircuits: ExpressRouteCircuits;
    // (undocumented)
    expressRouteConnections: ExpressRouteConnections;
    // (undocumented)
    expressRouteCrossConnectionPeerings: ExpressRouteCrossConnectionPeerings;
    // (undocumented)
    expressRouteCrossConnections: ExpressRouteCrossConnections;
    // (undocumented)
    expressRouteGateways: ExpressRouteGateways;
    // (undocumented)
    expressRouteLinks: ExpressRouteLinks;
    // (undocumented)
    expressRoutePortAuthorizations: ExpressRoutePortAuthorizations;
    // (undocumented)
    expressRoutePorts: ExpressRoutePorts;
    // (undocumented)
    expressRoutePortsLocations: ExpressRoutePortsLocations;
    expressRouteProviderPort(providerport: string, options?: ExpressRouteProviderPortOptionalParams): Promise<ExpressRouteProviderPortResponse>;
    // (undocumented)
    expressRouteProviderPortsLocation: ExpressRouteProviderPortsLocation;
    // (undocumented)
    expressRouteServiceProviders: ExpressRouteServiceProviders;
    // (undocumented)
    firewallPolicies: FirewallPolicies;
    // (undocumented)
    firewallPolicyDeployments: FirewallPolicyDeployments;
    // (undocumented)
    firewallPolicyDrafts: FirewallPolicyDrafts;
    // (undocumented)
    firewallPolicyIdpsSignatures: FirewallPolicyIdpsSignatures;
    // (undocumented)
    firewallPolicyIdpsSignaturesFilterValues: FirewallPolicyIdpsSignaturesFilterValues;
    // (undocumented)
    firewallPolicyIdpsSignaturesOverrides: FirewallPolicyIdpsSignaturesOverrides;
    // (undocumented)
    firewallPolicyRuleCollectionGroupDrafts: FirewallPolicyRuleCollectionGroupDrafts;
    // (undocumented)
    firewallPolicyRuleCollectionGroups: FirewallPolicyRuleCollectionGroups;
    // (undocumented)
    flowLogs: FlowLogs;
    // (undocumented)
    hubRouteTables: HubRouteTables;
    // (undocumented)
    hubVirtualNetworkConnections: HubVirtualNetworkConnections;
    // (undocumented)
    inboundNatRules: InboundNatRules;
    // (undocumented)
    inboundSecurityRuleOperations: InboundSecurityRuleOperations;
    // (undocumented)
    ipAllocations: IpAllocations;
    // (undocumented)
    ipamPools: IpamPools;
    // (undocumented)
    ipGroups: IpGroups;
    listActiveConnectivityConfigurations(resourceGroupName: string, networkManagerName: string, parameters: ActiveConfigurationParameter, options?: ListActiveConnectivityConfigurationsOptionalParams): Promise<ListActiveConnectivityConfigurationsResponse>;
    listActiveSecurityAdminRules(resourceGroupName: string, networkManagerName: string, parameters: ActiveConfigurationParameter, options?: ListActiveSecurityAdminRulesOptionalParams): Promise<ListActiveSecurityAdminRulesResponse>;
    listBastionShareableLink(resourceGroupName: string, bastionHostName: string, bslRequest: BastionShareableLinkListRequest, options?: GetBastionShareableLinkOptionalParams): PagedAsyncIterableIterator<BastionShareableLink>;
    listDisconnectActiveSessions(resourceGroupName: string, bastionHostName: string, sessionIds: SessionIds, options?: DisconnectActiveSessionsOptionalParams): PagedAsyncIterableIterator<BastionSessionState>;
    listNetworkManagerEffectiveConnectivityConfigurations(resourceGroupName: string, virtualNetworkName: string, parameters: QueryRequestOptions, options?: ListNetworkManagerEffectiveConnectivityConfigurationsOptionalParams): Promise<ListNetworkManagerEffectiveConnectivityConfigurationsResponse>;
    listNetworkManagerEffectiveSecurityAdminRules(resourceGroupName: string, virtualNetworkName: string, parameters: QueryRequestOptions, options?: ListNetworkManagerEffectiveSecurityAdminRulesOptionalParams): Promise<ListNetworkManagerEffectiveSecurityAdminRulesResponse>;
    // (undocumented)
    loadBalancerBackendAddressPools: LoadBalancerBackendAddressPools;
    // (undocumented)
    loadBalancerFrontendIPConfigurations: LoadBalancerFrontendIPConfigurations;
    // (undocumented)
    loadBalancerLoadBalancingRules: LoadBalancerLoadBalancingRules;
    // (undocumented)
    loadBalancerNetworkInterfaces: LoadBalancerNetworkInterfaces;
    // (undocumented)
    loadBalancerOutboundRules: LoadBalancerOutboundRules;
    // (undocumented)
    loadBalancerProbes: LoadBalancerProbes;
    // (undocumented)
    loadBalancers: LoadBalancers;
    // (undocumented)
    localNetworkGateways: LocalNetworkGateways;
    // (undocumented)
    managementGroupNetworkManagerConnections: ManagementGroupNetworkManagerConnections;
    // (undocumented)
    natGateways: NatGateways;
    // (undocumented)
    natRules: NatRules;
    // (undocumented)
    networkGroups: NetworkGroups;
    // (undocumented)
    networkInterfaceIPConfigurations: NetworkInterfaceIPConfigurations;
    // (undocumented)
    networkInterfaceLoadBalancers: NetworkInterfaceLoadBalancers;
    // (undocumented)
    networkInterfaces: NetworkInterfaces;
    // (undocumented)
    networkInterfaceTapConfigurations: NetworkInterfaceTapConfigurations;
    // (undocumented)
    networkManagerCommits: NetworkManagerCommits;
    // (undocumented)
    networkManagerDeploymentStatusOperations: NetworkManagerDeploymentStatusOperations;
    // (undocumented)
    networkManagerRoutingConfigurations: NetworkManagerRoutingConfigurations;
    // (undocumented)
    networkManagers: NetworkManagers;
    // (undocumented)
    networkProfiles: NetworkProfiles;
    // (undocumented)
    networkSecurityGroups: NetworkSecurityGroups;
    // (undocumented)
    networkSecurityPerimeterAccessRules: NetworkSecurityPerimeterAccessRules;
    // (undocumented)
    networkSecurityPerimeterAssociableResourceTypes: NetworkSecurityPerimeterAssociableResourceTypes;
    // (undocumented)
    networkSecurityPerimeterAssociations: NetworkSecurityPerimeterAssociations;
    // (undocumented)
    networkSecurityPerimeterLinkReferences: NetworkSecurityPerimeterLinkReferences;
    // (undocumented)
    networkSecurityPerimeterLinks: NetworkSecurityPerimeterLinks;
    // (undocumented)
    networkSecurityPerimeterLoggingConfigurations: NetworkSecurityPerimeterLoggingConfigurations;
    // (undocumented)
    networkSecurityPerimeterOperationStatuses: NetworkSecurityPerimeterOperationStatuses;
    // (undocumented)
    networkSecurityPerimeterProfiles: NetworkSecurityPerimeterProfiles;
    // (undocumented)
    networkSecurityPerimeters: NetworkSecurityPerimeters;
    // (undocumented)
    networkVirtualApplianceConnections: NetworkVirtualApplianceConnections;
    // (undocumented)
    networkVirtualAppliances: NetworkVirtualAppliances;
    // (undocumented)
    networkWatchers: NetworkWatchers;
    // (undocumented)
    operations: Operations;
    // (undocumented)
    p2SVpnGateways: P2SVpnGateways;
    // (undocumented)
    packetCaptures: PacketCaptures;
    // (undocumented)
    peerExpressRouteCircuitConnections: PeerExpressRouteCircuitConnections;
    // (undocumented)
    privateDnsZoneGroups: PrivateDnsZoneGroups;
    // (undocumented)
    privateEndpoints: PrivateEndpoints;
    // (undocumented)
    privateLinkServices: PrivateLinkServices;
    // (undocumented)
    publicIPAddresses: PublicIPAddresses;
    // (undocumented)
    publicIPPrefixes: PublicIPPrefixes;
    // (undocumented)
    reachabilityAnalysisIntents: ReachabilityAnalysisIntents;
    // (undocumented)
    reachabilityAnalysisRuns: ReachabilityAnalysisRuns;
    // (undocumented)
    resourceNavigationLinks: ResourceNavigationLinks;
    // (undocumented)
    routeFilterRules: RouteFilterRules;
    // (undocumented)
    routeFilters: RouteFilters;
    // (undocumented)
    routeMaps: RouteMaps;
    // (undocumented)
    routes: Routes;
    // (undocumented)
    routeTables: RouteTables;
    // (undocumented)
    routingIntentOperations: RoutingIntentOperations;
    // (undocumented)
    routingRuleCollections: RoutingRuleCollections;
    // (undocumented)
    routingRules: RoutingRules;
    // (undocumented)
    scopeConnections: ScopeConnections;
    // (undocumented)
    securityAdminConfigurations: SecurityAdminConfigurations;
    // (undocumented)
    securityPartnerProviders: SecurityPartnerProviders;
    // (undocumented)
    securityRules: SecurityRules;
    // (undocumented)
    securityUserConfigurations: SecurityUserConfigurations;
    // (undocumented)
    securityUserRuleCollections: SecurityUserRuleCollections;
    // (undocumented)
    securityUserRules: SecurityUserRules;
    // (undocumented)
    serviceAssociationLinks: ServiceAssociationLinks;
    // (undocumented)
    serviceEndpointPolicies: ServiceEndpointPolicies;
    // (undocumented)
    serviceEndpointPolicyDefinitions: ServiceEndpointPolicyDefinitions;
    // (undocumented)
    serviceTagInformationOperations: ServiceTagInformationOperations;
    // (undocumented)
    serviceTags: ServiceTags;
    // (undocumented)
    staticCidrs: StaticCidrs;
    // (undocumented)
    staticMembers: StaticMembers;
    // (undocumented)
    subnets: Subnets;
    // (undocumented)
    subscriptionId?: string;
    // (undocumented)
    subscriptionNetworkManagerConnections: SubscriptionNetworkManagerConnections;
    supportedSecurityProviders(resourceGroupName: string, virtualWANName: string, options?: SupportedSecurityProvidersOptionalParams): Promise<SupportedSecurityProvidersResponse>;
    // (undocumented)
    usages: Usages;
    // (undocumented)
    verifierWorkspaces: VerifierWorkspaces;
    // (undocumented)
    vipSwap: VipSwap;
    // (undocumented)
    virtualApplianceSites: VirtualApplianceSites;
    // (undocumented)
    virtualApplianceSkus: VirtualApplianceSkus;
    // (undocumented)
    virtualHubBgpConnection: VirtualHubBgpConnection;
    // (undocumented)
    virtualHubBgpConnections: VirtualHubBgpConnections;
    // (undocumented)
    virtualHubIpConfiguration: VirtualHubIpConfiguration;
    // (undocumented)
    virtualHubRouteTableV2S: VirtualHubRouteTableV2S;
    // (undocumented)
    virtualHubs: VirtualHubs;
    // (undocumented)
    virtualNetworkGatewayConnections: VirtualNetworkGatewayConnections;
    // (undocumented)
    virtualNetworkGatewayNatRules: VirtualNetworkGatewayNatRules;
    // (undocumented)
    virtualNetworkGateways: VirtualNetworkGateways;
    // (undocumented)
    virtualNetworkPeerings: VirtualNetworkPeerings;
    // (undocumented)
    virtualNetworks: VirtualNetworks;
    // (undocumented)
    virtualNetworkTaps: VirtualNetworkTaps;
    // (undocumented)
    virtualRouterPeerings: VirtualRouterPeerings;
    // (undocumented)
    virtualRouters: VirtualRouters;
    // (undocumented)
    virtualWans: VirtualWans;
    // (undocumented)
    vpnConnections: VpnConnections;
    // (undocumented)
    vpnGateways: VpnGateways;
    // (undocumented)
    vpnLinkConnections: VpnLinkConnections;
    // (undocumented)
    vpnServerConfigurations: VpnServerConfigurations;
    // (undocumented)
    vpnServerConfigurationsAssociatedWithVirtualWan: VpnServerConfigurationsAssociatedWithVirtualWan;
    // (undocumented)
    vpnSiteLinkConnections: VpnSiteLinkConnections;
    // (undocumented)
    vpnSiteLinks: VpnSiteLinks;
    // (undocumented)
    vpnSites: VpnSites;
    // (undocumented)
    vpnSitesConfiguration: VpnSitesConfiguration;
    // (undocumented)
    webApplicationFirewallPolicies: WebApplicationFirewallPolicies;
    // (undocumented)
    webCategories: WebCategories;
}

// @public
export interface NetworkManagementClientDeleteBastionShareableLinkByTokenHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface NetworkManagementClientOptionalParams extends coreClient.ServiceClientOptions {
    $host?: string;
    endpoint?: string;
}

// @public
export interface NetworkManager extends Resource {
    description?: string;
    readonly etag?: string;
    networkManagerScopeAccesses?: ConfigurationType[];
    networkManagerScopes?: NetworkManagerPropertiesNetworkManagerScopes;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface NetworkManagerCommit {
    readonly commitId?: string;
    commitType: ConfigurationType;
    configurationIds?: string[];
    targetLocations: string[];
}

// @public
export interface NetworkManagerCommits {
    beginPost(resourceGroupName: string, networkManagerName: string, parameters: NetworkManagerCommit, options?: NetworkManagerCommitsPostOptionalParams): Promise<SimplePollerLike<OperationState<NetworkManagerCommitsPostResponse>, NetworkManagerCommitsPostResponse>>;
    beginPostAndWait(resourceGroupName: string, networkManagerName: string, parameters: NetworkManagerCommit, options?: NetworkManagerCommitsPostOptionalParams): Promise<NetworkManagerCommitsPostResponse>;
}

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

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

// @public
export type NetworkManagerCommitsPostResponse = NetworkManagerCommit;

// @public
export interface NetworkManagerConnection extends ChildResource {
    readonly connectionState?: ScopeConnectionState;
    description?: string;
    networkManagerId?: string;
    readonly systemData?: SystemData;
}

// @public
export interface NetworkManagerConnectionListResult {
    nextLink?: string;
    value?: NetworkManagerConnection[];
}

// @public
export interface NetworkManagerDeploymentStatus {
    commitTime?: Date;
    configurationIds?: string[];
    deploymentStatus?: DeploymentStatus;
    deploymentType?: ConfigurationType;
    errorMessage?: string;
    region?: string;
}

// @public
export interface NetworkManagerDeploymentStatusListOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type NetworkManagerDeploymentStatusListResponse = NetworkManagerDeploymentStatusListResult;

// @public
export interface NetworkManagerDeploymentStatusListResult {
    skipToken?: string;
    value?: NetworkManagerDeploymentStatus[];
}

// @public
export interface NetworkManagerDeploymentStatusOperations {
    list(resourceGroupName: string, networkManagerName: string, parameters: NetworkManagerDeploymentStatusParameter, options?: NetworkManagerDeploymentStatusListOptionalParams): Promise<NetworkManagerDeploymentStatusListResponse>;
}

// @public
export interface NetworkManagerDeploymentStatusParameter {
    deploymentTypes?: ConfigurationType[];
    regions?: string[];
    skipToken?: string;
}

// @public
export interface NetworkManagerEffectiveConnectivityConfigurationListResult {
    skipToken?: string;
    value?: EffectiveConnectivityConfiguration[];
}

// @public
export interface NetworkManagerEffectiveSecurityAdminRulesListResult {
    skipToken?: string;
    value?: EffectiveBaseSecurityAdminRuleUnion[];
}

// @public
export interface NetworkManagerListResult {
    nextLink?: string;
    value?: NetworkManager[];
}

// @public
export interface NetworkManagerPropertiesNetworkManagerScopes {
    readonly crossTenantScopes?: CrossTenantScopes[];
    managementGroups?: string[];
    subscriptions?: string[];
}

// @public
export interface NetworkManagerRoutingConfiguration extends ChildResource {
    description?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface NetworkManagerRoutingConfigurationListResult {
    nextLink?: string;
    value?: NetworkManagerRoutingConfiguration[];
}

// @public
export interface NetworkManagerRoutingConfigurations {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: NetworkManagerRoutingConfigurationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: NetworkManagerRoutingConfigurationsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, routingConfiguration: NetworkManagerRoutingConfiguration, options?: NetworkManagerRoutingConfigurationsCreateOrUpdateOptionalParams): Promise<NetworkManagerRoutingConfigurationsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: NetworkManagerRoutingConfigurationsGetOptionalParams): Promise<NetworkManagerRoutingConfigurationsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: NetworkManagerRoutingConfigurationsListOptionalParams): PagedAsyncIterableIterator<NetworkManagerRoutingConfiguration>;
}

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

// @public
export type NetworkManagerRoutingConfigurationsCreateOrUpdateResponse = NetworkManagerRoutingConfiguration;

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

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

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

// @public
export type NetworkManagerRoutingConfigurationsGetResponse = NetworkManagerRoutingConfiguration;

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

// @public
export type NetworkManagerRoutingConfigurationsListNextResponse = NetworkManagerRoutingConfigurationListResult;

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

// @public
export type NetworkManagerRoutingConfigurationsListResponse = NetworkManagerRoutingConfigurationListResult;

// @public
export interface NetworkManagerRoutingGroupItem {
    networkGroupId: string;
}

// @public
export interface NetworkManagers {
    beginDelete(resourceGroupName: string, networkManagerName: string, options?: NetworkManagersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, options?: NetworkManagersDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, parameters: NetworkManager, options?: NetworkManagersCreateOrUpdateOptionalParams): Promise<NetworkManagersCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, options?: NetworkManagersGetOptionalParams): Promise<NetworkManagersGetResponse>;
    list(resourceGroupName: string, options?: NetworkManagersListOptionalParams): PagedAsyncIterableIterator<NetworkManager>;
    listBySubscription(options?: NetworkManagersListBySubscriptionOptionalParams): PagedAsyncIterableIterator<NetworkManager>;
    patch(resourceGroupName: string, networkManagerName: string, parameters: PatchObject, options?: NetworkManagersPatchOptionalParams): Promise<NetworkManagersPatchResponse>;
}

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

// @public
export type NetworkManagersCreateOrUpdateResponse = NetworkManager;

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

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

// @public
export interface NetworkManagerSecurityGroupItem {
    networkGroupId: string;
}

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

// @public
export type NetworkManagersGetResponse = NetworkManager;

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

// @public
export type NetworkManagersListBySubscriptionNextResponse = NetworkManagerListResult;

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

// @public
export type NetworkManagersListBySubscriptionResponse = NetworkManagerListResult;

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

// @public
export type NetworkManagersListNextResponse = NetworkManagerListResult;

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

// @public
export type NetworkManagersListResponse = NetworkManagerListResult;

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

// @public
export type NetworkManagersPatchResponse = NetworkManager;

// @public
export type NetworkOperationStatus = string;

// @public
export interface NetworkProfile extends Resource {
    containerNetworkInterfaceConfigurations?: ContainerNetworkInterfaceConfiguration[];
    readonly containerNetworkInterfaces?: ContainerNetworkInterface[];
    readonly etag?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

// @public
export interface NetworkProfileListResult {
    nextLink?: string;
    value?: NetworkProfile[];
}

// @public
export interface NetworkProfiles {
    beginDelete(resourceGroupName: string, networkProfileName: string, options?: NetworkProfilesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkProfileName: string, options?: NetworkProfilesDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkProfileName: string, parameters: NetworkProfile, options?: NetworkProfilesCreateOrUpdateOptionalParams): Promise<NetworkProfilesCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkProfileName: string, options?: NetworkProfilesGetOptionalParams): Promise<NetworkProfilesGetResponse>;
    list(resourceGroupName: string, options?: NetworkProfilesListOptionalParams): PagedAsyncIterableIterator<NetworkProfile>;
    listAll(options?: NetworkProfilesListAllOptionalParams): PagedAsyncIterableIterator<NetworkProfile>;
    updateTags(resourceGroupName: string, networkProfileName: string, parameters: TagsObject, options?: NetworkProfilesUpdateTagsOptionalParams): Promise<NetworkProfilesUpdateTagsResponse>;
}

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

// @public
export type NetworkProfilesCreateOrUpdateResponse = NetworkProfile;

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

// @public
export interface NetworkProfilesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkProfilesGetResponse = NetworkProfile;

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

// @public
export type NetworkProfilesListAllNextResponse = NetworkProfileListResult;

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

// @public
export type NetworkProfilesListAllResponse = NetworkProfileListResult;

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

// @public
export type NetworkProfilesListNextResponse = NetworkProfileListResult;

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

// @public
export type NetworkProfilesListResponse = NetworkProfileListResult;

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

// @public
export type NetworkProfilesUpdateTagsResponse = NetworkProfile;

// @public
export type NetworkProtocol = string;

// @public
export interface NetworkRule extends FirewallPolicyRule {
    destinationAddresses?: string[];
    destinationFqdns?: string[];
    destinationIpGroups?: string[];
    destinationPorts?: string[];
    ipProtocols?: FirewallPolicyRuleNetworkProtocol[];
    ruleType: "NetworkRule";
    sourceAddresses?: string[];
    sourceIpGroups?: string[];
}

// @public
export interface NetworkSecurityGroup extends Resource {
    readonly defaultSecurityRules?: SecurityRule[];
    readonly etag?: string;
    readonly flowLogs?: FlowLog[];
    flushConnection?: boolean;
    readonly networkInterfaces?: NetworkInterface[];
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    securityRules?: SecurityRule[];
    readonly subnets?: Subnet[];
}

// @public
export interface NetworkSecurityGroupListResult {
    nextLink?: string;
    value?: NetworkSecurityGroup[];
}

// @public
export interface NetworkSecurityGroupResult {
    readonly evaluatedNetworkSecurityGroups?: EvaluatedNetworkSecurityGroup[];
    securityRuleAccessResult?: SecurityRuleAccess;
}

// @public
export interface NetworkSecurityGroups {
    beginCreateOrUpdate(resourceGroupName: string, networkSecurityGroupName: string, parameters: NetworkSecurityGroup, options?: NetworkSecurityGroupsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkSecurityGroupsCreateOrUpdateResponse>, NetworkSecurityGroupsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkSecurityGroupName: string, parameters: NetworkSecurityGroup, options?: NetworkSecurityGroupsCreateOrUpdateOptionalParams): Promise<NetworkSecurityGroupsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkSecurityGroupName: string, options?: NetworkSecurityGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkSecurityGroupName: string, options?: NetworkSecurityGroupsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityGroupName: string, options?: NetworkSecurityGroupsGetOptionalParams): Promise<NetworkSecurityGroupsGetResponse>;
    list(resourceGroupName: string, options?: NetworkSecurityGroupsListOptionalParams): PagedAsyncIterableIterator<NetworkSecurityGroup>;
    listAll(options?: NetworkSecurityGroupsListAllOptionalParams): PagedAsyncIterableIterator<NetworkSecurityGroup>;
    updateTags(resourceGroupName: string, networkSecurityGroupName: string, parameters: TagsObject, options?: NetworkSecurityGroupsUpdateTagsOptionalParams): Promise<NetworkSecurityGroupsUpdateTagsResponse>;
}

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

// @public
export type NetworkSecurityGroupsCreateOrUpdateResponse = NetworkSecurityGroup;

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

// @public
export interface NetworkSecurityGroupsGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkSecurityGroupsGetResponse = NetworkSecurityGroup;

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

// @public
export type NetworkSecurityGroupsListAllNextResponse = NetworkSecurityGroupListResult;

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

// @public
export type NetworkSecurityGroupsListAllResponse = NetworkSecurityGroupListResult;

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

// @public
export type NetworkSecurityGroupsListNextResponse = NetworkSecurityGroupListResult;

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

// @public
export type NetworkSecurityGroupsListResponse = NetworkSecurityGroupListResult;

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

// @public
export type NetworkSecurityGroupsUpdateTagsResponse = NetworkSecurityGroup;

// @public
export interface NetworkSecurityPerimeter extends TrackedResource {
    readonly perimeterGuid?: string;
    readonly provisioningState?: NspProvisioningState;
}

// @public
export interface NetworkSecurityPerimeterAccessRules {
    createOrUpdate(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, accessRuleName: string, parameters: NspAccessRule, options?: NetworkSecurityPerimeterAccessRulesCreateOrUpdateOptionalParams): Promise<NetworkSecurityPerimeterAccessRulesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, accessRuleName: string, options?: NetworkSecurityPerimeterAccessRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, accessRuleName: string, options?: NetworkSecurityPerimeterAccessRulesGetOptionalParams): Promise<NetworkSecurityPerimeterAccessRulesGetResponse>;
    list(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, options?: NetworkSecurityPerimeterAccessRulesListOptionalParams): PagedAsyncIterableIterator<NspAccessRule>;
    reconcile(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, accessRuleName: string, parameters: Record<string, unknown>, options?: NetworkSecurityPerimeterAccessRulesReconcileOptionalParams): Promise<NetworkSecurityPerimeterAccessRulesReconcileResponse>;
}

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

// @public
export type NetworkSecurityPerimeterAccessRulesCreateOrUpdateResponse = NspAccessRule;

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

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

// @public
export type NetworkSecurityPerimeterAccessRulesGetResponse = NspAccessRule;

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

// @public
export type NetworkSecurityPerimeterAccessRulesListNextResponse = NspAccessRuleListResult;

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

// @public
export type NetworkSecurityPerimeterAccessRulesListResponse = NspAccessRuleListResult;

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

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

// @public
export interface NetworkSecurityPerimeterAssociableResourceTypes {
    list(location: string, options?: NetworkSecurityPerimeterAssociableResourceTypesListOptionalParams): PagedAsyncIterableIterator<PerimeterAssociableResource>;
}

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

// @public
export type NetworkSecurityPerimeterAssociableResourceTypesListNextResponse = PerimeterAssociableResourcesListResult;

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

// @public
export type NetworkSecurityPerimeterAssociableResourceTypesListResponse = PerimeterAssociableResourcesListResult;

// @public
export interface NetworkSecurityPerimeterAssociations {
    beginCreateOrUpdate(resourceGroupName: string, networkSecurityPerimeterName: string, associationName: string, parameters: NspAssociation, options?: NetworkSecurityPerimeterAssociationsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkSecurityPerimeterAssociationsCreateOrUpdateResponse>, NetworkSecurityPerimeterAssociationsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkSecurityPerimeterName: string, associationName: string, parameters: NspAssociation, options?: NetworkSecurityPerimeterAssociationsCreateOrUpdateOptionalParams): Promise<NetworkSecurityPerimeterAssociationsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkSecurityPerimeterName: string, associationName: string, options?: NetworkSecurityPerimeterAssociationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkSecurityPerimeterName: string, associationName: string, options?: NetworkSecurityPerimeterAssociationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, associationName: string, options?: NetworkSecurityPerimeterAssociationsGetOptionalParams): Promise<NetworkSecurityPerimeterAssociationsGetResponse>;
    list(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimeterAssociationsListOptionalParams): PagedAsyncIterableIterator<NspAssociation>;
    reconcile(resourceGroupName: string, networkSecurityPerimeterName: string, associationName: string, parameters: Record<string, unknown>, options?: NetworkSecurityPerimeterAssociationsReconcileOptionalParams): Promise<NetworkSecurityPerimeterAssociationsReconcileResponse>;
}

// @public
export interface NetworkSecurityPerimeterAssociationsCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
}

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

// @public
export type NetworkSecurityPerimeterAssociationsCreateOrUpdateResponse = NspAssociation;

// @public
export interface NetworkSecurityPerimeterAssociationsDeleteHeaders {
    azureAsyncOperation?: string;
}

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

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

// @public
export type NetworkSecurityPerimeterAssociationsGetResponse = NspAssociation;

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

// @public
export type NetworkSecurityPerimeterAssociationsListNextResponse = NspAssociationsListResult;

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

// @public
export type NetworkSecurityPerimeterAssociationsListResponse = NspAssociationsListResult;

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

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

// @public
export interface NetworkSecurityPerimeterLinkReferences {
    beginDelete(resourceGroupName: string, networkSecurityPerimeterName: string, linkReferenceName: string, options?: NetworkSecurityPerimeterLinkReferencesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkSecurityPerimeterName: string, linkReferenceName: string, options?: NetworkSecurityPerimeterLinkReferencesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, linkReferenceName: string, options?: NetworkSecurityPerimeterLinkReferencesGetOptionalParams): Promise<NetworkSecurityPerimeterLinkReferencesGetResponse>;
    list(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimeterLinkReferencesListOptionalParams): PagedAsyncIterableIterator<NspLinkReference>;
}

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

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

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

// @public
export type NetworkSecurityPerimeterLinkReferencesGetResponse = NspLinkReference;

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

// @public
export type NetworkSecurityPerimeterLinkReferencesListNextResponse = NspLinkReferenceListResult;

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

// @public
export type NetworkSecurityPerimeterLinkReferencesListResponse = NspLinkReferenceListResult;

// @public
export interface NetworkSecurityPerimeterLinks {
    beginDelete(resourceGroupName: string, networkSecurityPerimeterName: string, linkName: string, options?: NetworkSecurityPerimeterLinksDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkSecurityPerimeterName: string, linkName: string, options?: NetworkSecurityPerimeterLinksDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkSecurityPerimeterName: string, linkName: string, parameters: NspLink, options?: NetworkSecurityPerimeterLinksCreateOrUpdateOptionalParams): Promise<NetworkSecurityPerimeterLinksCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, linkName: string, options?: NetworkSecurityPerimeterLinksGetOptionalParams): Promise<NetworkSecurityPerimeterLinksGetResponse>;
    list(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimeterLinksListOptionalParams): PagedAsyncIterableIterator<NspLink>;
}

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

// @public
export type NetworkSecurityPerimeterLinksCreateOrUpdateResponse = NspLink;

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

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

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

// @public
export type NetworkSecurityPerimeterLinksGetResponse = NspLink;

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

// @public
export type NetworkSecurityPerimeterLinksListNextResponse = NspLinkListResult;

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

// @public
export type NetworkSecurityPerimeterLinksListResponse = NspLinkListResult;

// @public
export interface NetworkSecurityPerimeterListResult {
    nextLink?: string;
    value?: NetworkSecurityPerimeter[];
}

// @public
export interface NetworkSecurityPerimeterLoggingConfigurations {
    createOrUpdate(resourceGroupName: string, networkSecurityPerimeterName: string, loggingConfigurationName: string, parameters: NspLoggingConfiguration, options?: NetworkSecurityPerimeterLoggingConfigurationsCreateOrUpdateOptionalParams): Promise<NetworkSecurityPerimeterLoggingConfigurationsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, networkSecurityPerimeterName: string, loggingConfigurationName: string, options?: NetworkSecurityPerimeterLoggingConfigurationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, loggingConfigurationName: string, options?: NetworkSecurityPerimeterLoggingConfigurationsGetOptionalParams): Promise<NetworkSecurityPerimeterLoggingConfigurationsGetResponse>;
    list(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimeterLoggingConfigurationsListOptionalParams): PagedAsyncIterableIterator<NspLoggingConfiguration>;
}

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

// @public
export type NetworkSecurityPerimeterLoggingConfigurationsCreateOrUpdateResponse = NspLoggingConfiguration;

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

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

// @public
export type NetworkSecurityPerimeterLoggingConfigurationsGetResponse = NspLoggingConfiguration;

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

// @public
export type NetworkSecurityPerimeterLoggingConfigurationsListNextResponse = NspLoggingConfigurationListResult;

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

// @public
export type NetworkSecurityPerimeterLoggingConfigurationsListResponse = NspLoggingConfigurationListResult;

// @public
export interface NetworkSecurityPerimeterOperationStatuses {
    get(location: string, operationId: string, options?: NetworkSecurityPerimeterOperationStatusesGetOptionalParams): Promise<NetworkSecurityPerimeterOperationStatusesGetResponse>;
}

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

// @public
export type NetworkSecurityPerimeterOperationStatusesGetResponse = OperationStatusResult;

// @public
export interface NetworkSecurityPerimeterProfiles {
    createOrUpdate(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, parameters: NspProfile, options?: NetworkSecurityPerimeterProfilesCreateOrUpdateOptionalParams): Promise<NetworkSecurityPerimeterProfilesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, options?: NetworkSecurityPerimeterProfilesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, profileName: string, options?: NetworkSecurityPerimeterProfilesGetOptionalParams): Promise<NetworkSecurityPerimeterProfilesGetResponse>;
    list(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimeterProfilesListOptionalParams): PagedAsyncIterableIterator<NspProfile>;
}

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

// @public
export type NetworkSecurityPerimeterProfilesCreateOrUpdateResponse = NspProfile;

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

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

// @public
export type NetworkSecurityPerimeterProfilesGetResponse = NspProfile;

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

// @public
export type NetworkSecurityPerimeterProfilesListNextResponse = NspProfileListResult;

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

// @public
export type NetworkSecurityPerimeterProfilesListResponse = NspProfileListResult;

// @public
export interface NetworkSecurityPerimeters {
    beginDelete(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimetersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimetersDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkSecurityPerimeterName: string, parameters: NetworkSecurityPerimeter, options?: NetworkSecurityPerimetersCreateOrUpdateOptionalParams): Promise<NetworkSecurityPerimetersCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkSecurityPerimeterName: string, options?: NetworkSecurityPerimetersGetOptionalParams): Promise<NetworkSecurityPerimetersGetResponse>;
    list(resourceGroupName: string, options?: NetworkSecurityPerimetersListOptionalParams): PagedAsyncIterableIterator<NetworkSecurityPerimeter>;
    listBySubscription(options?: NetworkSecurityPerimetersListBySubscriptionOptionalParams): PagedAsyncIterableIterator<NetworkSecurityPerimeter>;
    patch(resourceGroupName: string, networkSecurityPerimeterName: string, parameters: UpdateTagsRequest, options?: NetworkSecurityPerimetersPatchOptionalParams): Promise<NetworkSecurityPerimetersPatchResponse>;
}

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

// @public
export type NetworkSecurityPerimetersCreateOrUpdateResponse = NetworkSecurityPerimeter;

// @public
export interface NetworkSecurityPerimetersDeleteHeaders {
    azureAsyncOperation?: string;
}

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

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

// @public
export type NetworkSecurityPerimetersGetResponse = NetworkSecurityPerimeter;

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

// @public
export type NetworkSecurityPerimetersListBySubscriptionNextResponse = NetworkSecurityPerimeterListResult;

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

// @public
export type NetworkSecurityPerimetersListBySubscriptionResponse = NetworkSecurityPerimeterListResult;

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

// @public
export type NetworkSecurityPerimetersListNextResponse = NetworkSecurityPerimeterListResult;

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

// @public
export type NetworkSecurityPerimetersListResponse = NetworkSecurityPerimeterListResult;

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

// @public
export type NetworkSecurityPerimetersPatchResponse = NetworkSecurityPerimeter;

// @public
export interface NetworkSecurityRulesEvaluationResult {
    destinationMatched?: boolean;
    destinationPortMatched?: boolean;
    name?: string;
    protocolMatched?: boolean;
    sourceMatched?: boolean;
    sourcePortMatched?: boolean;
}

// @public
export interface NetworkVirtualAppliance extends Resource {
    additionalNics?: VirtualApplianceAdditionalNicProperties[];
    readonly addressPrefix?: string;
    bootStrapConfigurationBlobs?: string[];
    cloudInitConfiguration?: string;
    cloudInitConfigurationBlobs?: string[];
    delegation?: DelegationProperties;
    readonly deploymentType?: string;
    readonly etag?: string;
    identity?: ManagedServiceIdentity;
    readonly inboundSecurityRules?: SubResource[];
    internetIngressPublicIps?: InternetIngressPublicIpsProperties[];
    networkProfile?: NetworkVirtualAppliancePropertiesFormatNetworkProfile;
    nvaSku?: VirtualApplianceSkuProperties;
    partnerManagedResource?: PartnerManagedResourceProperties;
    readonly provisioningState?: ProvisioningState;
    sshPublicKey?: string;
    virtualApplianceAsn?: number;
    readonly virtualApplianceConnections?: SubResource[];
    readonly virtualApplianceNics?: VirtualApplianceNicProperties[];
    readonly virtualApplianceSites?: SubResource[];
    virtualHub?: SubResource;
}

// @public
export interface NetworkVirtualApplianceBootDiagnosticParameters {
    consoleScreenshotStorageSasUrl?: string;
    instanceId?: number;
    serialConsoleStorageSasUrl?: string;
}

// @public
export interface NetworkVirtualApplianceConnection extends SubResource {
    asn?: number;
    bgpPeerAddress?: string[];
    enableInternetSecurity?: boolean;
    name?: string;
    namePropertiesName?: string;
    readonly provisioningState?: ProvisioningState;
    routingConfiguration?: RoutingConfiguration;
    tunnelIdentifier?: number;
}

// @public
export interface NetworkVirtualApplianceConnectionList {
    nextLink?: string;
    value?: NetworkVirtualApplianceConnection[];
}

// @public
export interface NetworkVirtualApplianceConnections {
    beginCreateOrUpdate(resourceGroupName: string, networkVirtualApplianceName: string, connectionName: string, networkVirtualApplianceConnectionParameters: NetworkVirtualApplianceConnection, options?: NetworkVirtualApplianceConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkVirtualApplianceConnectionsCreateOrUpdateResponse>, NetworkVirtualApplianceConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkVirtualApplianceName: string, connectionName: string, networkVirtualApplianceConnectionParameters: NetworkVirtualApplianceConnection, options?: NetworkVirtualApplianceConnectionsCreateOrUpdateOptionalParams): Promise<NetworkVirtualApplianceConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkVirtualApplianceName: string, connectionName: string, options?: NetworkVirtualApplianceConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkVirtualApplianceName: string, connectionName: string, options?: NetworkVirtualApplianceConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkVirtualApplianceName: string, connectionName: string, options?: NetworkVirtualApplianceConnectionsGetOptionalParams): Promise<NetworkVirtualApplianceConnectionsGetResponse>;
    list(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualApplianceConnectionsListOptionalParams): PagedAsyncIterableIterator<NetworkVirtualApplianceConnection>;
}

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

// @public
export type NetworkVirtualApplianceConnectionsCreateOrUpdateResponse = NetworkVirtualApplianceConnection;

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

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

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

// @public
export type NetworkVirtualApplianceConnectionsGetResponse = NetworkVirtualApplianceConnection;

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

// @public
export type NetworkVirtualApplianceConnectionsListNextResponse = NetworkVirtualApplianceConnectionList;

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

// @public
export type NetworkVirtualApplianceConnectionsListResponse = NetworkVirtualApplianceConnectionList;

// @public (undocumented)
export interface NetworkVirtualApplianceInstanceId {
    instanceId?: number;
}

// @public
export interface NetworkVirtualApplianceInstanceIds {
    instanceIds?: string[];
}

// @public
export interface NetworkVirtualApplianceListResult {
    nextLink?: string;
    value?: NetworkVirtualAppliance[];
}

// @public
export interface NetworkVirtualAppliancePropertiesFormatNetworkProfile {
    // (undocumented)
    networkInterfaceConfigurations?: VirtualApplianceNetworkInterfaceConfiguration[];
}

// @public
export interface NetworkVirtualAppliances {
    beginCreateOrUpdate(resourceGroupName: string, networkVirtualApplianceName: string, parameters: NetworkVirtualAppliance, options?: NetworkVirtualAppliancesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkVirtualAppliancesCreateOrUpdateResponse>, NetworkVirtualAppliancesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkVirtualApplianceName: string, parameters: NetworkVirtualAppliance, options?: NetworkVirtualAppliancesCreateOrUpdateOptionalParams): Promise<NetworkVirtualAppliancesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesDeleteOptionalParams): Promise<void>;
    beginGetBootDiagnosticLogs(resourceGroupName: string, networkVirtualApplianceName: string, request: NetworkVirtualApplianceBootDiagnosticParameters, options?: NetworkVirtualAppliancesGetBootDiagnosticLogsOptionalParams): Promise<SimplePollerLike<OperationState<NetworkVirtualAppliancesGetBootDiagnosticLogsResponse>, NetworkVirtualAppliancesGetBootDiagnosticLogsResponse>>;
    beginGetBootDiagnosticLogsAndWait(resourceGroupName: string, networkVirtualApplianceName: string, request: NetworkVirtualApplianceBootDiagnosticParameters, options?: NetworkVirtualAppliancesGetBootDiagnosticLogsOptionalParams): Promise<NetworkVirtualAppliancesGetBootDiagnosticLogsResponse>;
    beginReimage(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesReimageOptionalParams): Promise<SimplePollerLike<OperationState<NetworkVirtualAppliancesReimageResponse>, NetworkVirtualAppliancesReimageResponse>>;
    beginReimageAndWait(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesReimageOptionalParams): Promise<NetworkVirtualAppliancesReimageResponse>;
    beginRestart(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesRestartOptionalParams): Promise<SimplePollerLike<OperationState<NetworkVirtualAppliancesRestartResponse>, NetworkVirtualAppliancesRestartResponse>>;
    beginRestartAndWait(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesRestartOptionalParams): Promise<NetworkVirtualAppliancesRestartResponse>;
    get(resourceGroupName: string, networkVirtualApplianceName: string, options?: NetworkVirtualAppliancesGetOptionalParams): Promise<NetworkVirtualAppliancesGetResponse>;
    list(options?: NetworkVirtualAppliancesListOptionalParams): PagedAsyncIterableIterator<NetworkVirtualAppliance>;
    listByResourceGroup(resourceGroupName: string, options?: NetworkVirtualAppliancesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<NetworkVirtualAppliance>;
    updateTags(resourceGroupName: string, networkVirtualApplianceName: string, parameters: TagsObject, options?: NetworkVirtualAppliancesUpdateTagsOptionalParams): Promise<NetworkVirtualAppliancesUpdateTagsResponse>;
}

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

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

// @public
export type NetworkVirtualAppliancesCreateOrUpdateResponse = NetworkVirtualAppliance;

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

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

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

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

// @public
export type NetworkVirtualAppliancesGetBootDiagnosticLogsResponse = NetworkVirtualApplianceInstanceId;

// @public
export interface NetworkVirtualAppliancesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type NetworkVirtualAppliancesGetResponse = NetworkVirtualAppliance;

// @public
export interface NetworkVirtualApplianceSiteListResult {
    nextLink?: string;
    value?: VirtualApplianceSite[];
}

// @public
export interface NetworkVirtualApplianceSku extends Resource {
    availableScaleUnits?: NetworkVirtualApplianceSkuInstances[];
    readonly availableVersions?: string[];
    readonly etag?: string;
    readonly vendor?: string;
}

// @public
export interface NetworkVirtualApplianceSkuInstances {
    readonly instanceCount?: number;
    readonly scaleUnit?: string;
}

// @public
export interface NetworkVirtualApplianceSkuListResult {
    nextLink?: string;
    value?: NetworkVirtualApplianceSku[];
}

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

// @public
export type NetworkVirtualAppliancesListByResourceGroupNextResponse = NetworkVirtualApplianceListResult;

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

// @public
export type NetworkVirtualAppliancesListByResourceGroupResponse = NetworkVirtualApplianceListResult;

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

// @public
export type NetworkVirtualAppliancesListNextResponse = NetworkVirtualApplianceListResult;

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

// @public
export type NetworkVirtualAppliancesListResponse = NetworkVirtualApplianceListResult;

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

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

// @public
export type NetworkVirtualAppliancesReimageResponse = NetworkVirtualApplianceInstanceIds;

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

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

// @public
export type NetworkVirtualAppliancesRestartResponse = NetworkVirtualApplianceInstanceIds;

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

// @public
export type NetworkVirtualAppliancesUpdateTagsResponse = NetworkVirtualAppliance;

// @public
export interface NetworkWatcher extends Resource {
    readonly etag?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface NetworkWatcherListResult {
    value?: NetworkWatcher[];
}

// @public
export interface NetworkWatchers {
    beginCheckConnectivity(resourceGroupName: string, networkWatcherName: string, parameters: ConnectivityParameters, options?: NetworkWatchersCheckConnectivityOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersCheckConnectivityResponse>, NetworkWatchersCheckConnectivityResponse>>;
    beginCheckConnectivityAndWait(resourceGroupName: string, networkWatcherName: string, parameters: ConnectivityParameters, options?: NetworkWatchersCheckConnectivityOptionalParams): Promise<NetworkWatchersCheckConnectivityResponse>;
    beginDelete(resourceGroupName: string, networkWatcherName: string, options?: NetworkWatchersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkWatcherName: string, options?: NetworkWatchersDeleteOptionalParams): Promise<void>;
    beginGetAzureReachabilityReport(resourceGroupName: string, networkWatcherName: string, parameters: AzureReachabilityReportParameters, options?: NetworkWatchersGetAzureReachabilityReportOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetAzureReachabilityReportResponse>, NetworkWatchersGetAzureReachabilityReportResponse>>;
    beginGetAzureReachabilityReportAndWait(resourceGroupName: string, networkWatcherName: string, parameters: AzureReachabilityReportParameters, options?: NetworkWatchersGetAzureReachabilityReportOptionalParams): Promise<NetworkWatchersGetAzureReachabilityReportResponse>;
    beginGetFlowLogStatus(resourceGroupName: string, networkWatcherName: string, parameters: FlowLogStatusParameters, options?: NetworkWatchersGetFlowLogStatusOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetFlowLogStatusResponse>, NetworkWatchersGetFlowLogStatusResponse>>;
    beginGetFlowLogStatusAndWait(resourceGroupName: string, networkWatcherName: string, parameters: FlowLogStatusParameters, options?: NetworkWatchersGetFlowLogStatusOptionalParams): Promise<NetworkWatchersGetFlowLogStatusResponse>;
    beginGetNetworkConfigurationDiagnostic(resourceGroupName: string, networkWatcherName: string, parameters: NetworkConfigurationDiagnosticParameters, options?: NetworkWatchersGetNetworkConfigurationDiagnosticOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetNetworkConfigurationDiagnosticResponse>, NetworkWatchersGetNetworkConfigurationDiagnosticResponse>>;
    beginGetNetworkConfigurationDiagnosticAndWait(resourceGroupName: string, networkWatcherName: string, parameters: NetworkConfigurationDiagnosticParameters, options?: NetworkWatchersGetNetworkConfigurationDiagnosticOptionalParams): Promise<NetworkWatchersGetNetworkConfigurationDiagnosticResponse>;
    beginGetNextHop(resourceGroupName: string, networkWatcherName: string, parameters: NextHopParameters, options?: NetworkWatchersGetNextHopOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetNextHopResponse>, NetworkWatchersGetNextHopResponse>>;
    beginGetNextHopAndWait(resourceGroupName: string, networkWatcherName: string, parameters: NextHopParameters, options?: NetworkWatchersGetNextHopOptionalParams): Promise<NetworkWatchersGetNextHopResponse>;
    beginGetTroubleshooting(resourceGroupName: string, networkWatcherName: string, parameters: TroubleshootingParameters, options?: NetworkWatchersGetTroubleshootingOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetTroubleshootingResponse>, NetworkWatchersGetTroubleshootingResponse>>;
    beginGetTroubleshootingAndWait(resourceGroupName: string, networkWatcherName: string, parameters: TroubleshootingParameters, options?: NetworkWatchersGetTroubleshootingOptionalParams): Promise<NetworkWatchersGetTroubleshootingResponse>;
    beginGetTroubleshootingResult(resourceGroupName: string, networkWatcherName: string, parameters: QueryTroubleshootingParameters, options?: NetworkWatchersGetTroubleshootingResultOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetTroubleshootingResultResponse>, NetworkWatchersGetTroubleshootingResultResponse>>;
    beginGetTroubleshootingResultAndWait(resourceGroupName: string, networkWatcherName: string, parameters: QueryTroubleshootingParameters, options?: NetworkWatchersGetTroubleshootingResultOptionalParams): Promise<NetworkWatchersGetTroubleshootingResultResponse>;
    beginGetVMSecurityRules(resourceGroupName: string, networkWatcherName: string, parameters: SecurityGroupViewParameters, options?: NetworkWatchersGetVMSecurityRulesOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersGetVMSecurityRulesResponse>, NetworkWatchersGetVMSecurityRulesResponse>>;
    beginGetVMSecurityRulesAndWait(resourceGroupName: string, networkWatcherName: string, parameters: SecurityGroupViewParameters, options?: NetworkWatchersGetVMSecurityRulesOptionalParams): Promise<NetworkWatchersGetVMSecurityRulesResponse>;
    beginListAvailableProviders(resourceGroupName: string, networkWatcherName: string, parameters: AvailableProvidersListParameters, options?: NetworkWatchersListAvailableProvidersOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersListAvailableProvidersResponse>, NetworkWatchersListAvailableProvidersResponse>>;
    beginListAvailableProvidersAndWait(resourceGroupName: string, networkWatcherName: string, parameters: AvailableProvidersListParameters, options?: NetworkWatchersListAvailableProvidersOptionalParams): Promise<NetworkWatchersListAvailableProvidersResponse>;
    beginSetFlowLogConfiguration(resourceGroupName: string, networkWatcherName: string, parameters: FlowLogInformation, options?: NetworkWatchersSetFlowLogConfigurationOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersSetFlowLogConfigurationResponse>, NetworkWatchersSetFlowLogConfigurationResponse>>;
    beginSetFlowLogConfigurationAndWait(resourceGroupName: string, networkWatcherName: string, parameters: FlowLogInformation, options?: NetworkWatchersSetFlowLogConfigurationOptionalParams): Promise<NetworkWatchersSetFlowLogConfigurationResponse>;
    beginVerifyIPFlow(resourceGroupName: string, networkWatcherName: string, parameters: VerificationIPFlowParameters, options?: NetworkWatchersVerifyIPFlowOptionalParams): Promise<SimplePollerLike<OperationState<NetworkWatchersVerifyIPFlowResponse>, NetworkWatchersVerifyIPFlowResponse>>;
    beginVerifyIPFlowAndWait(resourceGroupName: string, networkWatcherName: string, parameters: VerificationIPFlowParameters, options?: NetworkWatchersVerifyIPFlowOptionalParams): Promise<NetworkWatchersVerifyIPFlowResponse>;
    createOrUpdate(resourceGroupName: string, networkWatcherName: string, parameters: NetworkWatcher, options?: NetworkWatchersCreateOrUpdateOptionalParams): Promise<NetworkWatchersCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkWatcherName: string, options?: NetworkWatchersGetOptionalParams): Promise<NetworkWatchersGetResponse>;
    getTopology(resourceGroupName: string, networkWatcherName: string, parameters: TopologyParameters, options?: NetworkWatchersGetTopologyOptionalParams): Promise<NetworkWatchersGetTopologyResponse>;
    list(resourceGroupName: string, options?: NetworkWatchersListOptionalParams): PagedAsyncIterableIterator<NetworkWatcher>;
    listAll(options?: NetworkWatchersListAllOptionalParams): PagedAsyncIterableIterator<NetworkWatcher>;
    updateTags(resourceGroupName: string, networkWatcherName: string, parameters: TagsObject, options?: NetworkWatchersUpdateTagsOptionalParams): Promise<NetworkWatchersUpdateTagsResponse>;
}

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

// @public
export type NetworkWatchersCheckConnectivityResponse = ConnectivityInformation;

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

// @public
export type NetworkWatchersCreateOrUpdateResponse = NetworkWatcher;

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

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

// @public
export type NetworkWatchersGetAzureReachabilityReportResponse = AzureReachabilityReport;

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

// @public
export type NetworkWatchersGetFlowLogStatusResponse = FlowLogInformation;

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

// @public
export type NetworkWatchersGetNetworkConfigurationDiagnosticResponse = NetworkConfigurationDiagnosticResponse;

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

// @public
export type NetworkWatchersGetNextHopResponse = NextHopResult;

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

// @public
export type NetworkWatchersGetResponse = NetworkWatcher;

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

// @public
export type NetworkWatchersGetTopologyResponse = Topology;

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

// @public
export type NetworkWatchersGetTroubleshootingResponse = TroubleshootingResult;

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

// @public
export type NetworkWatchersGetTroubleshootingResultResponse = TroubleshootingResult;

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

// @public
export type NetworkWatchersGetVMSecurityRulesResponse = SecurityGroupViewResult;

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

// @public
export type NetworkWatchersListAllResponse = NetworkWatcherListResult;

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

// @public
export type NetworkWatchersListAvailableProvidersResponse = AvailableProvidersList;

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

// @public
export type NetworkWatchersListResponse = NetworkWatcherListResult;

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

// @public
export type NetworkWatchersSetFlowLogConfigurationResponse = FlowLogInformation;

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

// @public
export type NetworkWatchersUpdateTagsResponse = NetworkWatcher;

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

// @public
export type NetworkWatchersVerifyIPFlowResponse = VerificationIPFlowResult;

// @public
export interface NextHopParameters {
    destinationIPAddress: string;
    sourceIPAddress: string;
    targetNicResourceId?: string;
    targetResourceId: string;
}

// @public
export interface NextHopResult {
    nextHopIpAddress?: string;
    nextHopType?: NextHopType;
    routeTableId?: string;
}

// @public
export type NextHopType = string;

// @public
export type NextStep = string;

// @public
export type NicTypeInRequest = string;

// @public
export type NicTypeInResponse = string;

// @public
export interface NspAccessRule extends SecurityPerimeterProxyResource {
    addressPrefixes?: string[];
    direction?: AccessRuleDirection;
    emailAddresses?: string[];
    fullyQualifiedDomainNames?: string[];
    readonly networkSecurityPerimeters?: PerimeterBasedAccessRule[];
    phoneNumbers?: string[];
    readonly provisioningState?: NspProvisioningState;
    serviceTags?: string[];
    subscriptions?: SubscriptionId[];
}

// @public
export interface NspAccessRuleListResult {
    nextLink?: string;
    value?: NspAccessRule[];
}

// @public
export interface NspAssociation extends SecurityPerimeterProxyResource {
    accessMode?: AssociationAccessMode;
    readonly hasProvisioningIssues?: string;
    privateLinkResource?: SubResource;
    profile?: SubResource;
    readonly provisioningState?: NspProvisioningState;
}

// @public
export interface NspAssociationsListResult {
    nextLink?: string;
    value?: NspAssociation[];
}

// @public
export interface NspLink extends SecurityPerimeterProxyResource {
    autoApprovedRemotePerimeterResourceId?: string;
    description?: string;
    localInboundProfiles?: string[];
    readonly localOutboundProfiles?: string[];
    readonly provisioningState?: NspLinkProvisioningState;
    remoteInboundProfiles?: string[];
    readonly remoteOutboundProfiles?: string[];
    readonly remotePerimeterGuid?: string;
    readonly remotePerimeterLocation?: string;
    readonly status?: NspLinkStatus;
}

// @public
export interface NspLinkListResult {
    nextLink?: string;
    value?: NspLink[];
}

// @public
export type NspLinkProvisioningState = string;

// @public
export interface NspLinkReference extends SecurityPerimeterProxyResource {
    readonly description?: string;
    localInboundProfiles?: string[];
    readonly localOutboundProfiles?: string[];
    readonly provisioningState?: NspLinkProvisioningState;
    readonly remoteInboundProfiles?: string[];
    readonly remoteOutboundProfiles?: string[];
    readonly remotePerimeterGuid?: string;
    readonly remotePerimeterLocation?: string;
    readonly remotePerimeterResourceId?: string;
    status?: NspLinkStatus;
}

// @public
export interface NspLinkReferenceListResult {
    nextLink?: string;
    value?: NspLinkReference[];
}

// @public
export type NspLinkStatus = string;

// @public
export interface NspLoggingConfiguration extends SecurityPerimeterProxyResource {
    enabledLogCategories?: string[];
    version?: string;
}

// @public
export interface NspLoggingConfigurationListResult {
    nextLink?: string;
    value?: NspLoggingConfiguration[];
}

// @public
export interface NspProfile extends SecurityPerimeterProxyResource {
    readonly accessRulesVersion?: string;
    readonly diagnosticSettingsVersion?: string;
}

// @public
export interface NspProfileListResult {
    nextLink?: string;
    value?: NspProfile[];
}

// @public
export type NspProvisioningState = string;

// @public
export interface O365BreakOutCategoryPolicies {
    allow?: boolean;
    default?: boolean;
    optimize?: boolean;
}

// @public
export interface O365PolicyProperties {
    breakOutCategories?: O365BreakOutCategoryPolicies;
}

// @public
export interface Office365PolicyProperties {
    breakOutCategories?: BreakOutCategoryPolicies;
}

// @public
export type OfficeTrafficCategory = string;

// @public
export interface Operation {
    display?: OperationDisplay;
    name?: string;
    origin?: string;
    serviceSpecification?: OperationPropertiesFormatServiceSpecification;
}

// @public
export interface OperationDisplay {
    description?: string;
    operation?: string;
    provider?: string;
    resource?: string;
}

// @public
export interface OperationListResult {
    nextLink?: string;
    value?: Operation[];
}

// @public
export interface OperationPropertiesFormatServiceSpecification {
    logSpecifications?: LogSpecification[];
    metricSpecifications?: MetricSpecification[];
}

// @public
export interface Operations {
    list(options?: OperationsListOptionalParams): PagedAsyncIterableIterator<Operation>;
}

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

// @public
export type OperationsListNextResponse = OperationListResult;

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

// @public
export type OperationsListResponse = OperationListResult;

// @public
export interface OperationStatusResult {
    endTime?: Date;
    error?: ErrorDetail;
    id?: string;
    name?: string;
    operations?: OperationStatusResult[];
    percentComplete?: number;
    readonly resourceId?: string;
    startTime?: Date;
    status: string;
}

// @public
export interface OrderBy {
    field?: string;
    order?: FirewallPolicyIdpsQuerySortOrder;
}

// @public
export type Origin = string;

// @public
export interface OutboundRule extends SubResource {
    allocatedOutboundPorts?: number;
    backendAddressPool?: SubResource;
    enableTcpReset?: boolean;
    readonly etag?: string;
    frontendIPConfigurations?: SubResource[];
    idleTimeoutInMinutes?: number;
    name?: string;
    protocol?: LoadBalancerOutboundRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export type OutputType = string;

// @public
export interface OwaspCrsExclusionEntry {
    exclusionManagedRuleSets?: ExclusionManagedRuleSet[];
    matchVariable: OwaspCrsExclusionEntryMatchVariable;
    selector: string;
    selectorMatchOperator: OwaspCrsExclusionEntrySelectorMatchOperator;
}

// @public
export type OwaspCrsExclusionEntryMatchVariable = string;

// @public
export type OwaspCrsExclusionEntrySelectorMatchOperator = string;

// @public
export interface P2SConnectionConfiguration extends SubResource {
    configurationPolicyGroupAssociations?: SubResource[];
    enableInternetSecurity?: boolean;
    readonly etag?: string;
    name?: string;
    readonly previousConfigurationPolicyGroupAssociations?: VpnServerConfigurationPolicyGroup[];
    readonly provisioningState?: ProvisioningState;
    routingConfiguration?: RoutingConfiguration;
    vpnClientAddressPool?: AddressSpace;
}

// @public
export interface P2SVpnConnectionHealth {
    sasUrl?: string;
}

// @public
export interface P2SVpnConnectionHealthRequest {
    outputBlobSasUrl?: string;
    vpnUserNamesFilter?: string[];
}

// @public
export interface P2SVpnConnectionRequest {
    vpnConnectionIds?: string[];
}

// @public
export interface P2SVpnGateway extends Resource {
    customDnsServers?: string[];
    readonly etag?: string;
    isRoutingPreferenceInternet?: boolean;
    p2SConnectionConfigurations?: P2SConnectionConfiguration[];
    readonly provisioningState?: ProvisioningState;
    virtualHub?: SubResource;
    readonly vpnClientConnectionHealth?: VpnClientConnectionHealth;
    vpnGatewayScaleUnit?: number;
    vpnServerConfiguration?: SubResource;
}

// @public
export interface P2SVpnGateways {
    beginCreateOrUpdate(resourceGroupName: string, gatewayName: string, p2SVpnGatewayParameters: P2SVpnGateway, options?: P2SVpnGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<P2SVpnGatewaysCreateOrUpdateResponse>, P2SVpnGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, gatewayName: string, p2SVpnGatewayParameters: P2SVpnGateway, options?: P2SVpnGatewaysCreateOrUpdateOptionalParams): Promise<P2SVpnGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysDeleteOptionalParams): Promise<void>;
    beginDisconnectP2SVpnConnections(resourceGroupName: string, p2SVpnGatewayName: string, request: P2SVpnConnectionRequest, options?: P2SVpnGatewaysDisconnectP2SVpnConnectionsOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDisconnectP2SVpnConnectionsAndWait(resourceGroupName: string, p2SVpnGatewayName: string, request: P2SVpnConnectionRequest, options?: P2SVpnGatewaysDisconnectP2SVpnConnectionsOptionalParams): Promise<void>;
    beginGenerateVpnProfile(resourceGroupName: string, gatewayName: string, parameters: P2SVpnProfileParameters, options?: P2SVpnGatewaysGenerateVpnProfileOptionalParams): Promise<SimplePollerLike<OperationState<P2SVpnGatewaysGenerateVpnProfileResponse>, P2SVpnGatewaysGenerateVpnProfileResponse>>;
    beginGenerateVpnProfileAndWait(resourceGroupName: string, gatewayName: string, parameters: P2SVpnProfileParameters, options?: P2SVpnGatewaysGenerateVpnProfileOptionalParams): Promise<P2SVpnGatewaysGenerateVpnProfileResponse>;
    beginGetP2SVpnConnectionHealth(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysGetP2SVpnConnectionHealthOptionalParams): Promise<SimplePollerLike<OperationState<P2SVpnGatewaysGetP2SVpnConnectionHealthResponse>, P2SVpnGatewaysGetP2SVpnConnectionHealthResponse>>;
    beginGetP2SVpnConnectionHealthAndWait(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysGetP2SVpnConnectionHealthOptionalParams): Promise<P2SVpnGatewaysGetP2SVpnConnectionHealthResponse>;
    beginGetP2SVpnConnectionHealthDetailed(resourceGroupName: string, gatewayName: string, request: P2SVpnConnectionHealthRequest, options?: P2SVpnGatewaysGetP2SVpnConnectionHealthDetailedOptionalParams): Promise<SimplePollerLike<OperationState<P2SVpnGatewaysGetP2SVpnConnectionHealthDetailedResponse>, P2SVpnGatewaysGetP2SVpnConnectionHealthDetailedResponse>>;
    beginGetP2SVpnConnectionHealthDetailedAndWait(resourceGroupName: string, gatewayName: string, request: P2SVpnConnectionHealthRequest, options?: P2SVpnGatewaysGetP2SVpnConnectionHealthDetailedOptionalParams): Promise<P2SVpnGatewaysGetP2SVpnConnectionHealthDetailedResponse>;
    beginReset(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysResetOptionalParams): Promise<SimplePollerLike<OperationState<P2SVpnGatewaysResetResponse>, P2SVpnGatewaysResetResponse>>;
    beginResetAndWait(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysResetOptionalParams): Promise<P2SVpnGatewaysResetResponse>;
    beginUpdateTags(resourceGroupName: string, gatewayName: string, p2SVpnGatewayParameters: TagsObject, options?: P2SVpnGatewaysUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<P2SVpnGatewaysUpdateTagsResponse>, P2SVpnGatewaysUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, gatewayName: string, p2SVpnGatewayParameters: TagsObject, options?: P2SVpnGatewaysUpdateTagsOptionalParams): Promise<P2SVpnGatewaysUpdateTagsResponse>;
    get(resourceGroupName: string, gatewayName: string, options?: P2SVpnGatewaysGetOptionalParams): Promise<P2SVpnGatewaysGetResponse>;
    list(options?: P2SVpnGatewaysListOptionalParams): PagedAsyncIterableIterator<P2SVpnGateway>;
    listByResourceGroup(resourceGroupName: string, options?: P2SVpnGatewaysListByResourceGroupOptionalParams): PagedAsyncIterableIterator<P2SVpnGateway>;
}

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

// @public
export type P2SVpnGatewaysCreateOrUpdateResponse = P2SVpnGateway;

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

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

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

// @public
export type P2SVpnGatewaysGenerateVpnProfileResponse = VpnProfileResponse;

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

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

// @public
export type P2SVpnGatewaysGetP2SVpnConnectionHealthDetailedResponse = P2SVpnConnectionHealth;

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

// @public
export type P2SVpnGatewaysGetP2SVpnConnectionHealthResponse = P2SVpnGateway;

// @public
export type P2SVpnGatewaysGetResponse = P2SVpnGateway;

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

// @public
export type P2SVpnGatewaysListByResourceGroupNextResponse = ListP2SVpnGatewaysResult;

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

// @public
export type P2SVpnGatewaysListByResourceGroupResponse = ListP2SVpnGatewaysResult;

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

// @public
export type P2SVpnGatewaysListNextResponse = ListP2SVpnGatewaysResult;

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

// @public
export type P2SVpnGatewaysListResponse = ListP2SVpnGatewaysResult;

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

// @public
export type P2SVpnGatewaysResetResponse = P2SVpnGateway;

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

// @public
export type P2SVpnGatewaysUpdateTagsResponse = P2SVpnGateway;

// @public
export interface P2SVpnProfileParameters {
    authenticationMethod?: AuthenticationMethod;
}

// @public
export interface PacketCapture {
    bytesToCapturePerPacket?: number;
    captureSettings?: PacketCaptureSettings;
    continuousCapture?: boolean;
    filters?: PacketCaptureFilter[];
    scope?: PacketCaptureMachineScope;
    storageLocation: PacketCaptureStorageLocation;
    target: string;
    targetType?: PacketCaptureTargetType;
    timeLimitInSeconds?: number;
    totalBytesPerSession?: number;
}

// @public
export interface PacketCaptureFilter {
    localIPAddress?: string;
    localPort?: string;
    protocol?: PcProtocol;
    remoteIPAddress?: string;
    remotePort?: string;
}

// @public
export interface PacketCaptureListResult {
    value?: PacketCaptureResult[];
}

// @public
export interface PacketCaptureMachineScope {
    exclude?: string[];
    include?: string[];
}

// @public
export interface PacketCaptureParameters {
    bytesToCapturePerPacket?: number;
    captureSettings?: PacketCaptureSettings;
    continuousCapture?: boolean;
    filters?: PacketCaptureFilter[];
    scope?: PacketCaptureMachineScope;
    storageLocation: PacketCaptureStorageLocation;
    target: string;
    targetType?: PacketCaptureTargetType;
    timeLimitInSeconds?: number;
    totalBytesPerSession?: number;
}

// @public
export interface PacketCaptureQueryStatusResult {
    captureStartTime?: Date;
    id?: string;
    name?: string;
    packetCaptureError?: PcError[];
    packetCaptureStatus?: PcStatus;
    stopReason?: string;
}

// @public
export interface PacketCaptureResult {
    bytesToCapturePerPacket?: number;
    captureSettings?: PacketCaptureSettings;
    continuousCapture?: boolean;
    readonly etag?: string;
    filters?: PacketCaptureFilter[];
    readonly id?: string;
    readonly name?: string;
    readonly provisioningState?: ProvisioningState;
    scope?: PacketCaptureMachineScope;
    storageLocation?: PacketCaptureStorageLocation;
    target?: string;
    targetType?: PacketCaptureTargetType;
    timeLimitInSeconds?: number;
    totalBytesPerSession?: number;
}

// @public
export interface PacketCaptureResultProperties extends PacketCaptureParameters {
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface PacketCaptures {
    beginCreate(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, parameters: PacketCapture, options?: PacketCapturesCreateOptionalParams): Promise<SimplePollerLike<OperationState<PacketCapturesCreateResponse>, PacketCapturesCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, parameters: PacketCapture, options?: PacketCapturesCreateOptionalParams): Promise<PacketCapturesCreateResponse>;
    beginDelete(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesDeleteOptionalParams): Promise<void>;
    beginGetStatus(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesGetStatusOptionalParams): Promise<SimplePollerLike<OperationState<PacketCapturesGetStatusResponse>, PacketCapturesGetStatusResponse>>;
    beginGetStatusAndWait(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesGetStatusOptionalParams): Promise<PacketCapturesGetStatusResponse>;
    beginStop(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesStopOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginStopAndWait(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesStopOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkWatcherName: string, packetCaptureName: string, options?: PacketCapturesGetOptionalParams): Promise<PacketCapturesGetResponse>;
    list(resourceGroupName: string, networkWatcherName: string, options?: PacketCapturesListOptionalParams): PagedAsyncIterableIterator<PacketCaptureResult>;
}

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

// @public
export type PacketCapturesCreateResponse = PacketCaptureResult;

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

// @public
export interface PacketCaptureSettings {
    fileCount?: number;
    fileSizeInBytes?: number;
    sessionTimeLimitInSeconds?: number;
}

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

// @public
export type PacketCapturesGetResponse = PacketCaptureResult;

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

// @public
export type PacketCapturesGetStatusResponse = PacketCaptureQueryStatusResult;

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

// @public
export type PacketCapturesListResponse = PacketCaptureListResult;

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

// @public
export interface PacketCaptureStorageLocation {
    filePath?: string;
    localPath?: string;
    storageId?: string;
    storagePath?: string;
}

// @public
export type PacketCaptureTargetType = "AzureVM" | "AzureVMSS";

// @public
export interface Parameter {
    asPath?: string[];
    community?: string[];
    routePrefix?: string[];
}

// @public
export interface PartnerManagedResourceProperties {
    readonly id?: string;
    readonly internalLoadBalancerId?: string;
    readonly standardLoadBalancerId?: string;
}

// @public
export interface PatchObject {
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface PatchRouteFilter extends SubResource {
    readonly etag?: string;
    readonly ipv6Peerings?: ExpressRouteCircuitPeering[];
    readonly name?: string;
    readonly peerings?: ExpressRouteCircuitPeering[];
    readonly provisioningState?: ProvisioningState;
    rules?: RouteFilterRule[];
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface PatchRouteFilterRule extends SubResource {
    access?: Access;
    communities?: string[];
    readonly etag?: string;
    readonly name?: string;
    readonly provisioningState?: ProvisioningState;
    routeFilterRuleType?: RouteFilterRuleType;
}

// @public
export type PcError = string;

// @public
export type PcProtocol = string;

// @public
export type PcStatus = string;

// @public
export interface PeerExpressRouteCircuitConnection extends SubResource {
    addressPrefix?: string;
    authResourceGuid?: string;
    readonly circuitConnectionStatus?: CircuitConnectionStatus;
    connectionName?: string;
    readonly etag?: string;
    expressRouteCircuitPeering?: SubResource;
    name?: string;
    peerExpressRouteCircuitPeering?: SubResource;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface PeerExpressRouteCircuitConnectionListResult {
    nextLink?: string;
    value?: PeerExpressRouteCircuitConnection[];
}

// @public
export interface PeerExpressRouteCircuitConnections {
    get(resourceGroupName: string, circuitName: string, peeringName: string, connectionName: string, options?: PeerExpressRouteCircuitConnectionsGetOptionalParams): Promise<PeerExpressRouteCircuitConnectionsGetResponse>;
    list(resourceGroupName: string, circuitName: string, peeringName: string, options?: PeerExpressRouteCircuitConnectionsListOptionalParams): PagedAsyncIterableIterator<PeerExpressRouteCircuitConnection>;
}

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

// @public
export type PeerExpressRouteCircuitConnectionsGetResponse = PeerExpressRouteCircuitConnection;

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

// @public
export type PeerExpressRouteCircuitConnectionsListNextResponse = PeerExpressRouteCircuitConnectionListResult;

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

// @public
export type PeerExpressRouteCircuitConnectionsListResponse = PeerExpressRouteCircuitConnectionListResult;

// @public
export type PeeringEnforcement = string;

// @public
export interface PeerRoute {
    readonly asPath?: string;
    readonly localAddress?: string;
    readonly network?: string;
    readonly nextHop?: string;
    readonly origin?: string;
    readonly sourcePeer?: string;
    readonly weight?: number;
}

// @public
export interface PerimeterAssociableResource {
    readonly displayName?: string;
    readonly id?: string;
    name?: string;
    readonly publicDnsZones?: string[];
    readonly resourceType?: string;
    readonly type?: string;
}

// @public
export interface PerimeterAssociableResourcesListResult {
    nextLink?: string;
    value?: PerimeterAssociableResource[];
}

// @public (undocumented)
export interface PerimeterBasedAccessRule {
    readonly id?: string;
    readonly location?: string;
    readonly perimeterGuid?: string;
}

// @public
export type PfsGroup = string;

// @public
export interface PolicySettings {
    customBlockResponseBody?: string;
    customBlockResponseStatusCode?: number;
    fileUploadEnforcement?: boolean;
    fileUploadLimitInMb?: number;
    jsChallengeCookieExpirationInMins?: number;
    logScrubbing?: PolicySettingsLogScrubbing;
    maxRequestBodySizeInKb?: number;
    mode?: WebApplicationFirewallMode;
    requestBodyCheck?: boolean;
    requestBodyEnforcement?: boolean;
    requestBodyInspectLimitInKB?: number;
    state?: WebApplicationFirewallEnabledState;
}

// @public
export interface PolicySettingsLogScrubbing {
    scrubbingRules?: WebApplicationFirewallScrubbingRules[];
    state?: WebApplicationFirewallScrubbingState;
}

// @public
export interface PoolAssociation {
    readonly addressPrefixes?: string[];
    readonly createdAt?: Date;
    // (undocumented)
    description?: string;
    readonly numberOfReservedIPAddresses?: string;
    poolId?: string;
    readonly reservationExpiresAt?: Date;
    readonly reservedPrefixes?: string[];
    resourceId: string;
    readonly totalNumberOfIPAddresses?: string;
}

// @public
export interface PoolAssociationList {
    nextLink?: string;
    // (undocumented)
    value?: PoolAssociation[];
}

// @public
export interface PoolUsage {
    readonly addressPrefixes?: string[];
    readonly allocatedAddressPrefixes?: string[];
    readonly availableAddressPrefixes?: string[];
    readonly childPools?: ResourceBasics[];
    readonly numberOfAllocatedIPAddresses?: string;
    readonly numberOfAvailableIPAddresses?: string;
    readonly numberOfReservedIPAddresses?: string;
    readonly reservedAddressPrefixes?: string[];
    readonly totalNumberOfIPAddresses?: string;
}

// @public
export type PreferredIPVersion = string;

// @public
export type PreferredRoutingGateway = string;

// @public
export interface PrepareNetworkPoliciesRequest {
    networkIntentPolicyConfigurations?: NetworkIntentPolicyConfiguration[];
    serviceName?: string;
}

// @public
export interface PrivateDnsZoneConfig {
    name?: string;
    privateDnsZoneId?: string;
    readonly recordSets?: RecordSet[];
}

// @public
export interface PrivateDnsZoneGroup extends SubResource {
    readonly etag?: string;
    name?: string;
    privateDnsZoneConfigs?: PrivateDnsZoneConfig[];
    readonly provisioningState?: ProvisioningState;
}

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

// @public
export interface PrivateDnsZoneGroups {
    beginCreateOrUpdate(resourceGroupName: string, privateEndpointName: string, privateDnsZoneGroupName: string, parameters: PrivateDnsZoneGroup, options?: PrivateDnsZoneGroupsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PrivateDnsZoneGroupsCreateOrUpdateResponse>, PrivateDnsZoneGroupsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, privateEndpointName: string, privateDnsZoneGroupName: string, parameters: PrivateDnsZoneGroup, options?: PrivateDnsZoneGroupsCreateOrUpdateOptionalParams): Promise<PrivateDnsZoneGroupsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, privateEndpointName: string, privateDnsZoneGroupName: string, options?: PrivateDnsZoneGroupsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, privateEndpointName: string, privateDnsZoneGroupName: string, options?: PrivateDnsZoneGroupsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, privateEndpointName: string, privateDnsZoneGroupName: string, options?: PrivateDnsZoneGroupsGetOptionalParams): Promise<PrivateDnsZoneGroupsGetResponse>;
    list(privateEndpointName: string, resourceGroupName: string, options?: PrivateDnsZoneGroupsListOptionalParams): PagedAsyncIterableIterator<PrivateDnsZoneGroup>;
}

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

// @public
export type PrivateDnsZoneGroupsCreateOrUpdateResponse = PrivateDnsZoneGroup;

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

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

// @public
export type PrivateDnsZoneGroupsGetResponse = PrivateDnsZoneGroup;

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

// @public
export type PrivateDnsZoneGroupsListNextResponse = PrivateDnsZoneGroupListResult;

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

// @public
export type PrivateDnsZoneGroupsListResponse = PrivateDnsZoneGroupListResult;

// @public
export interface PrivateEndpoint extends Resource {
    applicationSecurityGroups?: ApplicationSecurityGroup[];
    customDnsConfigs?: CustomDnsConfigPropertiesFormat[];
    customNetworkInterfaceName?: string;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    ipConfigurations?: PrivateEndpointIPConfiguration[];
    manualPrivateLinkServiceConnections?: PrivateLinkServiceConnection[];
    readonly networkInterfaces?: NetworkInterface[];
    privateLinkServiceConnections?: PrivateLinkServiceConnection[];
    readonly provisioningState?: ProvisioningState;
    subnet?: Subnet;
}

// @public
export interface PrivateEndpointConnection extends SubResource {
    readonly etag?: string;
    readonly linkIdentifier?: string;
    name?: string;
    readonly privateEndpoint?: PrivateEndpoint;
    readonly privateEndpointLocation?: string;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

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

// @public
export interface PrivateEndpointIPConfiguration {
    readonly etag?: string;
    groupId?: string;
    memberName?: string;
    name?: string;
    privateIPAddress?: string;
    readonly type?: string;
}

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

// @public
export interface PrivateEndpoints {
    beginCreateOrUpdate(resourceGroupName: string, privateEndpointName: string, parameters: PrivateEndpoint, options?: PrivateEndpointsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PrivateEndpointsCreateOrUpdateResponse>, PrivateEndpointsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, privateEndpointName: string, parameters: PrivateEndpoint, options?: PrivateEndpointsCreateOrUpdateOptionalParams): Promise<PrivateEndpointsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, privateEndpointName: string, options?: PrivateEndpointsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, privateEndpointName: string, options?: PrivateEndpointsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, privateEndpointName: string, options?: PrivateEndpointsGetOptionalParams): Promise<PrivateEndpointsGetResponse>;
    list(resourceGroupName: string, options?: PrivateEndpointsListOptionalParams): PagedAsyncIterableIterator<PrivateEndpoint>;
    listBySubscription(options?: PrivateEndpointsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<PrivateEndpoint>;
}

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

// @public
export type PrivateEndpointsCreateOrUpdateResponse = PrivateEndpoint;

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

// @public
export interface PrivateEndpointsGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type PrivateEndpointsGetResponse = PrivateEndpoint;

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

// @public
export type PrivateEndpointsListBySubscriptionNextResponse = PrivateEndpointListResult;

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

// @public
export type PrivateEndpointsListBySubscriptionResponse = PrivateEndpointListResult;

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

// @public
export type PrivateEndpointsListNextResponse = PrivateEndpointListResult;

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

// @public
export type PrivateEndpointsListResponse = PrivateEndpointListResult;

// @public
export type PrivateEndpointVNetPolicies = string;

// @public
export interface PrivateLinkService extends Resource {
    readonly alias?: string;
    autoApproval?: PrivateLinkServicePropertiesAutoApproval;
    destinationIPAddress?: string;
    enableProxyProtocol?: boolean;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    fqdns?: string[];
    ipConfigurations?: PrivateLinkServiceIpConfiguration[];
    loadBalancerFrontendIpConfigurations?: FrontendIPConfiguration[];
    readonly networkInterfaces?: NetworkInterface[];
    readonly privateEndpointConnections?: PrivateEndpointConnection[];
    readonly provisioningState?: ProvisioningState;
    visibility?: PrivateLinkServicePropertiesVisibility;
}

// @public
export interface PrivateLinkServiceConnection extends SubResource {
    readonly etag?: string;
    groupIds?: string[];
    name?: string;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
    privateLinkServiceId?: string;
    readonly provisioningState?: ProvisioningState;
    requestMessage?: string;
    readonly type?: string;
}

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

// @public
export interface PrivateLinkServiceIpConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    primary?: boolean;
    privateIPAddress?: string;
    privateIPAddressVersion?: IPVersion;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    subnet?: Subnet;
    readonly type?: string;
}

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

// @public
export interface PrivateLinkServicePropertiesAutoApproval extends ResourceSet {
}

// @public
export interface PrivateLinkServicePropertiesVisibility extends ResourceSet {
}

// @public
export interface PrivateLinkServices {
    beginCheckPrivateLinkServiceVisibility(location: string, parameters: CheckPrivateLinkServiceVisibilityRequest, options?: PrivateLinkServicesCheckPrivateLinkServiceVisibilityOptionalParams): Promise<SimplePollerLike<OperationState<PrivateLinkServicesCheckPrivateLinkServiceVisibilityResponse>, PrivateLinkServicesCheckPrivateLinkServiceVisibilityResponse>>;
    beginCheckPrivateLinkServiceVisibilityAndWait(location: string, parameters: CheckPrivateLinkServiceVisibilityRequest, options?: PrivateLinkServicesCheckPrivateLinkServiceVisibilityOptionalParams): Promise<PrivateLinkServicesCheckPrivateLinkServiceVisibilityResponse>;
    beginCheckPrivateLinkServiceVisibilityByResourceGroup(location: string, resourceGroupName: string, parameters: CheckPrivateLinkServiceVisibilityRequest, options?: PrivateLinkServicesCheckPrivateLinkServiceVisibilityByResourceGroupOptionalParams): Promise<SimplePollerLike<OperationState<PrivateLinkServicesCheckPrivateLinkServiceVisibilityByResourceGroupResponse>, PrivateLinkServicesCheckPrivateLinkServiceVisibilityByResourceGroupResponse>>;
    beginCheckPrivateLinkServiceVisibilityByResourceGroupAndWait(location: string, resourceGroupName: string, parameters: CheckPrivateLinkServiceVisibilityRequest, options?: PrivateLinkServicesCheckPrivateLinkServiceVisibilityByResourceGroupOptionalParams): Promise<PrivateLinkServicesCheckPrivateLinkServiceVisibilityByResourceGroupResponse>;
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, parameters: PrivateLinkService, options?: PrivateLinkServicesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PrivateLinkServicesCreateOrUpdateResponse>, PrivateLinkServicesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, parameters: PrivateLinkService, options?: PrivateLinkServicesCreateOrUpdateOptionalParams): Promise<PrivateLinkServicesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, serviceName: string, options?: PrivateLinkServicesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, serviceName: string, options?: PrivateLinkServicesDeleteOptionalParams): Promise<void>;
    beginDeletePrivateEndpointConnection(resourceGroupName: string, serviceName: string, peConnectionName: string, options?: PrivateLinkServicesDeletePrivateEndpointConnectionOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeletePrivateEndpointConnectionAndWait(resourceGroupName: string, serviceName: string, peConnectionName: string, options?: PrivateLinkServicesDeletePrivateEndpointConnectionOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, options?: PrivateLinkServicesGetOptionalParams): Promise<PrivateLinkServicesGetResponse>;
    getPrivateEndpointConnection(resourceGroupName: string, serviceName: string, peConnectionName: string, options?: PrivateLinkServicesGetPrivateEndpointConnectionOptionalParams): Promise<PrivateLinkServicesGetPrivateEndpointConnectionResponse>;
    list(resourceGroupName: string, options?: PrivateLinkServicesListOptionalParams): PagedAsyncIterableIterator<PrivateLinkService>;
    listAutoApprovedPrivateLinkServices(location: string, options?: PrivateLinkServicesListAutoApprovedPrivateLinkServicesOptionalParams): PagedAsyncIterableIterator<AutoApprovedPrivateLinkService>;
    listAutoApprovedPrivateLinkServicesByResourceGroup(location: string, resourceGroupName: string, options?: PrivateLinkServicesListAutoApprovedPrivateLinkServicesByResourceGroupOptionalParams): PagedAsyncIterableIterator<AutoApprovedPrivateLinkService>;
    listBySubscription(options?: PrivateLinkServicesListBySubscriptionOptionalParams): PagedAsyncIterableIterator<PrivateLinkService>;
    listPrivateEndpointConnections(resourceGroupName: string, serviceName: string, options?: PrivateLinkServicesListPrivateEndpointConnectionsOptionalParams): PagedAsyncIterableIterator<PrivateEndpointConnection>;
    updatePrivateEndpointConnection(resourceGroupName: string, serviceName: string, peConnectionName: string, parameters: PrivateEndpointConnection, options?: PrivateLinkServicesUpdatePrivateEndpointConnectionOptionalParams): Promise<PrivateLinkServicesUpdatePrivateEndpointConnectionResponse>;
}

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

// @public
export type PrivateLinkServicesCheckPrivateLinkServiceVisibilityByResourceGroupResponse = PrivateLinkServiceVisibility;

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

// @public
export type PrivateLinkServicesCheckPrivateLinkServiceVisibilityResponse = PrivateLinkServiceVisibility;

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

// @public
export type PrivateLinkServicesCreateOrUpdateResponse = PrivateLinkService;

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

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

// @public
export interface PrivateLinkServicesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export interface PrivateLinkServicesGetPrivateEndpointConnectionOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type PrivateLinkServicesGetPrivateEndpointConnectionResponse = PrivateEndpointConnection;

// @public
export type PrivateLinkServicesGetResponse = PrivateLinkService;

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

// @public
export type PrivateLinkServicesListAutoApprovedPrivateLinkServicesByResourceGroupNextResponse = AutoApprovedPrivateLinkServicesResult;

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

// @public
export type PrivateLinkServicesListAutoApprovedPrivateLinkServicesByResourceGroupResponse = AutoApprovedPrivateLinkServicesResult;

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

// @public
export type PrivateLinkServicesListAutoApprovedPrivateLinkServicesNextResponse = AutoApprovedPrivateLinkServicesResult;

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

// @public
export type PrivateLinkServicesListAutoApprovedPrivateLinkServicesResponse = AutoApprovedPrivateLinkServicesResult;

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

// @public
export type PrivateLinkServicesListBySubscriptionNextResponse = PrivateLinkServiceListResult;

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

// @public
export type PrivateLinkServicesListBySubscriptionResponse = PrivateLinkServiceListResult;

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

// @public
export type PrivateLinkServicesListNextResponse = PrivateLinkServiceListResult;

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

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

// @public
export type PrivateLinkServicesListPrivateEndpointConnectionsNextResponse = PrivateEndpointConnectionListResult;

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

// @public
export type PrivateLinkServicesListPrivateEndpointConnectionsResponse = PrivateEndpointConnectionListResult;

// @public
export type PrivateLinkServicesListResponse = PrivateLinkServiceListResult;

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

// @public
export type PrivateLinkServicesUpdatePrivateEndpointConnectionResponse = PrivateEndpointConnection;

// @public
export interface PrivateLinkServiceVisibility {
    visible?: boolean;
}

// @public
export interface Probe extends SubResource {
    readonly etag?: string;
    intervalInSeconds?: number;
    readonly loadBalancingRules?: SubResource[];
    name?: string;
    noHealthyBackendsBehavior?: ProbeNoHealthyBackendsBehavior;
    numberOfProbes?: number;
    port?: number;
    probeThreshold?: number;
    protocol?: ProbeProtocol;
    readonly provisioningState?: ProvisioningState;
    requestPath?: string;
    readonly type?: string;
}

// @public
export type ProbeNoHealthyBackendsBehavior = string;

// @public
export type ProbeProtocol = string;

// @public
export type ProcessorArchitecture = string;

// @public
export interface PropagatedRouteTable {
    ids?: SubResource[];
    labels?: string[];
}

// @public
export type Protocol = string;

// @public
export interface ProtocolConfiguration {
    httpConfiguration?: HttpConfiguration;
}

// @public
export type ProtocolType = string;

// @public
export type ProvisioningState = string;

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

// @public
export interface PublicIPAddress extends Resource {
    ddosSettings?: DdosSettings;
    deleteOption?: DeleteOptions;
    dnsSettings?: PublicIPAddressDnsSettings;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    idleTimeoutInMinutes?: number;
    ipAddress?: string;
    readonly ipConfiguration?: IPConfiguration;
    ipTags?: IpTag[];
    linkedPublicIPAddress?: PublicIPAddress;
    migrationPhase?: PublicIPAddressMigrationPhase;
    natGateway?: NatGateway;
    readonly provisioningState?: ProvisioningState;
    publicIPAddressVersion?: IPVersion;
    publicIPAllocationMethod?: IPAllocationMethod;
    publicIPPrefix?: SubResource;
    readonly resourceGuid?: string;
    servicePublicIPAddress?: PublicIPAddress;
    sku?: PublicIPAddressSku;
    zones?: string[];
}

// @public
export interface PublicIPAddressDnsSettings {
    domainNameLabel?: string;
    domainNameLabelScope?: PublicIpAddressDnsSettingsDomainNameLabelScope;
    fqdn?: string;
    reverseFqdn?: string;
}

// @public
export type PublicIpAddressDnsSettingsDomainNameLabelScope = "TenantReuse" | "SubscriptionReuse" | "ResourceGroupReuse" | "NoReuse";

// @public
export interface PublicIPAddresses {
    beginCreateOrUpdate(resourceGroupName: string, publicIpAddressName: string, parameters: PublicIPAddress, options?: PublicIPAddressesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PublicIPAddressesCreateOrUpdateResponse>, PublicIPAddressesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, publicIpAddressName: string, parameters: PublicIPAddress, options?: PublicIPAddressesCreateOrUpdateOptionalParams): Promise<PublicIPAddressesCreateOrUpdateResponse>;
    beginDdosProtectionStatus(resourceGroupName: string, publicIpAddressName: string, options?: PublicIPAddressesDdosProtectionStatusOptionalParams): Promise<SimplePollerLike<OperationState<PublicIPAddressesDdosProtectionStatusResponse>, PublicIPAddressesDdosProtectionStatusResponse>>;
    beginDdosProtectionStatusAndWait(resourceGroupName: string, publicIpAddressName: string, options?: PublicIPAddressesDdosProtectionStatusOptionalParams): Promise<PublicIPAddressesDdosProtectionStatusResponse>;
    beginDelete(resourceGroupName: string, publicIpAddressName: string, options?: PublicIPAddressesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, publicIpAddressName: string, options?: PublicIPAddressesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, publicIpAddressName: string, options?: PublicIPAddressesGetOptionalParams): Promise<PublicIPAddressesGetResponse>;
    getCloudServicePublicIPAddress(resourceGroupName: string, cloudServiceName: string, roleInstanceName: string, networkInterfaceName: string, ipConfigurationName: string, publicIpAddressName: string, options?: PublicIPAddressesGetCloudServicePublicIPAddressOptionalParams): Promise<PublicIPAddressesGetCloudServicePublicIPAddressResponse>;
    getVirtualMachineScaleSetPublicIPAddress(resourceGroupName: string, virtualMachineScaleSetName: string, virtualmachineIndex: string, networkInterfaceName: string, ipConfigurationName: string, publicIpAddressName: string, options?: PublicIPAddressesGetVirtualMachineScaleSetPublicIPAddressOptionalParams): Promise<PublicIPAddressesGetVirtualMachineScaleSetPublicIPAddressResponse>;
    list(resourceGroupName: string, options?: PublicIPAddressesListOptionalParams): PagedAsyncIterableIterator<PublicIPAddress>;
    listAll(options?: PublicIPAddressesListAllOptionalParams): PagedAsyncIterableIterator<PublicIPAddress>;
    listCloudServicePublicIPAddresses(resourceGroupName: string, cloudServiceName: string, options?: PublicIPAddressesListCloudServicePublicIPAddressesOptionalParams): PagedAsyncIterableIterator<PublicIPAddress>;
    listCloudServiceRoleInstancePublicIPAddresses(resourceGroupName: string, cloudServiceName: string, roleInstanceName: string, networkInterfaceName: string, ipConfigurationName: string, options?: PublicIPAddressesListCloudServiceRoleInstancePublicIPAddressesOptionalParams): PagedAsyncIterableIterator<PublicIPAddress>;
    listVirtualMachineScaleSetPublicIPAddresses(resourceGroupName: string, virtualMachineScaleSetName: string, options?: PublicIPAddressesListVirtualMachineScaleSetPublicIPAddressesOptionalParams): PagedAsyncIterableIterator<PublicIPAddress>;
    listVirtualMachineScaleSetVMPublicIPAddresses(resourceGroupName: string, virtualMachineScaleSetName: string, virtualmachineIndex: string, networkInterfaceName: string, ipConfigurationName: string, options?: PublicIPAddressesListVirtualMachineScaleSetVMPublicIPAddressesOptionalParams): PagedAsyncIterableIterator<PublicIPAddress>;
    updateTags(resourceGroupName: string, publicIpAddressName: string, parameters: TagsObject, options?: PublicIPAddressesUpdateTagsOptionalParams): Promise<PublicIPAddressesUpdateTagsResponse>;
}

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

// @public
export type PublicIPAddressesCreateOrUpdateResponse = PublicIPAddress;

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

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

// @public
export type PublicIPAddressesDdosProtectionStatusResponse = PublicIpDdosProtectionStatusResult;

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

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

// @public
export interface PublicIPAddressesGetCloudServicePublicIPAddressOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type PublicIPAddressesGetCloudServicePublicIPAddressResponse = PublicIPAddress;

// @public
export interface PublicIPAddressesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type PublicIPAddressesGetResponse = PublicIPAddress;

// @public
export interface PublicIPAddressesGetVirtualMachineScaleSetPublicIPAddressOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type PublicIPAddressesGetVirtualMachineScaleSetPublicIPAddressResponse = PublicIPAddress;

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

// @public
export type PublicIPAddressesListAllNextResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListAllResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListCloudServicePublicIPAddressesNextResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListCloudServicePublicIPAddressesResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListCloudServiceRoleInstancePublicIPAddressesNextResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListCloudServiceRoleInstancePublicIPAddressesResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListNextResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListVirtualMachineScaleSetPublicIPAddressesNextResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListVirtualMachineScaleSetPublicIPAddressesResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListVirtualMachineScaleSetVMPublicIPAddressesNextResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesListVirtualMachineScaleSetVMPublicIPAddressesResponse = PublicIPAddressListResult;

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

// @public
export type PublicIPAddressesUpdateTagsResponse = PublicIPAddress;

// @public
export interface PublicIPAddressListResult {
    nextLink?: string;
    value?: PublicIPAddress[];
}

// @public
export type PublicIPAddressMigrationPhase = string;

// @public
export interface PublicIPAddressSku {
    name?: PublicIPAddressSkuName;
    tier?: PublicIPAddressSkuTier;
}

// @public
export type PublicIPAddressSkuName = string;

// @public
export type PublicIPAddressSkuTier = string;

// @public
export interface PublicIpDdosProtectionStatusResult {
    ddosProtectionPlanId?: string;
    isWorkloadProtected?: IsWorkloadProtected;
    publicIpAddress?: string;
    publicIpAddressId?: string;
}

// @public
export interface PublicIPPrefix extends Resource {
    customIPPrefix?: SubResource;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    readonly ipPrefix?: string;
    ipTags?: IpTag[];
    readonly loadBalancerFrontendIpConfiguration?: SubResource;
    natGateway?: NatGateway;
    prefixLength?: number;
    readonly provisioningState?: ProvisioningState;
    readonly publicIPAddresses?: ReferencedPublicIpAddress[];
    publicIPAddressVersion?: IPVersion;
    readonly resourceGuid?: string;
    sku?: PublicIPPrefixSku;
    zones?: string[];
}

// @public
export interface PublicIPPrefixes {
    beginCreateOrUpdate(resourceGroupName: string, publicIpPrefixName: string, parameters: PublicIPPrefix, options?: PublicIPPrefixesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PublicIPPrefixesCreateOrUpdateResponse>, PublicIPPrefixesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, publicIpPrefixName: string, parameters: PublicIPPrefix, options?: PublicIPPrefixesCreateOrUpdateOptionalParams): Promise<PublicIPPrefixesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, publicIpPrefixName: string, options?: PublicIPPrefixesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, publicIpPrefixName: string, options?: PublicIPPrefixesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, publicIpPrefixName: string, options?: PublicIPPrefixesGetOptionalParams): Promise<PublicIPPrefixesGetResponse>;
    list(resourceGroupName: string, options?: PublicIPPrefixesListOptionalParams): PagedAsyncIterableIterator<PublicIPPrefix>;
    listAll(options?: PublicIPPrefixesListAllOptionalParams): PagedAsyncIterableIterator<PublicIPPrefix>;
    updateTags(resourceGroupName: string, publicIpPrefixName: string, parameters: TagsObject, options?: PublicIPPrefixesUpdateTagsOptionalParams): Promise<PublicIPPrefixesUpdateTagsResponse>;
}

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

// @public
export type PublicIPPrefixesCreateOrUpdateResponse = PublicIPPrefix;

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

// @public
export interface PublicIPPrefixesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type PublicIPPrefixesGetResponse = PublicIPPrefix;

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

// @public
export type PublicIPPrefixesListAllNextResponse = PublicIPPrefixListResult;

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

// @public
export type PublicIPPrefixesListAllResponse = PublicIPPrefixListResult;

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

// @public
export type PublicIPPrefixesListNextResponse = PublicIPPrefixListResult;

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

// @public
export type PublicIPPrefixesListResponse = PublicIPPrefixListResult;

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

// @public
export type PublicIPPrefixesUpdateTagsResponse = PublicIPPrefix;

// @public
export interface PublicIPPrefixListResult {
    nextLink?: string;
    value?: PublicIPPrefix[];
}

// @public
export interface PublicIPPrefixSku {
    name?: PublicIPPrefixSkuName;
    tier?: PublicIPPrefixSkuTier;
}

// @public
export type PublicIPPrefixSkuName = string;

// @public
export type PublicIPPrefixSkuTier = string;

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

// @public
export type PutBastionShareableLinkNextResponse = BastionShareableLinkListResult;

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

// @public
export type PutBastionShareableLinkResponse = BastionShareableLinkListResult;

// @public
export interface QosDefinition {
    destinationIpRanges?: QosIpRange[];
    destinationPortRanges?: QosPortRange[];
    markings?: number[];
    protocol?: ProtocolType;
    sourceIpRanges?: QosIpRange[];
    sourcePortRanges?: QosPortRange[];
}

// @public
export interface QosIpRange {
    endIP?: string;
    startIP?: string;
}

// @public
export interface QosPortRange {
    end?: number;
    start?: number;
}

// @public
export interface QueryInboundNatRulePortMappingRequest {
    ipAddress?: string;
    ipConfiguration?: SubResource;
}

// @public
export interface QueryRequestOptions {
    skipToken?: string;
}

// @public
export interface QueryResults {
    matchingRecordsCount?: number;
    signatures?: SingleQueryResult[];
}

// @public
export interface QueryTroubleshootingParameters {
    targetResourceId: string;
}

// @public
export interface RadiusServer {
    radiusServerAddress: string;
    radiusServerScore?: number;
    radiusServerSecret?: string;
}

// @public
export interface ReachabilityAnalysisIntent extends CommonProxyResource {
    properties: ReachabilityAnalysisIntentProperties;
}

// @public
export interface ReachabilityAnalysisIntentListResult {
    nextLink?: string;
    value?: ReachabilityAnalysisIntent[];
}

// @public
export interface ReachabilityAnalysisIntentProperties {
    // (undocumented)
    description?: string;
    destinationResourceId: string;
    ipTraffic: IPTraffic;
    provisioningState?: ProvisioningState;
    sourceResourceId: string;
}

// @public
export interface ReachabilityAnalysisIntents {
    create(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisIntentName: string, body: ReachabilityAnalysisIntent, options?: ReachabilityAnalysisIntentsCreateOptionalParams): Promise<ReachabilityAnalysisIntentsCreateResponse>;
    delete(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisIntentName: string, options?: ReachabilityAnalysisIntentsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisIntentName: string, options?: ReachabilityAnalysisIntentsGetOptionalParams): Promise<ReachabilityAnalysisIntentsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, workspaceName: string, options?: ReachabilityAnalysisIntentsListOptionalParams): PagedAsyncIterableIterator<ReachabilityAnalysisIntent>;
}

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

// @public
export type ReachabilityAnalysisIntentsCreateResponse = ReachabilityAnalysisIntent;

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

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

// @public
export type ReachabilityAnalysisIntentsGetResponse = ReachabilityAnalysisIntent;

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

// @public
export type ReachabilityAnalysisIntentsListNextResponse = ReachabilityAnalysisIntentListResult;

// @public
export interface ReachabilityAnalysisIntentsListOptionalParams extends coreClient.OperationOptions {
    skip?: number;
    skipToken?: string;
    sortKey?: string;
    sortValue?: string;
    top?: number;
}

// @public
export type ReachabilityAnalysisIntentsListResponse = ReachabilityAnalysisIntentListResult;

// @public
export interface ReachabilityAnalysisRun extends CommonProxyResource {
    properties: ReachabilityAnalysisRunProperties;
}

// @public
export interface ReachabilityAnalysisRunListResult {
    nextLink?: string;
    value?: ReachabilityAnalysisRun[];
}

// @public
export interface ReachabilityAnalysisRunProperties {
    readonly analysisResult?: string;
    // (undocumented)
    description?: string;
    readonly errorMessage?: string;
    readonly intentContent?: IntentContent;
    intentId: string;
    provisioningState?: ProvisioningState;
}

// @public
export interface ReachabilityAnalysisRuns {
    beginDelete(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisRunName: string, options?: ReachabilityAnalysisRunsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<ReachabilityAnalysisRunsDeleteResponse>, ReachabilityAnalysisRunsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisRunName: string, options?: ReachabilityAnalysisRunsDeleteOptionalParams): Promise<ReachabilityAnalysisRunsDeleteResponse>;
    create(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisRunName: string, body: ReachabilityAnalysisRun, options?: ReachabilityAnalysisRunsCreateOptionalParams): Promise<ReachabilityAnalysisRunsCreateResponse>;
    get(resourceGroupName: string, networkManagerName: string, workspaceName: string, reachabilityAnalysisRunName: string, options?: ReachabilityAnalysisRunsGetOptionalParams): Promise<ReachabilityAnalysisRunsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, workspaceName: string, options?: ReachabilityAnalysisRunsListOptionalParams): PagedAsyncIterableIterator<ReachabilityAnalysisRun>;
}

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

// @public
export type ReachabilityAnalysisRunsCreateResponse = ReachabilityAnalysisRun;

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

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

// @public
export type ReachabilityAnalysisRunsDeleteResponse = ReachabilityAnalysisRunsDeleteHeaders;

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

// @public
export type ReachabilityAnalysisRunsGetResponse = ReachabilityAnalysisRun;

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

// @public
export type ReachabilityAnalysisRunsListNextResponse = ReachabilityAnalysisRunListResult;

// @public
export interface ReachabilityAnalysisRunsListOptionalParams extends coreClient.OperationOptions {
    skip?: number;
    skipToken?: string;
    sortKey?: string;
    sortValue?: string;
    top?: number;
}

// @public
export type ReachabilityAnalysisRunsListResponse = ReachabilityAnalysisRunListResult;

// @public
export interface RecordSet {
    fqdn?: string;
    ipAddresses?: string[];
    readonly provisioningState?: ProvisioningState;
    recordSetName?: string;
    recordType?: string;
    ttl?: number;
}

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

// @public
export type ResiliencyModel = string;

// @public
export interface ResiliencyRecommendationComponents {
    currentScore?: string;
    maxScore?: string;
    name?: string;
    recommendations?: GatewayResiliencyRecommendation[];
}

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

// @public
export interface ResourceBasics {
    addressPrefixes?: string[];
    resourceId?: string;
}

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

// @public
export interface ResourceNavigationLink extends SubResource {
    readonly etag?: string;
    link?: string;
    linkedResourceType?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ResourceNavigationLinks {
    list(resourceGroupName: string, virtualNetworkName: string, subnetName: string, options?: ResourceNavigationLinksListOptionalParams): Promise<ResourceNavigationLinksListResponse>;
}

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

// @public
export type ResourceNavigationLinksListResponse = ResourceNavigationLinksListResult;

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

// @public
export interface ResourceSet {
    subscriptions?: string[];
}

// @public
export interface RetentionPolicyParameters {
    days?: number;
    enabled?: boolean;
}

// @public
export interface Route extends SubResource {
    addressPrefix?: string;
    readonly etag?: string;
    readonly hasBgpOverride?: boolean;
    name?: string;
    nextHopIpAddress?: string;
    nextHopType?: RouteNextHopType;
    readonly provisioningState?: ProvisioningState;
    type?: string;
}

// @public
export interface RouteFilter extends Resource {
    readonly etag?: string;
    readonly ipv6Peerings?: ExpressRouteCircuitPeering[];
    readonly peerings?: ExpressRouteCircuitPeering[];
    readonly provisioningState?: ProvisioningState;
    rules?: RouteFilterRule[];
}

// @public
export interface RouteFilterListResult {
    nextLink?: string;
    value?: RouteFilter[];
}

// @public
export interface RouteFilterRule extends SubResource {
    access?: Access;
    communities?: string[];
    readonly etag?: string;
    location?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    routeFilterRuleType?: RouteFilterRuleType;
}

// @public
export interface RouteFilterRuleListResult {
    nextLink?: string;
    value?: RouteFilterRule[];
}

// @public
export interface RouteFilterRules {
    beginCreateOrUpdate(resourceGroupName: string, routeFilterName: string, ruleName: string, routeFilterRuleParameters: RouteFilterRule, options?: RouteFilterRulesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RouteFilterRulesCreateOrUpdateResponse>, RouteFilterRulesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, routeFilterName: string, ruleName: string, routeFilterRuleParameters: RouteFilterRule, options?: RouteFilterRulesCreateOrUpdateOptionalParams): Promise<RouteFilterRulesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, routeFilterName: string, ruleName: string, options?: RouteFilterRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, routeFilterName: string, ruleName: string, options?: RouteFilterRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, routeFilterName: string, ruleName: string, options?: RouteFilterRulesGetOptionalParams): Promise<RouteFilterRulesGetResponse>;
    listByRouteFilter(resourceGroupName: string, routeFilterName: string, options?: RouteFilterRulesListByRouteFilterOptionalParams): PagedAsyncIterableIterator<RouteFilterRule>;
}

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

// @public
export type RouteFilterRulesCreateOrUpdateResponse = RouteFilterRule;

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

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

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

// @public
export type RouteFilterRulesGetResponse = RouteFilterRule;

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

// @public
export type RouteFilterRulesListByRouteFilterNextResponse = RouteFilterRuleListResult;

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

// @public
export type RouteFilterRulesListByRouteFilterResponse = RouteFilterRuleListResult;

// @public
export type RouteFilterRuleType = string;

// @public
export interface RouteFilters {
    beginCreateOrUpdate(resourceGroupName: string, routeFilterName: string, routeFilterParameters: RouteFilter, options?: RouteFiltersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RouteFiltersCreateOrUpdateResponse>, RouteFiltersCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, routeFilterName: string, routeFilterParameters: RouteFilter, options?: RouteFiltersCreateOrUpdateOptionalParams): Promise<RouteFiltersCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, routeFilterName: string, options?: RouteFiltersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, routeFilterName: string, options?: RouteFiltersDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, routeFilterName: string, options?: RouteFiltersGetOptionalParams): Promise<RouteFiltersGetResponse>;
    list(options?: RouteFiltersListOptionalParams): PagedAsyncIterableIterator<RouteFilter>;
    listByResourceGroup(resourceGroupName: string, options?: RouteFiltersListByResourceGroupOptionalParams): PagedAsyncIterableIterator<RouteFilter>;
    updateTags(resourceGroupName: string, routeFilterName: string, parameters: TagsObject, options?: RouteFiltersUpdateTagsOptionalParams): Promise<RouteFiltersUpdateTagsResponse>;
}

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

// @public
export type RouteFiltersCreateOrUpdateResponse = RouteFilter;

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

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

// @public
export interface RouteFiltersGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type RouteFiltersGetResponse = RouteFilter;

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

// @public
export type RouteFiltersListByResourceGroupNextResponse = RouteFilterListResult;

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

// @public
export type RouteFiltersListByResourceGroupResponse = RouteFilterListResult;

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

// @public
export type RouteFiltersListNextResponse = RouteFilterListResult;

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

// @public
export type RouteFiltersListResponse = RouteFilterListResult;

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

// @public
export type RouteFiltersUpdateTagsResponse = RouteFilter;

// @public
export interface RouteListResult {
    nextLink?: string;
    value?: Route[];
}

// @public
export interface RouteMap extends SubResource {
    associatedInboundConnections?: string[];
    associatedOutboundConnections?: string[];
    readonly etag?: string;
    readonly name?: string;
    readonly provisioningState?: ProvisioningState;
    rules?: RouteMapRule[];
    readonly type?: string;
}

// @public
export type RouteMapActionType = string;

// @public
export type RouteMapMatchCondition = string;

// @public
export interface RouteMapRule {
    actions?: Action[];
    matchCriteria?: Criterion[];
    name?: string;
    nextStepIfMatched?: NextStep;
}

// @public
export interface RouteMaps {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, routeMapName: string, routeMapParameters: RouteMap, options?: RouteMapsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RouteMapsCreateOrUpdateResponse>, RouteMapsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, routeMapName: string, routeMapParameters: RouteMap, options?: RouteMapsCreateOrUpdateOptionalParams): Promise<RouteMapsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, routeMapName: string, options?: RouteMapsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, routeMapName: string, options?: RouteMapsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, routeMapName: string, options?: RouteMapsGetOptionalParams): Promise<RouteMapsGetResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: RouteMapsListOptionalParams): PagedAsyncIterableIterator<RouteMap>;
}

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

// @public
export type RouteMapsCreateOrUpdateResponse = RouteMap;

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

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

// @public
export type RouteMapsGetResponse = RouteMap;

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

// @public
export type RouteMapsListNextResponse = ListRouteMapsResult;

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

// @public
export type RouteMapsListResponse = ListRouteMapsResult;

// @public
export type RouteNextHopType = string;

// @public
export interface Routes {
    beginCreateOrUpdate(resourceGroupName: string, routeTableName: string, routeName: string, routeParameters: Route, options?: RoutesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RoutesCreateOrUpdateResponse>, RoutesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, routeTableName: string, routeName: string, routeParameters: Route, options?: RoutesCreateOrUpdateOptionalParams): Promise<RoutesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, routeTableName: string, routeName: string, options?: RoutesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, routeTableName: string, routeName: string, options?: RoutesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, routeTableName: string, routeName: string, options?: RoutesGetOptionalParams): Promise<RoutesGetResponse>;
    list(resourceGroupName: string, routeTableName: string, options?: RoutesListOptionalParams): PagedAsyncIterableIterator<Route>;
}

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

// @public
export type RoutesCreateOrUpdateResponse = Route;

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

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

// @public
export type RoutesGetResponse = Route;

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

// @public
export type RoutesListNextResponse = RouteListResult;

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

// @public
export type RoutesListResponse = RouteListResult;

// @public (undocumented)
export interface RouteSourceDetails {
    circuit?: string;
    pri?: string;
    sec?: string;
}

// @public
export interface RouteTable extends Resource {
    disableBgpRoutePropagation?: boolean;
    readonly etag?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    routes?: Route[];
    readonly subnets?: Subnet[];
}

// @public
export interface RouteTableListResult {
    nextLink?: string;
    value?: RouteTable[];
}

// @public
export interface RouteTables {
    beginCreateOrUpdate(resourceGroupName: string, routeTableName: string, parameters: RouteTable, options?: RouteTablesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RouteTablesCreateOrUpdateResponse>, RouteTablesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, routeTableName: string, parameters: RouteTable, options?: RouteTablesCreateOrUpdateOptionalParams): Promise<RouteTablesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, routeTableName: string, options?: RouteTablesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, routeTableName: string, options?: RouteTablesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, routeTableName: string, options?: RouteTablesGetOptionalParams): Promise<RouteTablesGetResponse>;
    list(resourceGroupName: string, options?: RouteTablesListOptionalParams): PagedAsyncIterableIterator<RouteTable>;
    listAll(options?: RouteTablesListAllOptionalParams): PagedAsyncIterableIterator<RouteTable>;
    updateTags(resourceGroupName: string, routeTableName: string, parameters: TagsObject, options?: RouteTablesUpdateTagsOptionalParams): Promise<RouteTablesUpdateTagsResponse>;
}

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

// @public
export type RouteTablesCreateOrUpdateResponse = RouteTable;

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

// @public
export interface RouteTablesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type RouteTablesGetResponse = RouteTable;

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

// @public
export type RouteTablesListAllNextResponse = RouteTableListResult;

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

// @public
export type RouteTablesListAllResponse = RouteTableListResult;

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

// @public
export type RouteTablesListNextResponse = RouteTableListResult;

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

// @public
export type RouteTablesListResponse = RouteTableListResult;

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

// @public
export type RouteTablesUpdateTagsResponse = RouteTable;

// @public
export interface RoutingConfiguration {
    associatedRouteTable?: SubResource;
    inboundRouteMap?: SubResource;
    outboundRouteMap?: SubResource;
    propagatedRouteTables?: PropagatedRouteTable;
    vnetRoutes?: VnetRoute;
}

// @public
export interface RoutingIntent extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    routingPolicies?: RoutingPolicy[];
    readonly type?: string;
}

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

// @public
export type RoutingIntentCreateOrUpdateResponse = RoutingIntent;

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

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

// @public
export type RoutingIntentGetResponse = RoutingIntent;

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

// @public
export type RoutingIntentListNextResponse = ListRoutingIntentResult;

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

// @public
export type RoutingIntentListResponse = ListRoutingIntentResult;

// @public
export interface RoutingIntentOperations {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, routingIntentName: string, routingIntentParameters: RoutingIntent, options?: RoutingIntentCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RoutingIntentCreateOrUpdateResponse>, RoutingIntentCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, routingIntentName: string, routingIntentParameters: RoutingIntent, options?: RoutingIntentCreateOrUpdateOptionalParams): Promise<RoutingIntentCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, routingIntentName: string, options?: RoutingIntentDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, routingIntentName: string, options?: RoutingIntentDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, routingIntentName: string, options?: RoutingIntentGetOptionalParams): Promise<RoutingIntentGetResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: RoutingIntentListOptionalParams): PagedAsyncIterableIterator<RoutingIntent>;
}

// @public
export interface RoutingPolicy {
    destinations: string[];
    name: string;
    nextHop: string;
}

// @public
export interface RoutingRule extends ChildResource {
    description?: string;
    destination?: RoutingRuleRouteDestination;
    nextHop?: RoutingRuleNextHop;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface RoutingRuleCollection extends ChildResource {
    appliesTo?: NetworkManagerRoutingGroupItem[];
    description?: string;
    disableBgpRoutePropagation?: DisableBgpRoutePropagation;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface RoutingRuleCollectionListResult {
    nextLink?: string;
    value?: RoutingRuleCollection[];
}

// @public
export interface RoutingRuleCollections {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: RoutingRuleCollectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: RoutingRuleCollectionsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleCollection: RoutingRuleCollection, options?: RoutingRuleCollectionsCreateOrUpdateOptionalParams): Promise<RoutingRuleCollectionsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: RoutingRuleCollectionsGetOptionalParams): Promise<RoutingRuleCollectionsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: RoutingRuleCollectionsListOptionalParams): PagedAsyncIterableIterator<RoutingRuleCollection>;
}

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

// @public
export type RoutingRuleCollectionsCreateOrUpdateResponse = RoutingRuleCollection;

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

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

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

// @public
export type RoutingRuleCollectionsGetResponse = RoutingRuleCollection;

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

// @public
export type RoutingRuleCollectionsListNextResponse = RoutingRuleCollectionListResult;

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

// @public
export type RoutingRuleCollectionsListResponse = RoutingRuleCollectionListResult;

// @public
export type RoutingRuleDestinationType = string;

// @public
export interface RoutingRuleListResult {
    nextLink?: string;
    value?: RoutingRule[];
}

// @public
export interface RoutingRuleNextHop {
    nextHopAddress?: string;
    nextHopType: RoutingRuleNextHopType;
}

// @public
export type RoutingRuleNextHopType = string;

// @public
export interface RoutingRuleRouteDestination {
    destinationAddress: string;
    type: RoutingRuleDestinationType;
}

// @public
export interface RoutingRules {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: RoutingRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: RoutingRulesDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, routingRule: RoutingRule, options?: RoutingRulesCreateOrUpdateOptionalParams): Promise<RoutingRulesCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: RoutingRulesGetOptionalParams): Promise<RoutingRulesGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: RoutingRulesListOptionalParams): PagedAsyncIterableIterator<RoutingRule>;
}

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

// @public
export type RoutingRulesCreateOrUpdateResponse = RoutingRule;

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

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

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

// @public
export type RoutingRulesGetResponse = RoutingRule;

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

// @public
export type RoutingRulesListNextResponse = RoutingRuleListResult;

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

// @public
export type RoutingRulesListResponse = RoutingRuleListResult;

// @public
export type RoutingState = string;

// @public
export interface ScopeConnection extends ChildResource {
    readonly connectionState?: ScopeConnectionState;
    description?: string;
    resourceId?: string;
    readonly systemData?: SystemData;
    tenantId?: string;
}

// @public
export interface ScopeConnectionListResult {
    nextLink?: string;
    value?: ScopeConnection[];
}

// @public
export interface ScopeConnections {
    createOrUpdate(resourceGroupName: string, networkManagerName: string, scopeConnectionName: string, parameters: ScopeConnection, options?: ScopeConnectionsCreateOrUpdateOptionalParams): Promise<ScopeConnectionsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, networkManagerName: string, scopeConnectionName: string, options?: ScopeConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkManagerName: string, scopeConnectionName: string, options?: ScopeConnectionsGetOptionalParams): Promise<ScopeConnectionsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: ScopeConnectionsListOptionalParams): PagedAsyncIterableIterator<ScopeConnection>;
}

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

// @public
export type ScopeConnectionsCreateOrUpdateResponse = ScopeConnection;

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

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

// @public
export type ScopeConnectionsGetResponse = ScopeConnection;

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

// @public
export type ScopeConnectionsListNextResponse = ScopeConnectionListResult;

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

// @public
export type ScopeConnectionsListResponse = ScopeConnectionListResult;

// @public
export type ScopeConnectionState = string;

// @public
export type ScrubbingRuleEntryMatchOperator = string;

// @public
export type ScrubbingRuleEntryMatchVariable = string;

// @public
export type ScrubbingRuleEntryState = string;

// @public
export interface SecurityAdminConfiguration extends ChildResource {
    applyOnNetworkIntentPolicyBasedServices?: NetworkIntentPolicyBasedService[];
    description?: string;
    networkGroupAddressSpaceAggregationOption?: AddressSpaceAggregationOption;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface SecurityAdminConfigurationListResult {
    nextLink?: string;
    value?: SecurityAdminConfiguration[];
}

// @public
export interface SecurityAdminConfigurations {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityAdminConfigurationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityAdminConfigurationsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, securityAdminConfiguration: SecurityAdminConfiguration, options?: SecurityAdminConfigurationsCreateOrUpdateOptionalParams): Promise<SecurityAdminConfigurationsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityAdminConfigurationsGetOptionalParams): Promise<SecurityAdminConfigurationsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: SecurityAdminConfigurationsListOptionalParams): PagedAsyncIterableIterator<SecurityAdminConfiguration>;
}

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

// @public
export type SecurityAdminConfigurationsCreateOrUpdateResponse = SecurityAdminConfiguration;

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

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

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

// @public
export type SecurityAdminConfigurationsGetResponse = SecurityAdminConfiguration;

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

// @public
export type SecurityAdminConfigurationsListNextResponse = SecurityAdminConfigurationListResult;

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

// @public
export type SecurityAdminConfigurationsListResponse = SecurityAdminConfigurationListResult;

// @public
export type SecurityConfigurationRuleAccess = string;

// @public
export type SecurityConfigurationRuleDirection = string;

// @public
export type SecurityConfigurationRuleProtocol = string;

// @public
export interface SecurityGroupNetworkInterface {
    id?: string;
    securityRuleAssociations?: SecurityRuleAssociations;
}

// @public
export interface SecurityGroupViewParameters {
    targetResourceId: string;
}

// @public
export interface SecurityGroupViewResult {
    networkInterfaces?: SecurityGroupNetworkInterface[];
}

// @public
export interface SecurityPartnerProvider extends Resource {
    readonly connectionStatus?: SecurityPartnerProviderConnectionStatus;
    readonly etag?: string;
    readonly provisioningState?: ProvisioningState;
    securityProviderName?: SecurityProviderName;
    virtualHub?: SubResource;
}

// @public
export type SecurityPartnerProviderConnectionStatus = string;

// @public
export interface SecurityPartnerProviderListResult {
    nextLink?: string;
    value?: SecurityPartnerProvider[];
}

// @public
export interface SecurityPartnerProviders {
    beginCreateOrUpdate(resourceGroupName: string, securityPartnerProviderName: string, parameters: SecurityPartnerProvider, options?: SecurityPartnerProvidersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<SecurityPartnerProvidersCreateOrUpdateResponse>, SecurityPartnerProvidersCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, securityPartnerProviderName: string, parameters: SecurityPartnerProvider, options?: SecurityPartnerProvidersCreateOrUpdateOptionalParams): Promise<SecurityPartnerProvidersCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, securityPartnerProviderName: string, options?: SecurityPartnerProvidersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, securityPartnerProviderName: string, options?: SecurityPartnerProvidersDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, securityPartnerProviderName: string, options?: SecurityPartnerProvidersGetOptionalParams): Promise<SecurityPartnerProvidersGetResponse>;
    list(options?: SecurityPartnerProvidersListOptionalParams): PagedAsyncIterableIterator<SecurityPartnerProvider>;
    listByResourceGroup(resourceGroupName: string, options?: SecurityPartnerProvidersListByResourceGroupOptionalParams): PagedAsyncIterableIterator<SecurityPartnerProvider>;
    updateTags(resourceGroupName: string, securityPartnerProviderName: string, parameters: TagsObject, options?: SecurityPartnerProvidersUpdateTagsOptionalParams): Promise<SecurityPartnerProvidersUpdateTagsResponse>;
}

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

// @public
export type SecurityPartnerProvidersCreateOrUpdateResponse = SecurityPartnerProvider;

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

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

// @public
export type SecurityPartnerProvidersGetResponse = SecurityPartnerProvider;

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

// @public
export type SecurityPartnerProvidersListByResourceGroupNextResponse = SecurityPartnerProviderListResult;

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

// @public
export type SecurityPartnerProvidersListByResourceGroupResponse = SecurityPartnerProviderListResult;

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

// @public
export type SecurityPartnerProvidersListNextResponse = SecurityPartnerProviderListResult;

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

// @public
export type SecurityPartnerProvidersListResponse = SecurityPartnerProviderListResult;

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

// @public
export type SecurityPartnerProvidersUpdateTagsResponse = SecurityPartnerProvider;

// @public
export interface SecurityPerimeterProxyResource extends SecurityPerimeterResource {
}

// @public
export interface SecurityPerimeterResource {
    readonly id?: string;
    readonly name?: string;
    readonly systemData?: SecurityPerimeterSystemData;
    readonly type?: string;
}

// @public
export interface SecurityPerimeterSystemData {
    createdAt?: Date;
    createdBy?: string;
    createdByType?: CreatedByType;
    lastModifiedAt?: Date;
    lastModifiedBy?: string;
    lastModifiedByType?: CreatedByType;
}

// @public
export type SecurityProviderName = string;

// @public
export interface SecurityRule extends SubResource {
    access?: SecurityRuleAccess;
    description?: string;
    destinationAddressPrefix?: string;
    destinationAddressPrefixes?: string[];
    destinationApplicationSecurityGroups?: ApplicationSecurityGroup[];
    destinationPortRange?: string;
    destinationPortRanges?: string[];
    direction?: SecurityRuleDirection;
    readonly etag?: string;
    name?: string;
    priority?: number;
    protocol?: SecurityRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    sourceAddressPrefix?: string;
    sourceAddressPrefixes?: string[];
    sourceApplicationSecurityGroups?: ApplicationSecurityGroup[];
    sourcePortRange?: string;
    sourcePortRanges?: string[];
    type?: string;
}

// @public
export type SecurityRuleAccess = string;

// @public
export interface SecurityRuleAssociations {
    defaultSecurityRules?: SecurityRule[];
    effectiveSecurityRules?: EffectiveNetworkSecurityRule[];
    networkInterfaceAssociation?: NetworkInterfaceAssociation;
    subnetAssociation?: SubnetAssociation;
}

// @public
export type SecurityRuleDirection = string;

// @public
export interface SecurityRuleListResult {
    nextLink?: string;
    value?: SecurityRule[];
}

// @public
export type SecurityRuleProtocol = string;

// @public
export interface SecurityRules {
    beginCreateOrUpdate(resourceGroupName: string, networkSecurityGroupName: string, securityRuleName: string, securityRuleParameters: SecurityRule, options?: SecurityRulesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<SecurityRulesCreateOrUpdateResponse>, SecurityRulesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkSecurityGroupName: string, securityRuleName: string, securityRuleParameters: SecurityRule, options?: SecurityRulesCreateOrUpdateOptionalParams): Promise<SecurityRulesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkSecurityGroupName: string, securityRuleName: string, options?: SecurityRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkSecurityGroupName: string, securityRuleName: string, options?: SecurityRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkSecurityGroupName: string, securityRuleName: string, options?: SecurityRulesGetOptionalParams): Promise<SecurityRulesGetResponse>;
    list(resourceGroupName: string, networkSecurityGroupName: string, options?: SecurityRulesListOptionalParams): PagedAsyncIterableIterator<SecurityRule>;
}

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

// @public
export type SecurityRulesCreateOrUpdateResponse = SecurityRule;

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

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

// @public
export type SecurityRulesGetResponse = SecurityRule;

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

// @public
export type SecurityRulesListNextResponse = SecurityRuleListResult;

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

// @public
export type SecurityRulesListResponse = SecurityRuleListResult;

// @public
export interface SecurityUserConfiguration extends ChildResource {
    description?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface SecurityUserConfigurationListResult {
    nextLink?: string;
    value?: SecurityUserConfiguration[];
}

// @public
export interface SecurityUserConfigurations {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityUserConfigurationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityUserConfigurationsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, securityUserConfiguration: SecurityUserConfiguration, options?: SecurityUserConfigurationsCreateOrUpdateOptionalParams): Promise<SecurityUserConfigurationsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityUserConfigurationsGetOptionalParams): Promise<SecurityUserConfigurationsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: SecurityUserConfigurationsListOptionalParams): PagedAsyncIterableIterator<SecurityUserConfiguration>;
}

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

// @public
export type SecurityUserConfigurationsCreateOrUpdateResponse = SecurityUserConfiguration;

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

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

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

// @public
export type SecurityUserConfigurationsGetResponse = SecurityUserConfiguration;

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

// @public
export type SecurityUserConfigurationsListNextResponse = SecurityUserConfigurationListResult;

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

// @public
export type SecurityUserConfigurationsListResponse = SecurityUserConfigurationListResult;

// @public
export interface SecurityUserGroupItem {
    networkGroupId: string;
}

// @public
export interface SecurityUserRule extends ChildResource {
    description?: string;
    destinationPortRanges?: string[];
    destinations?: AddressPrefixItem[];
    direction?: SecurityConfigurationRuleDirection;
    protocol?: SecurityConfigurationRuleProtocol;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    sourcePortRanges?: string[];
    sources?: AddressPrefixItem[];
    readonly systemData?: SystemData;
}

// @public
export interface SecurityUserRuleCollection extends ChildResource {
    appliesToGroups?: SecurityUserGroupItem[];
    description?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    readonly systemData?: SystemData;
}

// @public
export interface SecurityUserRuleCollectionListResult {
    nextLink?: string;
    value?: SecurityUserRuleCollection[];
}

// @public
export interface SecurityUserRuleCollections {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: SecurityUserRuleCollectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: SecurityUserRuleCollectionsDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, securityUserRuleCollection: SecurityUserRuleCollection, options?: SecurityUserRuleCollectionsCreateOrUpdateOptionalParams): Promise<SecurityUserRuleCollectionsCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: SecurityUserRuleCollectionsGetOptionalParams): Promise<SecurityUserRuleCollectionsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, configurationName: string, options?: SecurityUserRuleCollectionsListOptionalParams): PagedAsyncIterableIterator<SecurityUserRuleCollection>;
}

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

// @public
export type SecurityUserRuleCollectionsCreateOrUpdateResponse = SecurityUserRuleCollection;

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

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

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

// @public
export type SecurityUserRuleCollectionsGetResponse = SecurityUserRuleCollection;

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

// @public
export type SecurityUserRuleCollectionsListNextResponse = SecurityUserRuleCollectionListResult;

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

// @public
export type SecurityUserRuleCollectionsListResponse = SecurityUserRuleCollectionListResult;

// @public
export interface SecurityUserRuleListResult {
    nextLink?: string;
    value?: SecurityUserRule[];
}

// @public
export interface SecurityUserRules {
    beginDelete(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: SecurityUserRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: SecurityUserRulesDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, securityUserRule: SecurityUserRule, options?: SecurityUserRulesCreateOrUpdateOptionalParams): Promise<SecurityUserRulesCreateOrUpdateResponse>;
    get(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, ruleName: string, options?: SecurityUserRulesGetOptionalParams): Promise<SecurityUserRulesGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, configurationName: string, ruleCollectionName: string, options?: SecurityUserRulesListOptionalParams): PagedAsyncIterableIterator<SecurityUserRule>;
}

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

// @public
export type SecurityUserRulesCreateOrUpdateResponse = SecurityUserRule;

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

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

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

// @public
export type SecurityUserRulesGetResponse = SecurityUserRule;

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

// @public
export type SecurityUserRulesListNextResponse = SecurityUserRuleListResult;

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

// @public
export type SecurityUserRulesListResponse = SecurityUserRuleListResult;

// @public
export type SensitivityType = string;

// @public
export interface ServiceAssociationLink extends SubResource {
    allowDelete?: boolean;
    readonly etag?: string;
    link?: string;
    linkedResourceType?: string;
    locations?: string[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface ServiceAssociationLinks {
    list(resourceGroupName: string, virtualNetworkName: string, subnetName: string, options?: ServiceAssociationLinksListOptionalParams): Promise<ServiceAssociationLinksListResponse>;
}

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

// @public
export type ServiceAssociationLinksListResponse = ServiceAssociationLinksListResult;

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

// @public
export interface ServiceEndpointPolicies {
    beginCreateOrUpdate(resourceGroupName: string, serviceEndpointPolicyName: string, parameters: ServiceEndpointPolicy, options?: ServiceEndpointPoliciesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ServiceEndpointPoliciesCreateOrUpdateResponse>, ServiceEndpointPoliciesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceEndpointPolicyName: string, parameters: ServiceEndpointPolicy, options?: ServiceEndpointPoliciesCreateOrUpdateOptionalParams): Promise<ServiceEndpointPoliciesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, serviceEndpointPolicyName: string, options?: ServiceEndpointPoliciesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, serviceEndpointPolicyName: string, options?: ServiceEndpointPoliciesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceEndpointPolicyName: string, options?: ServiceEndpointPoliciesGetOptionalParams): Promise<ServiceEndpointPoliciesGetResponse>;
    list(options?: ServiceEndpointPoliciesListOptionalParams): PagedAsyncIterableIterator<ServiceEndpointPolicy>;
    listByResourceGroup(resourceGroupName: string, options?: ServiceEndpointPoliciesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ServiceEndpointPolicy>;
    updateTags(resourceGroupName: string, serviceEndpointPolicyName: string, parameters: TagsObject, options?: ServiceEndpointPoliciesUpdateTagsOptionalParams): Promise<ServiceEndpointPoliciesUpdateTagsResponse>;
}

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

// @public
export type ServiceEndpointPoliciesCreateOrUpdateResponse = ServiceEndpointPolicy;

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

// @public
export interface ServiceEndpointPoliciesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type ServiceEndpointPoliciesGetResponse = ServiceEndpointPolicy;

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

// @public
export type ServiceEndpointPoliciesListByResourceGroupNextResponse = ServiceEndpointPolicyListResult;

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

// @public
export type ServiceEndpointPoliciesListByResourceGroupResponse = ServiceEndpointPolicyListResult;

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

// @public
export type ServiceEndpointPoliciesListNextResponse = ServiceEndpointPolicyListResult;

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

// @public
export type ServiceEndpointPoliciesListResponse = ServiceEndpointPolicyListResult;

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

// @public
export type ServiceEndpointPoliciesUpdateTagsResponse = ServiceEndpointPolicy;

// @public
export interface ServiceEndpointPolicy extends Resource {
    contextualServiceEndpointPolicies?: string[];
    readonly etag?: string;
    readonly kind?: string;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    serviceAlias?: string;
    serviceEndpointPolicyDefinitions?: ServiceEndpointPolicyDefinition[];
    readonly subnets?: Subnet[];
}

// @public
export interface ServiceEndpointPolicyDefinition extends SubResource {
    description?: string;
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    service?: string;
    serviceResources?: string[];
    type?: string;
}

// @public
export interface ServiceEndpointPolicyDefinitionListResult {
    nextLink?: string;
    value?: ServiceEndpointPolicyDefinition[];
}

// @public
export interface ServiceEndpointPolicyDefinitions {
    beginCreateOrUpdate(resourceGroupName: string, serviceEndpointPolicyName: string, serviceEndpointPolicyDefinitionName: string, serviceEndpointPolicyDefinitions: ServiceEndpointPolicyDefinition, options?: ServiceEndpointPolicyDefinitionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ServiceEndpointPolicyDefinitionsCreateOrUpdateResponse>, ServiceEndpointPolicyDefinitionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceEndpointPolicyName: string, serviceEndpointPolicyDefinitionName: string, serviceEndpointPolicyDefinitions: ServiceEndpointPolicyDefinition, options?: ServiceEndpointPolicyDefinitionsCreateOrUpdateOptionalParams): Promise<ServiceEndpointPolicyDefinitionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, serviceEndpointPolicyName: string, serviceEndpointPolicyDefinitionName: string, options?: ServiceEndpointPolicyDefinitionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, serviceEndpointPolicyName: string, serviceEndpointPolicyDefinitionName: string, options?: ServiceEndpointPolicyDefinitionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceEndpointPolicyName: string, serviceEndpointPolicyDefinitionName: string, options?: ServiceEndpointPolicyDefinitionsGetOptionalParams): Promise<ServiceEndpointPolicyDefinitionsGetResponse>;
    listByResourceGroup(resourceGroupName: string, serviceEndpointPolicyName: string, options?: ServiceEndpointPolicyDefinitionsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ServiceEndpointPolicyDefinition>;
}

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

// @public
export type ServiceEndpointPolicyDefinitionsCreateOrUpdateResponse = ServiceEndpointPolicyDefinition;

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

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

// @public
export type ServiceEndpointPolicyDefinitionsGetResponse = ServiceEndpointPolicyDefinition;

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

// @public
export type ServiceEndpointPolicyDefinitionsListByResourceGroupNextResponse = ServiceEndpointPolicyDefinitionListResult;

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

// @public
export type ServiceEndpointPolicyDefinitionsListByResourceGroupResponse = ServiceEndpointPolicyDefinitionListResult;

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

// @public
export interface ServiceEndpointPropertiesFormat {
    locations?: string[];
    networkIdentifier?: SubResource;
    readonly provisioningState?: ProvisioningState;
    service?: string;
}

// @public
export type ServiceProviderProvisioningState = string;

// @public
export interface ServiceTagInformation {
    readonly id?: string;
    readonly name?: string;
    readonly properties?: ServiceTagInformationPropertiesFormat;
    readonly serviceTagChangeNumber?: string;
}

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

// @public
export type ServiceTagInformationListNextResponse = ServiceTagInformationListResult;

// @public
export interface ServiceTagInformationListOptionalParams extends coreClient.OperationOptions {
    noAddressPrefixes?: boolean;
    tagName?: string;
}

// @public
export type ServiceTagInformationListResponse = ServiceTagInformationListResult;

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

// @public
export interface ServiceTagInformationOperations {
    list(location: string, options?: ServiceTagInformationListOptionalParams): PagedAsyncIterableIterator<ServiceTagInformation>;
}

// @public
export interface ServiceTagInformationPropertiesFormat {
    readonly addressPrefixes?: string[];
    readonly changeNumber?: string;
    readonly region?: string;
    readonly state?: string;
    readonly systemService?: string;
}

// @public
export interface ServiceTags {
    list(location: string, options?: ServiceTagsListOptionalParams): Promise<ServiceTagsListResponse>;
}

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

// @public
export type ServiceTagsListResponse = ServiceTagsListResult;

// @public
export interface ServiceTagsListResult {
    readonly changeNumber?: string;
    readonly cloud?: string;
    readonly id?: string;
    readonly name?: string;
    readonly nextLink?: string;
    readonly type?: string;
    readonly values?: ServiceTagInformation[];
}

// @public
export interface SessionIds {
    sessionIds?: string[];
}

// @public
export type Severity = string;

// @public
export interface SharedKeyProperties {
    readonly provisioningState?: ProvisioningState;
    sharedKey?: string;
    sharedKeyLength?: number;
}

// @public
export type SharingScope = string;

// @public
export interface SignatureOverridesFilterValuesQuery {
    filterName?: string;
}

// @public
export interface SignatureOverridesFilterValuesResponse {
    filterValues?: string[];
}

// @public
export interface SignaturesOverrides {
    id?: string;
    name?: string;
    properties?: SignaturesOverridesProperties;
    type?: string;
}

// @public
export interface SignaturesOverridesList {
    value?: SignaturesOverrides[];
}

// @public
export interface SignaturesOverridesProperties {
    signatures?: {
        [propertyName: string]: string;
    };
}

// @public (undocumented)
export interface SingleQueryResult {
    description?: string;
    destinationPorts?: string[];
    direction?: FirewallPolicyIdpsSignatureDirection;
    group?: string;
    inheritedFromParentPolicy?: boolean;
    lastUpdated?: string;
    mode?: FirewallPolicyIdpsSignatureMode;
    protocol?: string;
    severity?: FirewallPolicyIdpsSignatureSeverity;
    signatureId?: number;
    sourcePorts?: string[];
}

// @public
export interface Sku {
    name?: BastionHostSkuName;
}

// @public
export type SlotType = "Production" | "Staging";

// @public
export interface StaticCidr extends CommonProxyResource {
    properties?: StaticCidrProperties;
}

// @public
export interface StaticCidrList {
    nextLink?: string;
    // (undocumented)
    value?: StaticCidr[];
}

// @public
export interface StaticCidrProperties {
    addressPrefixes?: string[];
    // (undocumented)
    description?: string;
    numberOfIPAddressesToAllocate?: string;
    provisioningState?: ProvisioningState;
    readonly totalNumberOfIPAddresses?: string;
}

// @public
export interface StaticCidrs {
    beginDelete(resourceGroupName: string, networkManagerName: string, poolName: string, staticCidrName: string, options?: StaticCidrsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<StaticCidrsDeleteResponse>, StaticCidrsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, poolName: string, staticCidrName: string, options?: StaticCidrsDeleteOptionalParams): Promise<StaticCidrsDeleteResponse>;
    create(resourceGroupName: string, networkManagerName: string, poolName: string, staticCidrName: string, options?: StaticCidrsCreateOptionalParams): Promise<StaticCidrsCreateResponse>;
    get(resourceGroupName: string, networkManagerName: string, poolName: string, staticCidrName: string, options?: StaticCidrsGetOptionalParams): Promise<StaticCidrsGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, poolName: string, options?: StaticCidrsListOptionalParams): PagedAsyncIterableIterator<StaticCidr>;
}

// @public
export interface StaticCidrsCreateOptionalParams extends coreClient.OperationOptions {
    body?: StaticCidr;
}

// @public
export type StaticCidrsCreateResponse = StaticCidr;

// @public
export interface StaticCidrsDeleteHeaders {
    // (undocumented)
    location?: string;
}

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

// @public
export type StaticCidrsDeleteResponse = StaticCidrsDeleteHeaders;

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

// @public
export type StaticCidrsGetResponse = StaticCidr;

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

// @public
export type StaticCidrsListNextResponse = StaticCidrList;

// @public
export interface StaticCidrsListOptionalParams extends coreClient.OperationOptions {
    skip?: number;
    skipToken?: string;
    sortKey?: string;
    sortValue?: string;
    top?: number;
}

// @public
export type StaticCidrsListResponse = StaticCidrList;

// @public
export interface StaticMember extends ChildResource {
    readonly provisioningState?: ProvisioningState;
    readonly region?: string;
    resourceId?: string;
    readonly systemData?: SystemData;
}

// @public
export interface StaticMemberListResult {
    nextLink?: string;
    value?: StaticMember[];
}

// @public
export interface StaticMembers {
    createOrUpdate(resourceGroupName: string, networkManagerName: string, networkGroupName: string, staticMemberName: string, parameters: StaticMember, options?: StaticMembersCreateOrUpdateOptionalParams): Promise<StaticMembersCreateOrUpdateResponse>;
    delete(resourceGroupName: string, networkManagerName: string, networkGroupName: string, staticMemberName: string, options?: StaticMembersDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkManagerName: string, networkGroupName: string, staticMemberName: string, options?: StaticMembersGetOptionalParams): Promise<StaticMembersGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, networkGroupName: string, options?: StaticMembersListOptionalParams): PagedAsyncIterableIterator<StaticMember>;
}

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

// @public
export type StaticMembersCreateOrUpdateResponse = StaticMember;

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

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

// @public
export type StaticMembersGetResponse = StaticMember;

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

// @public
export type StaticMembersListNextResponse = StaticMemberListResult;

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

// @public
export type StaticMembersListResponse = StaticMemberListResult;

// @public
export interface StaticRoute {
    addressPrefixes?: string[];
    name?: string;
    nextHopIpAddress?: string;
}

// @public
export interface StaticRoutesConfig {
    readonly propagateStaticRoutes?: boolean;
    vnetLocalRouteOverrideCriteria?: VnetLocalRouteOverrideCriteria;
}

// @public
export interface Subnet extends SubResource {
    addressPrefix?: string;
    addressPrefixes?: string[];
    applicationGatewayIPConfigurations?: ApplicationGatewayIPConfiguration[];
    defaultOutboundAccess?: boolean;
    delegations?: Delegation[];
    readonly etag?: string;
    ipAllocations?: SubResource[];
    ipamPoolPrefixAllocations?: IpamPoolPrefixAllocation[];
    readonly ipConfigurationProfiles?: IPConfigurationProfile[];
    readonly ipConfigurations?: IPConfiguration[];
    name?: string;
    natGateway?: SubResource;
    networkSecurityGroup?: NetworkSecurityGroup;
    privateEndpointNetworkPolicies?: VirtualNetworkPrivateEndpointNetworkPolicies;
    readonly privateEndpoints?: PrivateEndpoint[];
    privateLinkServiceNetworkPolicies?: VirtualNetworkPrivateLinkServiceNetworkPolicies;
    readonly provisioningState?: ProvisioningState;
    readonly purpose?: string;
    readonly resourceNavigationLinks?: ResourceNavigationLink[];
    routeTable?: RouteTable;
    readonly serviceAssociationLinks?: ServiceAssociationLink[];
    serviceEndpointPolicies?: ServiceEndpointPolicy[];
    serviceEndpoints?: ServiceEndpointPropertiesFormat[];
    sharingScope?: SharingScope;
    type?: string;
}

// @public
export interface SubnetAssociation {
    readonly id?: string;
    securityRules?: SecurityRule[];
}

// @public
export interface SubnetListResult {
    nextLink?: string;
    value?: Subnet[];
}

// @public
export interface Subnets {
    beginCreateOrUpdate(resourceGroupName: string, virtualNetworkName: string, subnetName: string, subnetParameters: Subnet, options?: SubnetsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<SubnetsCreateOrUpdateResponse>, SubnetsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualNetworkName: string, subnetName: string, subnetParameters: Subnet, options?: SubnetsCreateOrUpdateOptionalParams): Promise<SubnetsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualNetworkName: string, subnetName: string, options?: SubnetsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualNetworkName: string, subnetName: string, options?: SubnetsDeleteOptionalParams): Promise<void>;
    beginPrepareNetworkPolicies(resourceGroupName: string, virtualNetworkName: string, subnetName: string, prepareNetworkPoliciesRequestParameters: PrepareNetworkPoliciesRequest, options?: SubnetsPrepareNetworkPoliciesOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginPrepareNetworkPoliciesAndWait(resourceGroupName: string, virtualNetworkName: string, subnetName: string, prepareNetworkPoliciesRequestParameters: PrepareNetworkPoliciesRequest, options?: SubnetsPrepareNetworkPoliciesOptionalParams): Promise<void>;
    beginUnprepareNetworkPolicies(resourceGroupName: string, virtualNetworkName: string, subnetName: string, unprepareNetworkPoliciesRequestParameters: UnprepareNetworkPoliciesRequest, options?: SubnetsUnprepareNetworkPoliciesOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginUnprepareNetworkPoliciesAndWait(resourceGroupName: string, virtualNetworkName: string, subnetName: string, unprepareNetworkPoliciesRequestParameters: UnprepareNetworkPoliciesRequest, options?: SubnetsUnprepareNetworkPoliciesOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualNetworkName: string, subnetName: string, options?: SubnetsGetOptionalParams): Promise<SubnetsGetResponse>;
    list(resourceGroupName: string, virtualNetworkName: string, options?: SubnetsListOptionalParams): PagedAsyncIterableIterator<Subnet>;
}

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

// @public
export type SubnetsCreateOrUpdateResponse = Subnet;

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

// @public
export interface SubnetsGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type SubnetsGetResponse = Subnet;

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

// @public
export type SubnetsListNextResponse = SubnetListResult;

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

// @public
export type SubnetsListResponse = SubnetListResult;

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

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

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

// @public (undocumented)
export interface SubscriptionId {
    id?: string;
}

// @public
export interface SubscriptionNetworkManagerConnections {
    createOrUpdate(networkManagerConnectionName: string, parameters: NetworkManagerConnection, options?: SubscriptionNetworkManagerConnectionsCreateOrUpdateOptionalParams): Promise<SubscriptionNetworkManagerConnectionsCreateOrUpdateResponse>;
    delete(networkManagerConnectionName: string, options?: SubscriptionNetworkManagerConnectionsDeleteOptionalParams): Promise<void>;
    get(networkManagerConnectionName: string, options?: SubscriptionNetworkManagerConnectionsGetOptionalParams): Promise<SubscriptionNetworkManagerConnectionsGetResponse>;
    list(options?: SubscriptionNetworkManagerConnectionsListOptionalParams): PagedAsyncIterableIterator<NetworkManagerConnection>;
}

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

// @public
export type SubscriptionNetworkManagerConnectionsCreateOrUpdateResponse = NetworkManagerConnection;

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

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

// @public
export type SubscriptionNetworkManagerConnectionsGetResponse = NetworkManagerConnection;

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

// @public
export type SubscriptionNetworkManagerConnectionsListNextResponse = NetworkManagerConnectionListResult;

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

// @public
export type SubscriptionNetworkManagerConnectionsListResponse = NetworkManagerConnectionListResult;

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

// @public
export type SupportedSecurityProvidersResponse = VirtualWanSecurityProviders;

// @public
export interface SwapResource {
    readonly id?: string;
    readonly name?: string;
    properties?: SwapResourceProperties;
    readonly type?: string;
}

// @public
export interface SwapResourceListResult {
    // (undocumented)
    value?: SwapResource[];
}

// @public
export interface SwapResourceProperties {
    slotType?: SlotType;
}

// @public
export type SyncMode = string;

// @public
export type SyncRemoteAddressSpace = string;

// @public
export interface SystemData {
    createdAt?: Date;
    createdBy?: string;
    createdByType?: CreatedByType;
    lastModifiedAt?: Date;
    lastModifiedBy?: string;
    lastModifiedByType?: CreatedByType;
}

// @public
export interface TagsObject {
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface Topology {
    readonly createdDateTime?: Date;
    readonly id?: string;
    readonly lastModified?: Date;
    resources?: TopologyResource[];
}

// @public
export interface TopologyAssociation {
    associationType?: AssociationType;
    name?: string;
    resourceId?: string;
}

// @public
export interface TopologyParameters {
    targetResourceGroupName?: string;
    targetSubnet?: SubResource;
    targetVirtualNetwork?: SubResource;
}

// @public
export interface TopologyResource {
    associations?: TopologyAssociation[];
    id?: string;
    location?: string;
    name?: string;
}

// @public
export interface TrackedResource extends SecurityPerimeterResource {
    location: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface TrafficAnalyticsConfigurationProperties {
    enabled?: boolean;
    trafficAnalyticsInterval?: number;
    workspaceId?: string;
    workspaceRegion?: string;
    workspaceResourceId?: string;
}

// @public
export interface TrafficAnalyticsProperties {
    networkWatcherFlowAnalyticsConfiguration?: TrafficAnalyticsConfigurationProperties;
}

// @public
export interface TrafficSelectorPolicy {
    localAddressRanges: string[];
    remoteAddressRanges: string[];
}

// @public
export type TransportProtocol = string;

// @public
export interface TroubleshootingDetails {
    detail?: string;
    id?: string;
    reasonType?: string;
    recommendedActions?: TroubleshootingRecommendedActions[];
    summary?: string;
}

// @public
export interface TroubleshootingParameters {
    storageId: string;
    storagePath: string;
    targetResourceId: string;
}

// @public
export interface TroubleshootingRecommendedActions {
    actionId?: string;
    actionText?: string;
    actionUri?: string;
    actionUriText?: string;
}

// @public
export interface TroubleshootingResult {
    code?: string;
    endTime?: Date;
    results?: TroubleshootingDetails[];
    startTime?: Date;
}

// @public
export interface TunnelConnectionHealth {
    readonly connectionStatus?: VirtualNetworkGatewayConnectionStatus;
    readonly egressBytesTransferred?: number;
    readonly ingressBytesTransferred?: number;
    readonly lastConnectionEstablishedUtcTime?: string;
    readonly tunnel?: string;
}

// @public
export type TunnelConnectionStatus = string;

// @public
export interface UnprepareNetworkPoliciesRequest {
    serviceName?: string;
}

// @public
export interface UpdateTagsRequest {
    readonly id?: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface Usage {
    currentValue: number;
    readonly id?: string;
    limit: number;
    name: UsageName;
    unit: UsageUnit;
}

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

// @public
export interface Usages {
    list(location: string, options?: UsagesListOptionalParams): PagedAsyncIterableIterator<Usage>;
}

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

// @public
export type UsagesListNextResponse = UsagesListResult;

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

// @public
export type UsagesListResponse = UsagesListResult;

// @public
export interface UsagesListResult {
    nextLink?: string;
    value?: Usage[];
}

// @public
export type UsageUnit = string;

// @public
export type UseHubGateway = string;

// @public
export type VerbosityLevel = string;

// @public
export interface VerificationIPFlowParameters {
    direction: Direction;
    localIPAddress: string;
    localPort: string;
    protocol: IpFlowProtocol;
    remoteIPAddress: string;
    remotePort: string;
    targetNicResourceId?: string;
    targetResourceId: string;
}

// @public
export interface VerificationIPFlowResult {
    access?: Access;
    ruleName?: string;
}

// @public
export interface VerifierWorkspace extends CommonTrackedResource {
    readonly etag?: string;
    properties?: VerifierWorkspaceProperties;
}

// @public
export interface VerifierWorkspaceListResult {
    nextLink?: string;
    value?: VerifierWorkspace[];
}

// @public
export interface VerifierWorkspaceProperties {
    // (undocumented)
    description?: string;
    provisioningState?: ProvisioningState;
}

// @public
export interface VerifierWorkspaces {
    beginDelete(resourceGroupName: string, networkManagerName: string, workspaceName: string, options?: VerifierWorkspacesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<VerifierWorkspacesDeleteResponse>, VerifierWorkspacesDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, networkManagerName: string, workspaceName: string, options?: VerifierWorkspacesDeleteOptionalParams): Promise<VerifierWorkspacesDeleteResponse>;
    create(resourceGroupName: string, networkManagerName: string, workspaceName: string, body: VerifierWorkspace, options?: VerifierWorkspacesCreateOptionalParams): Promise<VerifierWorkspacesCreateResponse>;
    get(resourceGroupName: string, networkManagerName: string, workspaceName: string, options?: VerifierWorkspacesGetOptionalParams): Promise<VerifierWorkspacesGetResponse>;
    list(resourceGroupName: string, networkManagerName: string, options?: VerifierWorkspacesListOptionalParams): PagedAsyncIterableIterator<VerifierWorkspace>;
    update(resourceGroupName: string, networkManagerName: string, workspaceName: string, options?: VerifierWorkspacesUpdateOptionalParams): Promise<VerifierWorkspacesUpdateResponse>;
}

// @public
export interface VerifierWorkspacesCreateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type VerifierWorkspacesCreateResponse = VerifierWorkspace;

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

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

// @public
export type VerifierWorkspacesDeleteResponse = VerifierWorkspacesDeleteHeaders;

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

// @public
export type VerifierWorkspacesGetResponse = VerifierWorkspace;

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

// @public
export type VerifierWorkspacesListNextResponse = VerifierWorkspaceListResult;

// @public
export interface VerifierWorkspacesListOptionalParams extends coreClient.OperationOptions {
    skip?: number;
    skipToken?: string;
    sortKey?: string;
    sortValue?: string;
    top?: number;
}

// @public
export type VerifierWorkspacesListResponse = VerifierWorkspaceListResult;

// @public
export interface VerifierWorkspacesUpdateOptionalParams extends coreClient.OperationOptions {
    body?: VerifierWorkspaceUpdate;
    ifMatch?: string;
}

// @public
export type VerifierWorkspacesUpdateResponse = VerifierWorkspace;

// @public
export interface VerifierWorkspaceUpdate {
    properties?: VerifierWorkspaceUpdateProperties;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface VerifierWorkspaceUpdateProperties {
    // (undocumented)
    description?: string;
}

// @public
export interface VipSwap {
    beginCreate(groupName: string, resourceName: string, parameters: SwapResource, options?: VipSwapCreateOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginCreateAndWait(groupName: string, resourceName: string, parameters: SwapResource, options?: VipSwapCreateOptionalParams): Promise<void>;
    get(groupName: string, resourceName: string, options?: VipSwapGetOptionalParams): Promise<VipSwapGetResponse>;
    list(groupName: string, resourceName: string, options?: VipSwapListOptionalParams): Promise<VipSwapListResponse>;
}

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

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

// @public
export type VipSwapGetResponse = SwapResource;

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

// @public
export type VipSwapListResponse = SwapResourceListResult;

// @public
export interface VirtualApplianceAdditionalNicProperties {
    hasPublicIp?: boolean;
    name?: string;
}

// @public
export interface VirtualApplianceIPConfiguration {
    name?: string;
    properties?: VirtualApplianceIPConfigurationProperties;
}

// @public
export interface VirtualApplianceIPConfigurationProperties {
    primary?: boolean;
}

// @public
export interface VirtualApplianceNetworkInterfaceConfiguration {
    nicType?: NicTypeInRequest;
    properties?: VirtualApplianceNetworkInterfaceConfigurationProperties;
}

// @public
export interface VirtualApplianceNetworkInterfaceConfigurationProperties {
    // (undocumented)
    ipConfigurations?: VirtualApplianceIPConfiguration[];
}

// @public
export interface VirtualApplianceNicProperties {
    readonly instanceName?: string;
    readonly name?: string;
    readonly nicType?: NicTypeInResponse;
    readonly privateIpAddress?: string;
    readonly publicIpAddress?: string;
}

// @public
export interface VirtualApplianceSite extends SubResource {
    addressPrefix?: string;
    readonly etag?: string;
    name?: string;
    o365Policy?: Office365PolicyProperties;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface VirtualApplianceSites {
    beginCreateOrUpdate(resourceGroupName: string, networkVirtualApplianceName: string, siteName: string, parameters: VirtualApplianceSite, options?: VirtualApplianceSitesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualApplianceSitesCreateOrUpdateResponse>, VirtualApplianceSitesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkVirtualApplianceName: string, siteName: string, parameters: VirtualApplianceSite, options?: VirtualApplianceSitesCreateOrUpdateOptionalParams): Promise<VirtualApplianceSitesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkVirtualApplianceName: string, siteName: string, options?: VirtualApplianceSitesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, networkVirtualApplianceName: string, siteName: string, options?: VirtualApplianceSitesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, networkVirtualApplianceName: string, siteName: string, options?: VirtualApplianceSitesGetOptionalParams): Promise<VirtualApplianceSitesGetResponse>;
    list(resourceGroupName: string, networkVirtualApplianceName: string, options?: VirtualApplianceSitesListOptionalParams): PagedAsyncIterableIterator<VirtualApplianceSite>;
}

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

// @public
export type VirtualApplianceSitesCreateOrUpdateResponse = VirtualApplianceSite;

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

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

// @public
export type VirtualApplianceSitesGetResponse = VirtualApplianceSite;

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

// @public
export type VirtualApplianceSitesListNextResponse = NetworkVirtualApplianceSiteListResult;

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

// @public
export type VirtualApplianceSitesListResponse = NetworkVirtualApplianceSiteListResult;

// @public
export interface VirtualApplianceSkuProperties {
    bundledScaleUnit?: string;
    marketPlaceVersion?: string;
    vendor?: string;
}

// @public
export interface VirtualApplianceSkus {
    get(skuName: string, options?: VirtualApplianceSkusGetOptionalParams): Promise<VirtualApplianceSkusGetResponse>;
    list(options?: VirtualApplianceSkusListOptionalParams): PagedAsyncIterableIterator<NetworkVirtualApplianceSku>;
}

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

// @public
export type VirtualApplianceSkusGetResponse = NetworkVirtualApplianceSku;

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

// @public
export type VirtualApplianceSkusListNextResponse = NetworkVirtualApplianceSkuListResult;

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

// @public
export type VirtualApplianceSkusListResponse = NetworkVirtualApplianceSkuListResult;

// @public
export interface VirtualHub extends Resource {
    addressPrefix?: string;
    allowBranchToBranchTraffic?: boolean;
    azureFirewall?: SubResource;
    readonly bgpConnections?: SubResource[];
    readonly etag?: string;
    expressRouteGateway?: SubResource;
    hubRoutingPreference?: HubRoutingPreference;
    readonly ipConfigurations?: SubResource[];
    readonly kind?: string;
    p2SVpnGateway?: SubResource;
    preferredRoutingGateway?: PreferredRoutingGateway;
    readonly provisioningState?: ProvisioningState;
    readonly routeMaps?: SubResource[];
    routeTable?: VirtualHubRouteTable;
    readonly routingState?: RoutingState;
    securityPartnerProvider?: SubResource;
    securityProviderName?: string;
    sku?: string;
    virtualHubRouteTableV2S?: VirtualHubRouteTableV2[];
    virtualRouterAsn?: number;
    virtualRouterAutoScaleConfiguration?: VirtualRouterAutoScaleConfiguration;
    virtualRouterIps?: string[];
    virtualWan?: SubResource;
    vpnGateway?: SubResource;
}

// @public
export interface VirtualHubBgpConnection {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, connectionName: string, parameters: BgpConnection, options?: VirtualHubBgpConnectionCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubBgpConnectionCreateOrUpdateResponse>, VirtualHubBgpConnectionCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, connectionName: string, parameters: BgpConnection, options?: VirtualHubBgpConnectionCreateOrUpdateOptionalParams): Promise<VirtualHubBgpConnectionCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, connectionName: string, options?: VirtualHubBgpConnectionDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, connectionName: string, options?: VirtualHubBgpConnectionDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, connectionName: string, options?: VirtualHubBgpConnectionGetOptionalParams): Promise<VirtualHubBgpConnectionGetResponse>;
}

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

// @public
export type VirtualHubBgpConnectionCreateOrUpdateResponse = BgpConnection;

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

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

// @public
export type VirtualHubBgpConnectionGetResponse = BgpConnection;

// @public
export interface VirtualHubBgpConnections {
    beginListAdvertisedRoutes(resourceGroupName: string, hubName: string, connectionName: string, options?: VirtualHubBgpConnectionsListAdvertisedRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubBgpConnectionsListAdvertisedRoutesResponse>, VirtualHubBgpConnectionsListAdvertisedRoutesResponse>>;
    beginListAdvertisedRoutesAndWait(resourceGroupName: string, hubName: string, connectionName: string, options?: VirtualHubBgpConnectionsListAdvertisedRoutesOptionalParams): Promise<VirtualHubBgpConnectionsListAdvertisedRoutesResponse>;
    beginListLearnedRoutes(resourceGroupName: string, hubName: string, connectionName: string, options?: VirtualHubBgpConnectionsListLearnedRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubBgpConnectionsListLearnedRoutesResponse>, VirtualHubBgpConnectionsListLearnedRoutesResponse>>;
    beginListLearnedRoutesAndWait(resourceGroupName: string, hubName: string, connectionName: string, options?: VirtualHubBgpConnectionsListLearnedRoutesOptionalParams): Promise<VirtualHubBgpConnectionsListLearnedRoutesResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: VirtualHubBgpConnectionsListOptionalParams): PagedAsyncIterableIterator<BgpConnection>;
}

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

// @public
export type VirtualHubBgpConnectionsListAdvertisedRoutesResponse = {
    [propertyName: string]: PeerRoute[];
};

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

// @public
export type VirtualHubBgpConnectionsListLearnedRoutesResponse = {
    [propertyName: string]: PeerRoute[];
};

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

// @public
export type VirtualHubBgpConnectionsListNextResponse = ListVirtualHubBgpConnectionResults;

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

// @public
export type VirtualHubBgpConnectionsListResponse = ListVirtualHubBgpConnectionResults;

// @public
export interface VirtualHubEffectiveRoute {
    addressPrefixes?: string[];
    asPath?: string;
    nextHops?: string[];
    nextHopType?: string;
    routeOrigin?: string;
}

// @public
export interface VirtualHubEffectiveRouteList {
    value?: VirtualHubEffectiveRoute[];
}

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

// @public
export interface VirtualHubIpConfiguration {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, ipConfigName: string, parameters: HubIpConfiguration, options?: VirtualHubIpConfigurationCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubIpConfigurationCreateOrUpdateResponse>, VirtualHubIpConfigurationCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, ipConfigName: string, parameters: HubIpConfiguration, options?: VirtualHubIpConfigurationCreateOrUpdateOptionalParams): Promise<VirtualHubIpConfigurationCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, ipConfigName: string, options?: VirtualHubIpConfigurationDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, ipConfigName: string, options?: VirtualHubIpConfigurationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, ipConfigName: string, options?: VirtualHubIpConfigurationGetOptionalParams): Promise<VirtualHubIpConfigurationGetResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: VirtualHubIpConfigurationListOptionalParams): PagedAsyncIterableIterator<HubIpConfiguration>;
}

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

// @public
export type VirtualHubIpConfigurationCreateOrUpdateResponse = HubIpConfiguration;

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

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

// @public
export type VirtualHubIpConfigurationGetResponse = HubIpConfiguration;

// @public
export interface VirtualHubIpConfigurationListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubIpConfigurationListNextResponse = ListVirtualHubIpConfigurationResults;

// @public
export interface VirtualHubIpConfigurationListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubIpConfigurationListResponse = ListVirtualHubIpConfigurationResults;

// @public
export interface VirtualHubRoute {
    addressPrefixes?: string[];
    nextHopIpAddress?: string;
}

// @public
export interface VirtualHubRouteTable {
    routes?: VirtualHubRoute[];
}

// @public
export interface VirtualHubRouteTableV2 extends SubResource {
    attachedConnections?: string[];
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    routes?: VirtualHubRouteV2[];
}

// @public
export interface VirtualHubRouteTableV2S {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, routeTableName: string, virtualHubRouteTableV2Parameters: VirtualHubRouteTableV2, options?: VirtualHubRouteTableV2SCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubRouteTableV2SCreateOrUpdateResponse>, VirtualHubRouteTableV2SCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, routeTableName: string, virtualHubRouteTableV2Parameters: VirtualHubRouteTableV2, options?: VirtualHubRouteTableV2SCreateOrUpdateOptionalParams): Promise<VirtualHubRouteTableV2SCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, routeTableName: string, options?: VirtualHubRouteTableV2SDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, routeTableName: string, options?: VirtualHubRouteTableV2SDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualHubName: string, routeTableName: string, options?: VirtualHubRouteTableV2SGetOptionalParams): Promise<VirtualHubRouteTableV2SGetResponse>;
    list(resourceGroupName: string, virtualHubName: string, options?: VirtualHubRouteTableV2SListOptionalParams): PagedAsyncIterableIterator<VirtualHubRouteTableV2>;
}

// @public
export interface VirtualHubRouteTableV2SCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualHubRouteTableV2SCreateOrUpdateResponse = VirtualHubRouteTableV2;

// @public
export interface VirtualHubRouteTableV2SDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualHubRouteTableV2SGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubRouteTableV2SGetResponse = VirtualHubRouteTableV2;

// @public
export interface VirtualHubRouteTableV2SListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubRouteTableV2SListNextResponse = ListVirtualHubRouteTableV2SResult;

// @public
export interface VirtualHubRouteTableV2SListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubRouteTableV2SListResponse = ListVirtualHubRouteTableV2SResult;

// @public
export interface VirtualHubRouteV2 {
    destinations?: string[];
    destinationType?: string;
    nextHops?: string[];
    nextHopType?: string;
}

// @public
export interface VirtualHubs {
    beginCreateOrUpdate(resourceGroupName: string, virtualHubName: string, virtualHubParameters: VirtualHub, options?: VirtualHubsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubsCreateOrUpdateResponse>, VirtualHubsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHubName: string, virtualHubParameters: VirtualHub, options?: VirtualHubsCreateOrUpdateOptionalParams): Promise<VirtualHubsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualHubName: string, options?: VirtualHubsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualHubName: string, options?: VirtualHubsDeleteOptionalParams): Promise<void>;
    beginGetEffectiveVirtualHubRoutes(resourceGroupName: string, virtualHubName: string, options?: VirtualHubsGetEffectiveVirtualHubRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubsGetEffectiveVirtualHubRoutesResponse>, VirtualHubsGetEffectiveVirtualHubRoutesResponse>>;
    beginGetEffectiveVirtualHubRoutesAndWait(resourceGroupName: string, virtualHubName: string, options?: VirtualHubsGetEffectiveVirtualHubRoutesOptionalParams): Promise<VirtualHubsGetEffectiveVirtualHubRoutesResponse>;
    beginGetInboundRoutes(resourceGroupName: string, virtualHubName: string, getInboundRoutesParameters: GetInboundRoutesParameters, options?: VirtualHubsGetInboundRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubsGetInboundRoutesResponse>, VirtualHubsGetInboundRoutesResponse>>;
    beginGetInboundRoutesAndWait(resourceGroupName: string, virtualHubName: string, getInboundRoutesParameters: GetInboundRoutesParameters, options?: VirtualHubsGetInboundRoutesOptionalParams): Promise<VirtualHubsGetInboundRoutesResponse>;
    beginGetOutboundRoutes(resourceGroupName: string, virtualHubName: string, getOutboundRoutesParameters: GetOutboundRoutesParameters, options?: VirtualHubsGetOutboundRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHubsGetOutboundRoutesResponse>, VirtualHubsGetOutboundRoutesResponse>>;
    beginGetOutboundRoutesAndWait(resourceGroupName: string, virtualHubName: string, getOutboundRoutesParameters: GetOutboundRoutesParameters, options?: VirtualHubsGetOutboundRoutesOptionalParams): Promise<VirtualHubsGetOutboundRoutesResponse>;
    get(resourceGroupName: string, virtualHubName: string, options?: VirtualHubsGetOptionalParams): Promise<VirtualHubsGetResponse>;
    list(options?: VirtualHubsListOptionalParams): PagedAsyncIterableIterator<VirtualHub>;
    listByResourceGroup(resourceGroupName: string, options?: VirtualHubsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VirtualHub>;
    updateTags(resourceGroupName: string, virtualHubName: string, virtualHubParameters: TagsObject, options?: VirtualHubsUpdateTagsOptionalParams): Promise<VirtualHubsUpdateTagsResponse>;
}

// @public
export interface VirtualHubsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualHubsCreateOrUpdateResponse = VirtualHub;

// @public
export interface VirtualHubsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualHubsGetEffectiveVirtualHubRoutesOptionalParams extends coreClient.OperationOptions {
    effectiveRoutesParameters?: EffectiveRoutesParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualHubsGetEffectiveVirtualHubRoutesResponse = VirtualHubEffectiveRouteList;

// @public
export interface VirtualHubsGetInboundRoutesOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualHubsGetInboundRoutesResponse = EffectiveRouteMapRouteList;

// @public
export interface VirtualHubsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface VirtualHubsGetOutboundRoutesOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualHubsGetOutboundRoutesResponse = EffectiveRouteMapRouteList;

// @public
export type VirtualHubsGetResponse = VirtualHub;

// @public
export interface VirtualHubsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubsListByResourceGroupNextResponse = ListVirtualHubsResult;

// @public
export interface VirtualHubsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubsListByResourceGroupResponse = ListVirtualHubsResult;

// @public
export interface VirtualHubsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubsListNextResponse = ListVirtualHubsResult;

// @public
export interface VirtualHubsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubsListResponse = ListVirtualHubsResult;

// @public
export interface VirtualHubsUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualHubsUpdateTagsResponse = VirtualHub;

// @public
export interface VirtualNetwork extends Resource {
    addressSpace?: AddressSpace;
    bgpCommunities?: VirtualNetworkBgpCommunities;
    ddosProtectionPlan?: SubResource;
    readonly defaultPublicNatGateway?: SubResource;
    dhcpOptions?: DhcpOptions;
    enableDdosProtection?: boolean;
    enableVmProtection?: boolean;
    encryption?: VirtualNetworkEncryption;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    readonly flowLogs?: FlowLog[];
    flowTimeoutInMinutes?: number;
    ipAllocations?: SubResource[];
    privateEndpointVNetPolicies?: PrivateEndpointVNetPolicies;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    subnets?: Subnet[];
    virtualNetworkPeerings?: VirtualNetworkPeering[];
}

// @public
export interface VirtualNetworkBgpCommunities {
    readonly regionalCommunity?: string;
    virtualNetworkCommunity: string;
}

// @public
export interface VirtualNetworkConnectionGatewayReference {
    id: string;
}

// @public
export interface VirtualNetworkDdosProtectionStatusResult {
    nextLink?: string;
    value?: PublicIpDdosProtectionStatusResult[];
}

// @public
export interface VirtualNetworkEncryption {
    enabled: boolean;
    enforcement?: VirtualNetworkEncryptionEnforcement;
}

// @public
export type VirtualNetworkEncryptionEnforcement = string;

// @public
export interface VirtualNetworkGateway extends Resource {
    active?: boolean;
    adminState?: AdminState;
    allowRemoteVnetTraffic?: boolean;
    allowVirtualWanTraffic?: boolean;
    autoScaleConfiguration?: VirtualNetworkGatewayAutoScaleConfiguration;
    bgpSettings?: BgpSettings;
    customRoutes?: AddressSpace;
    disableIPSecReplayProtection?: boolean;
    enableBgp?: boolean;
    enableBgpRouteTranslationForNat?: boolean;
    enableDnsForwarding?: boolean;
    enableHighBandwidthVpnGateway?: boolean;
    enablePrivateIpAddress?: boolean;
    readonly etag?: string;
    extendedLocation?: ExtendedLocation;
    gatewayDefaultSite?: SubResource;
    gatewayType?: VirtualNetworkGatewayType;
    identity?: ManagedServiceIdentity;
    readonly inboundDnsForwardingEndpoint?: string;
    ipConfigurations?: VirtualNetworkGatewayIPConfiguration[];
    natRules?: VirtualNetworkGatewayNatRule[];
    readonly provisioningState?: ProvisioningState;
    resiliencyModel?: ResiliencyModel;
    readonly resourceGuid?: string;
    sku?: VirtualNetworkGatewaySku;
    virtualNetworkGatewayMigrationStatus?: VirtualNetworkGatewayMigrationStatus;
    virtualNetworkGatewayPolicyGroups?: VirtualNetworkGatewayPolicyGroup[];
    vNetExtendedLocationResourceId?: string;
    vpnClientConfiguration?: VpnClientConfiguration;
    vpnGatewayGeneration?: VpnGatewayGeneration;
    vpnType?: VpnType;
}

// @public (undocumented)
export interface VirtualNetworkGatewayAutoScaleBounds {
    max?: number;
    min?: number;
}

// @public
export interface VirtualNetworkGatewayAutoScaleConfiguration {
    bounds?: VirtualNetworkGatewayAutoScaleBounds;
}

// @public
export interface VirtualNetworkGatewayConnection extends Resource {
    authorizationKey?: string;
    connectionMode?: VirtualNetworkGatewayConnectionMode;
    connectionProtocol?: VirtualNetworkGatewayConnectionProtocol;
    readonly connectionStatus?: VirtualNetworkGatewayConnectionStatus;
    connectionType: VirtualNetworkGatewayConnectionType;
    dpdTimeoutSeconds?: number;
    readonly egressBytesTransferred?: number;
    egressNatRules?: SubResource[];
    enableBgp?: boolean;
    enablePrivateLinkFastPath?: boolean;
    readonly etag?: string;
    expressRouteGatewayBypass?: boolean;
    gatewayCustomBgpIpAddresses?: GatewayCustomBgpIpAddressIpConfiguration[];
    readonly ingressBytesTransferred?: number;
    ingressNatRules?: SubResource[];
    ipsecPolicies?: IpsecPolicy[];
    localNetworkGateway2?: LocalNetworkGateway;
    peer?: SubResource;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    routingWeight?: number;
    sharedKey?: string;
    trafficSelectorPolicies?: TrafficSelectorPolicy[];
    readonly tunnelConnectionStatus?: TunnelConnectionHealth[];
    tunnelProperties?: VirtualNetworkGatewayConnectionTunnelProperties[];
    useLocalAzureIpAddress?: boolean;
    usePolicyBasedTrafficSelectors?: boolean;
    virtualNetworkGateway1: VirtualNetworkGateway;
    virtualNetworkGateway2?: VirtualNetworkGateway;
}

// @public
export interface VirtualNetworkGatewayConnectionListEntity extends Resource {
    authorizationKey?: string;
    connectionMode?: VirtualNetworkGatewayConnectionMode;
    connectionProtocol?: VirtualNetworkGatewayConnectionProtocol;
    readonly connectionStatus?: VirtualNetworkGatewayConnectionStatus;
    connectionType: VirtualNetworkGatewayConnectionType;
    readonly egressBytesTransferred?: number;
    enableBgp?: boolean;
    enablePrivateLinkFastPath?: boolean;
    readonly etag?: string;
    expressRouteGatewayBypass?: boolean;
    gatewayCustomBgpIpAddresses?: GatewayCustomBgpIpAddressIpConfiguration[];
    readonly ingressBytesTransferred?: number;
    ipsecPolicies?: IpsecPolicy[];
    localNetworkGateway2?: VirtualNetworkConnectionGatewayReference;
    peer?: SubResource;
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
    routingWeight?: number;
    sharedKey?: string;
    trafficSelectorPolicies?: TrafficSelectorPolicy[];
    readonly tunnelConnectionStatus?: TunnelConnectionHealth[];
    usePolicyBasedTrafficSelectors?: boolean;
    virtualNetworkGateway1: VirtualNetworkConnectionGatewayReference;
    virtualNetworkGateway2?: VirtualNetworkConnectionGatewayReference;
}

// @public
export interface VirtualNetworkGatewayConnectionListResult {
    readonly nextLink?: string;
    value?: VirtualNetworkGatewayConnection[];
}

// @public
export type VirtualNetworkGatewayConnectionMode = string;

// @public
export type VirtualNetworkGatewayConnectionProtocol = string;

// @public
export interface VirtualNetworkGatewayConnections {
    beginCreateOrUpdate(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: VirtualNetworkGatewayConnection, options?: VirtualNetworkGatewayConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsCreateOrUpdateResponse>, VirtualNetworkGatewayConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: VirtualNetworkGatewayConnection, options?: VirtualNetworkGatewayConnectionsCreateOrUpdateOptionalParams): Promise<VirtualNetworkGatewayConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsDeleteOptionalParams): Promise<void>;
    beginGetIkeSas(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsGetIkeSasOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsGetIkeSasResponse>, VirtualNetworkGatewayConnectionsGetIkeSasResponse>>;
    beginGetIkeSasAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsGetIkeSasOptionalParams): Promise<VirtualNetworkGatewayConnectionsGetIkeSasResponse>;
    beginResetConnection(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsResetConnectionOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginResetConnectionAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsResetConnectionOptionalParams): Promise<void>;
    beginResetSharedKey(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: ConnectionResetSharedKey, options?: VirtualNetworkGatewayConnectionsResetSharedKeyOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsResetSharedKeyResponse>, VirtualNetworkGatewayConnectionsResetSharedKeyResponse>>;
    beginResetSharedKeyAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: ConnectionResetSharedKey, options?: VirtualNetworkGatewayConnectionsResetSharedKeyOptionalParams): Promise<VirtualNetworkGatewayConnectionsResetSharedKeyResponse>;
    beginSetSharedKey(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: ConnectionSharedKey, options?: VirtualNetworkGatewayConnectionsSetSharedKeyOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsSetSharedKeyResponse>, VirtualNetworkGatewayConnectionsSetSharedKeyResponse>>;
    beginSetSharedKeyAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: ConnectionSharedKey, options?: VirtualNetworkGatewayConnectionsSetSharedKeyOptionalParams): Promise<VirtualNetworkGatewayConnectionsSetSharedKeyResponse>;
    beginStartPacketCapture(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsStartPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsStartPacketCaptureResponse>, VirtualNetworkGatewayConnectionsStartPacketCaptureResponse>>;
    beginStartPacketCaptureAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsStartPacketCaptureOptionalParams): Promise<VirtualNetworkGatewayConnectionsStartPacketCaptureResponse>;
    beginStopPacketCapture(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: VpnPacketCaptureStopParameters, options?: VirtualNetworkGatewayConnectionsStopPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsStopPacketCaptureResponse>, VirtualNetworkGatewayConnectionsStopPacketCaptureResponse>>;
    beginStopPacketCaptureAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: VpnPacketCaptureStopParameters, options?: VirtualNetworkGatewayConnectionsStopPacketCaptureOptionalParams): Promise<VirtualNetworkGatewayConnectionsStopPacketCaptureResponse>;
    beginUpdateTags(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: TagsObject, options?: VirtualNetworkGatewayConnectionsUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayConnectionsUpdateTagsResponse>, VirtualNetworkGatewayConnectionsUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: TagsObject, options?: VirtualNetworkGatewayConnectionsUpdateTagsOptionalParams): Promise<VirtualNetworkGatewayConnectionsUpdateTagsResponse>;
    get(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsGetOptionalParams): Promise<VirtualNetworkGatewayConnectionsGetResponse>;
    getSharedKey(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, options?: VirtualNetworkGatewayConnectionsGetSharedKeyOptionalParams): Promise<VirtualNetworkGatewayConnectionsGetSharedKeyResponse>;
    list(resourceGroupName: string, options?: VirtualNetworkGatewayConnectionsListOptionalParams): PagedAsyncIterableIterator<VirtualNetworkGatewayConnection>;
}

// @public
export interface VirtualNetworkGatewayConnectionsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsCreateOrUpdateResponse = VirtualNetworkGatewayConnection;

// @public
export interface VirtualNetworkGatewayConnectionsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkGatewayConnectionsGetIkeSasOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsGetIkeSasResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewayConnectionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayConnectionsGetResponse = VirtualNetworkGatewayConnection;

// @public
export interface VirtualNetworkGatewayConnectionsGetSharedKeyOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayConnectionsGetSharedKeyResponse = ConnectionSharedKey;

// @public
export interface VirtualNetworkGatewayConnectionsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayConnectionsListNextResponse = VirtualNetworkGatewayConnectionListResult;

// @public
export interface VirtualNetworkGatewayConnectionsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayConnectionsListResponse = VirtualNetworkGatewayConnectionListResult;

// @public
export interface VirtualNetworkGatewayConnectionsResetConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkGatewayConnectionsResetSharedKeyOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsResetSharedKeyResponse = ConnectionResetSharedKey;

// @public
export interface VirtualNetworkGatewayConnectionsSetSharedKeyOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsSetSharedKeyResponse = ConnectionSharedKey;

// @public
export interface VirtualNetworkGatewayConnectionsStartPacketCaptureOptionalParams extends coreClient.OperationOptions {
    parameters?: VpnPacketCaptureStartParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsStartPacketCaptureResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewayConnectionsStopPacketCaptureOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsStopPacketCaptureResponse = {
    body: string;
};

// @public
export type VirtualNetworkGatewayConnectionStatus = string;

// @public
export interface VirtualNetworkGatewayConnectionsUpdateTagsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayConnectionsUpdateTagsResponse = VirtualNetworkGatewayConnection;

// @public (undocumented)
export interface VirtualNetworkGatewayConnectionTunnelProperties {
    bgpPeeringAddress?: string;
    tunnelIpAddress?: string;
}

// @public
export type VirtualNetworkGatewayConnectionType = string;

// @public
export interface VirtualNetworkGatewayIPConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly privateIPAddress?: string;
    privateIPAllocationMethod?: IPAllocationMethod;
    readonly provisioningState?: ProvisioningState;
    publicIPAddress?: SubResource;
    subnet?: SubResource;
}

// @public
export interface VirtualNetworkGatewayListConnectionsResult {
    readonly nextLink?: string;
    value?: VirtualNetworkGatewayConnectionListEntity[];
}

// @public
export interface VirtualNetworkGatewayListResult {
    readonly nextLink?: string;
    value?: VirtualNetworkGateway[];
}

// @public
export interface VirtualNetworkGatewayMigrationParameters {
    migrationType: VirtualNetworkGatewayMigrationType;
    resourceUrl?: string;
}

// @public
export type VirtualNetworkGatewayMigrationPhase = string;

// @public
export type VirtualNetworkGatewayMigrationState = string;

// @public
export interface VirtualNetworkGatewayMigrationStatus {
    errorMessage?: string;
    phase?: VirtualNetworkGatewayMigrationPhase;
    state?: VirtualNetworkGatewayMigrationState;
}

// @public
export type VirtualNetworkGatewayMigrationType = string;

// @public
export interface VirtualNetworkGatewayNatRule extends SubResource {
    readonly etag?: string;
    externalMappings?: VpnNatRuleMapping[];
    internalMappings?: VpnNatRuleMapping[];
    ipConfigurationId?: string;
    mode?: VpnNatRuleMode;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
    typePropertiesType?: VpnNatRuleType;
}

// @public
export interface VirtualNetworkGatewayNatRules {
    beginCreateOrUpdate(resourceGroupName: string, virtualNetworkGatewayName: string, natRuleName: string, natRuleParameters: VirtualNetworkGatewayNatRule, options?: VirtualNetworkGatewayNatRulesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewayNatRulesCreateOrUpdateResponse>, VirtualNetworkGatewayNatRulesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, natRuleName: string, natRuleParameters: VirtualNetworkGatewayNatRule, options?: VirtualNetworkGatewayNatRulesCreateOrUpdateOptionalParams): Promise<VirtualNetworkGatewayNatRulesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualNetworkGatewayName: string, natRuleName: string, options?: VirtualNetworkGatewayNatRulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, natRuleName: string, options?: VirtualNetworkGatewayNatRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualNetworkGatewayName: string, natRuleName: string, options?: VirtualNetworkGatewayNatRulesGetOptionalParams): Promise<VirtualNetworkGatewayNatRulesGetResponse>;
    listByVirtualNetworkGateway(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewayNatRulesListByVirtualNetworkGatewayOptionalParams): PagedAsyncIterableIterator<VirtualNetworkGatewayNatRule>;
}

// @public
export interface VirtualNetworkGatewayNatRulesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewayNatRulesCreateOrUpdateResponse = VirtualNetworkGatewayNatRule;

// @public
export interface VirtualNetworkGatewayNatRulesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkGatewayNatRulesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayNatRulesGetResponse = VirtualNetworkGatewayNatRule;

// @public
export interface VirtualNetworkGatewayNatRulesListByVirtualNetworkGatewayNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayNatRulesListByVirtualNetworkGatewayNextResponse = ListVirtualNetworkGatewayNatRulesResult;

// @public
export interface VirtualNetworkGatewayNatRulesListByVirtualNetworkGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewayNatRulesListByVirtualNetworkGatewayResponse = ListVirtualNetworkGatewayNatRulesResult;

// @public
export interface VirtualNetworkGatewayPolicyGroup extends SubResource {
    readonly etag?: string;
    isDefault?: boolean;
    name?: string;
    policyMembers?: VirtualNetworkGatewayPolicyGroupMember[];
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    readonly vngClientConnectionConfigurations?: SubResource[];
}

// @public
export interface VirtualNetworkGatewayPolicyGroupMember {
    attributeType?: VpnPolicyMemberAttributeType;
    attributeValue?: string;
    name?: string;
}

// @public
export interface VirtualNetworkGateways {
    beginCreateOrUpdate(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VirtualNetworkGateway, options?: VirtualNetworkGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysCreateOrUpdateResponse>, VirtualNetworkGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VirtualNetworkGateway, options?: VirtualNetworkGatewaysCreateOrUpdateOptionalParams): Promise<VirtualNetworkGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysDeleteOptionalParams): Promise<void>;
    beginDisconnectVirtualNetworkGatewayVpnConnections(resourceGroupName: string, virtualNetworkGatewayName: string, request: P2SVpnConnectionRequest, options?: VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDisconnectVirtualNetworkGatewayVpnConnectionsAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, request: P2SVpnConnectionRequest, options?: VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsOptionalParams): Promise<void>;
    beginGeneratevpnclientpackage(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VpnClientParameters, options?: VirtualNetworkGatewaysGeneratevpnclientpackageOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGeneratevpnclientpackageResponse>, VirtualNetworkGatewaysGeneratevpnclientpackageResponse>>;
    beginGeneratevpnclientpackageAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VpnClientParameters, options?: VirtualNetworkGatewaysGeneratevpnclientpackageOptionalParams): Promise<VirtualNetworkGatewaysGeneratevpnclientpackageResponse>;
    beginGenerateVpnProfile(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VpnClientParameters, options?: VirtualNetworkGatewaysGenerateVpnProfileOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGenerateVpnProfileResponse>, VirtualNetworkGatewaysGenerateVpnProfileResponse>>;
    beginGenerateVpnProfileAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VpnClientParameters, options?: VirtualNetworkGatewaysGenerateVpnProfileOptionalParams): Promise<VirtualNetworkGatewaysGenerateVpnProfileResponse>;
    beginGetAdvertisedRoutes(resourceGroupName: string, virtualNetworkGatewayName: string, peer: string, options?: VirtualNetworkGatewaysGetAdvertisedRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetAdvertisedRoutesResponse>, VirtualNetworkGatewaysGetAdvertisedRoutesResponse>>;
    beginGetAdvertisedRoutesAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, peer: string, options?: VirtualNetworkGatewaysGetAdvertisedRoutesOptionalParams): Promise<VirtualNetworkGatewaysGetAdvertisedRoutesResponse>;
    beginGetBgpPeerStatus(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetBgpPeerStatusOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetBgpPeerStatusResponse>, VirtualNetworkGatewaysGetBgpPeerStatusResponse>>;
    beginGetBgpPeerStatusAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetBgpPeerStatusOptionalParams): Promise<VirtualNetworkGatewaysGetBgpPeerStatusResponse>;
    beginGetFailoverAllTestDetails(resourceGroupName: string, virtualNetworkGatewayName: string, typeParam: string, fetchLatest: boolean, options?: VirtualNetworkGatewaysGetFailoverAllTestDetailsOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetFailoverAllTestDetailsResponse>, VirtualNetworkGatewaysGetFailoverAllTestDetailsResponse>>;
    beginGetFailoverAllTestDetailsAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, typeParam: string, fetchLatest: boolean, options?: VirtualNetworkGatewaysGetFailoverAllTestDetailsOptionalParams): Promise<VirtualNetworkGatewaysGetFailoverAllTestDetailsResponse>;
    beginGetFailoverSingleTestDetails(resourceGroupName: string, virtualNetworkGatewayName: string, peeringLocation: string, failoverTestId: string, options?: VirtualNetworkGatewaysGetFailoverSingleTestDetailsOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetFailoverSingleTestDetailsResponse>, VirtualNetworkGatewaysGetFailoverSingleTestDetailsResponse>>;
    beginGetFailoverSingleTestDetailsAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, peeringLocation: string, failoverTestId: string, options?: VirtualNetworkGatewaysGetFailoverSingleTestDetailsOptionalParams): Promise<VirtualNetworkGatewaysGetFailoverSingleTestDetailsResponse>;
    beginGetLearnedRoutes(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetLearnedRoutesOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetLearnedRoutesResponse>, VirtualNetworkGatewaysGetLearnedRoutesResponse>>;
    beginGetLearnedRoutesAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetLearnedRoutesOptionalParams): Promise<VirtualNetworkGatewaysGetLearnedRoutesResponse>;
    beginGetResiliencyInformation(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetResiliencyInformationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetResiliencyInformationResponse>, VirtualNetworkGatewaysGetResiliencyInformationResponse>>;
    beginGetResiliencyInformationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetResiliencyInformationOptionalParams): Promise<VirtualNetworkGatewaysGetResiliencyInformationResponse>;
    beginGetRoutesInformation(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetRoutesInformationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetRoutesInformationResponse>, VirtualNetworkGatewaysGetRoutesInformationResponse>>;
    beginGetRoutesInformationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetRoutesInformationOptionalParams): Promise<VirtualNetworkGatewaysGetRoutesInformationResponse>;
    beginGetVpnclientConnectionHealth(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetVpnclientConnectionHealthOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetVpnclientConnectionHealthResponse>, VirtualNetworkGatewaysGetVpnclientConnectionHealthResponse>>;
    beginGetVpnclientConnectionHealthAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetVpnclientConnectionHealthOptionalParams): Promise<VirtualNetworkGatewaysGetVpnclientConnectionHealthResponse>;
    beginGetVpnclientIpsecParameters(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetVpnclientIpsecParametersOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetVpnclientIpsecParametersResponse>, VirtualNetworkGatewaysGetVpnclientIpsecParametersResponse>>;
    beginGetVpnclientIpsecParametersAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetVpnclientIpsecParametersOptionalParams): Promise<VirtualNetworkGatewaysGetVpnclientIpsecParametersResponse>;
    beginGetVpnProfilePackageUrl(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetVpnProfilePackageUrlOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysGetVpnProfilePackageUrlResponse>, VirtualNetworkGatewaysGetVpnProfilePackageUrlResponse>>;
    beginGetVpnProfilePackageUrlAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetVpnProfilePackageUrlOptionalParams): Promise<VirtualNetworkGatewaysGetVpnProfilePackageUrlResponse>;
    beginInvokeAbortMigration(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysInvokeAbortMigrationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysInvokeAbortMigrationResponse>, VirtualNetworkGatewaysInvokeAbortMigrationResponse>>;
    beginInvokeAbortMigrationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysInvokeAbortMigrationOptionalParams): Promise<VirtualNetworkGatewaysInvokeAbortMigrationResponse>;
    beginInvokeCommitMigration(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysInvokeCommitMigrationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysInvokeCommitMigrationResponse>, VirtualNetworkGatewaysInvokeCommitMigrationResponse>>;
    beginInvokeCommitMigrationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysInvokeCommitMigrationOptionalParams): Promise<VirtualNetworkGatewaysInvokeCommitMigrationResponse>;
    beginInvokeExecuteMigration(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysInvokeExecuteMigrationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysInvokeExecuteMigrationResponse>, VirtualNetworkGatewaysInvokeExecuteMigrationResponse>>;
    beginInvokeExecuteMigrationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysInvokeExecuteMigrationOptionalParams): Promise<VirtualNetworkGatewaysInvokeExecuteMigrationResponse>;
    beginInvokePrepareMigration(resourceGroupName: string, virtualNetworkGatewayName: string, migrationParams: VirtualNetworkGatewayMigrationParameters, options?: VirtualNetworkGatewaysInvokePrepareMigrationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysInvokePrepareMigrationResponse>, VirtualNetworkGatewaysInvokePrepareMigrationResponse>>;
    beginInvokePrepareMigrationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, migrationParams: VirtualNetworkGatewayMigrationParameters, options?: VirtualNetworkGatewaysInvokePrepareMigrationOptionalParams): Promise<VirtualNetworkGatewaysInvokePrepareMigrationResponse>;
    beginReset(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysResetOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysResetResponse>, VirtualNetworkGatewaysResetResponse>>;
    beginResetAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysResetOptionalParams): Promise<VirtualNetworkGatewaysResetResponse>;
    beginResetVpnClientSharedKey(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysResetVpnClientSharedKeyOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginResetVpnClientSharedKeyAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysResetVpnClientSharedKeyOptionalParams): Promise<void>;
    beginSetVpnclientIpsecParameters(resourceGroupName: string, virtualNetworkGatewayName: string, vpnclientIpsecParams: VpnClientIPsecParameters, options?: VirtualNetworkGatewaysSetVpnclientIpsecParametersOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysSetVpnclientIpsecParametersResponse>, VirtualNetworkGatewaysSetVpnclientIpsecParametersResponse>>;
    beginSetVpnclientIpsecParametersAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, vpnclientIpsecParams: VpnClientIPsecParameters, options?: VirtualNetworkGatewaysSetVpnclientIpsecParametersOptionalParams): Promise<VirtualNetworkGatewaysSetVpnclientIpsecParametersResponse>;
    beginStartExpressRouteSiteFailoverSimulation(resourceGroupName: string, virtualNetworkGatewayName: string, peeringLocation: string, options?: VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationResponse>, VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationResponse>>;
    beginStartExpressRouteSiteFailoverSimulationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, peeringLocation: string, options?: VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationOptionalParams): Promise<VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationResponse>;
    beginStartPacketCapture(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysStartPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysStartPacketCaptureResponse>, VirtualNetworkGatewaysStartPacketCaptureResponse>>;
    beginStartPacketCaptureAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysStartPacketCaptureOptionalParams): Promise<VirtualNetworkGatewaysStartPacketCaptureResponse>;
    beginStopExpressRouteSiteFailoverSimulation(resourceGroupName: string, virtualNetworkGatewayName: string, stopParameters: ExpressRouteFailoverStopApiParameters, options?: VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationResponse>, VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationResponse>>;
    beginStopExpressRouteSiteFailoverSimulationAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, stopParameters: ExpressRouteFailoverStopApiParameters, options?: VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationOptionalParams): Promise<VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationResponse>;
    beginStopPacketCapture(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VpnPacketCaptureStopParameters, options?: VirtualNetworkGatewaysStopPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysStopPacketCaptureResponse>, VirtualNetworkGatewaysStopPacketCaptureResponse>>;
    beginStopPacketCaptureAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: VpnPacketCaptureStopParameters, options?: VirtualNetworkGatewaysStopPacketCaptureOptionalParams): Promise<VirtualNetworkGatewaysStopPacketCaptureResponse>;
    beginUpdateTags(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: TagsObject, options?: VirtualNetworkGatewaysUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkGatewaysUpdateTagsResponse>, VirtualNetworkGatewaysUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, virtualNetworkGatewayName: string, parameters: TagsObject, options?: VirtualNetworkGatewaysUpdateTagsOptionalParams): Promise<VirtualNetworkGatewaysUpdateTagsResponse>;
    get(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysGetOptionalParams): Promise<VirtualNetworkGatewaysGetResponse>;
    list(resourceGroupName: string, options?: VirtualNetworkGatewaysListOptionalParams): PagedAsyncIterableIterator<VirtualNetworkGateway>;
    listConnections(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysListConnectionsOptionalParams): PagedAsyncIterableIterator<VirtualNetworkGatewayConnectionListEntity>;
    supportedVpnDevices(resourceGroupName: string, virtualNetworkGatewayName: string, options?: VirtualNetworkGatewaysSupportedVpnDevicesOptionalParams): Promise<VirtualNetworkGatewaysSupportedVpnDevicesResponse>;
    vpnDeviceConfigurationScript(resourceGroupName: string, virtualNetworkGatewayConnectionName: string, parameters: VpnDeviceScriptParameters, options?: VirtualNetworkGatewaysVpnDeviceConfigurationScriptOptionalParams): Promise<VirtualNetworkGatewaysVpnDeviceConfigurationScriptResponse>;
}

// @public
export interface VirtualNetworkGatewaysCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysCreateOrUpdateResponse = VirtualNetworkGateway;

// @public
export interface VirtualNetworkGatewaysDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkGatewaysGeneratevpnclientpackageOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGeneratevpnclientpackageResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysGenerateVpnProfileOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGenerateVpnProfileResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysGetAdvertisedRoutesOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetAdvertisedRoutesResponse = GatewayRouteListResult;

// @public
export interface VirtualNetworkGatewaysGetBgpPeerStatusOptionalParams extends coreClient.OperationOptions {
    peer?: string;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetBgpPeerStatusResponse = BgpPeerStatusListResult;

// @public
export interface VirtualNetworkGatewaysGetFailoverAllTestDetailsHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysGetFailoverAllTestDetailsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetFailoverAllTestDetailsResponse = ExpressRouteFailoverTestDetails[];

// @public
export interface VirtualNetworkGatewaysGetFailoverSingleTestDetailsHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysGetFailoverSingleTestDetailsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetFailoverSingleTestDetailsResponse = ExpressRouteFailoverSingleTestDetails[];

// @public
export interface VirtualNetworkGatewaysGetLearnedRoutesOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetLearnedRoutesResponse = GatewayRouteListResult;

// @public
export interface VirtualNetworkGatewaysGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface VirtualNetworkGatewaysGetResiliencyInformationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysGetResiliencyInformationOptionalParams extends coreClient.OperationOptions {
    attemptRefresh?: boolean;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetResiliencyInformationResponse = GatewayResiliencyInformation;

// @public
export type VirtualNetworkGatewaysGetResponse = VirtualNetworkGateway;

// @public
export interface VirtualNetworkGatewaysGetRoutesInformationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysGetRoutesInformationOptionalParams extends coreClient.OperationOptions {
    attemptRefresh?: boolean;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetRoutesInformationResponse = GatewayRouteSetsInformation;

// @public
export interface VirtualNetworkGatewaysGetVpnclientConnectionHealthOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetVpnclientConnectionHealthResponse = VpnClientConnectionHealthDetailListResult;

// @public
export interface VirtualNetworkGatewaysGetVpnclientIpsecParametersOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetVpnclientIpsecParametersResponse = VpnClientIPsecParameters;

// @public
export interface VirtualNetworkGatewaysGetVpnProfilePackageUrlOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysGetVpnProfilePackageUrlResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysInvokeAbortMigrationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysInvokeAbortMigrationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysInvokeAbortMigrationResponse = VirtualNetworkGatewaysInvokeAbortMigrationHeaders;

// @public
export interface VirtualNetworkGatewaysInvokeCommitMigrationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysInvokeCommitMigrationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysInvokeCommitMigrationResponse = VirtualNetworkGatewaysInvokeCommitMigrationHeaders;

// @public
export interface VirtualNetworkGatewaysInvokeExecuteMigrationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysInvokeExecuteMigrationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysInvokeExecuteMigrationResponse = VirtualNetworkGatewaysInvokeExecuteMigrationHeaders;

// @public
export interface VirtualNetworkGatewaysInvokePrepareMigrationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysInvokePrepareMigrationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysInvokePrepareMigrationResponse = VirtualNetworkGatewaysInvokePrepareMigrationHeaders;

// @public
export interface VirtualNetworkGatewaySku {
    readonly capacity?: number;
    name?: VirtualNetworkGatewaySkuName;
    tier?: VirtualNetworkGatewaySkuTier;
}

// @public
export type VirtualNetworkGatewaySkuName = string;

// @public
export type VirtualNetworkGatewaySkuTier = string;

// @public
export interface VirtualNetworkGatewaysListConnectionsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewaysListConnectionsNextResponse = VirtualNetworkGatewayListConnectionsResult;

// @public
export interface VirtualNetworkGatewaysListConnectionsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewaysListConnectionsResponse = VirtualNetworkGatewayListConnectionsResult;

// @public
export interface VirtualNetworkGatewaysListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewaysListNextResponse = VirtualNetworkGatewayListResult;

// @public
export interface VirtualNetworkGatewaysListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewaysListResponse = VirtualNetworkGatewayListResult;

// @public
export interface VirtualNetworkGatewaysResetOptionalParams extends coreClient.OperationOptions {
    gatewayVip?: string;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysResetResponse = VirtualNetworkGateway;

// @public
export interface VirtualNetworkGatewaysResetVpnClientSharedKeyOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkGatewaysSetVpnclientIpsecParametersOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysSetVpnclientIpsecParametersResponse = VpnClientIPsecParameters;

// @public
export interface VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysStartExpressRouteSiteFailoverSimulationResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysStartPacketCaptureOptionalParams extends coreClient.OperationOptions {
    parameters?: VpnPacketCaptureStartParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysStartPacketCaptureResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysStopExpressRouteSiteFailoverSimulationResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysStopPacketCaptureOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysStopPacketCaptureResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysSupportedVpnDevicesOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewaysSupportedVpnDevicesResponse = {
    body: string;
};

// @public
export interface VirtualNetworkGatewaysUpdateTagsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkGatewaysUpdateTagsResponse = VirtualNetworkGateway;

// @public
export interface VirtualNetworkGatewaysVpnDeviceConfigurationScriptOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkGatewaysVpnDeviceConfigurationScriptResponse = {
    body: string;
};

// @public
export type VirtualNetworkGatewayType = string;

// @public
export interface VirtualNetworkListResult {
    nextLink?: string;
    value?: VirtualNetwork[];
}

// @public
export interface VirtualNetworkListUsageResult {
    nextLink?: string;
    readonly value?: VirtualNetworkUsage[];
}

// @public
export interface VirtualNetworkPeering extends SubResource {
    allowForwardedTraffic?: boolean;
    allowGatewayTransit?: boolean;
    allowVirtualNetworkAccess?: boolean;
    doNotVerifyRemoteGateways?: boolean;
    enableOnlyIPv6Peering?: boolean;
    readonly etag?: string;
    localAddressSpace?: AddressSpace;
    localSubnetNames?: string[];
    localVirtualNetworkAddressSpace?: AddressSpace;
    name?: string;
    peerCompleteVnets?: boolean;
    peeringState?: VirtualNetworkPeeringState;
    peeringSyncLevel?: VirtualNetworkPeeringLevel;
    readonly provisioningState?: ProvisioningState;
    remoteAddressSpace?: AddressSpace;
    remoteBgpCommunities?: VirtualNetworkBgpCommunities;
    remoteSubnetNames?: string[];
    remoteVirtualNetwork?: SubResource;
    remoteVirtualNetworkAddressSpace?: AddressSpace;
    readonly remoteVirtualNetworkEncryption?: VirtualNetworkEncryption;
    readonly resourceGuid?: string;
    type?: string;
    useRemoteGateways?: boolean;
}

// @public
export type VirtualNetworkPeeringLevel = string;

// @public
export interface VirtualNetworkPeeringListResult {
    nextLink?: string;
    value?: VirtualNetworkPeering[];
}

// @public
export interface VirtualNetworkPeerings {
    beginCreateOrUpdate(resourceGroupName: string, virtualNetworkName: string, virtualNetworkPeeringName: string, virtualNetworkPeeringParameters: VirtualNetworkPeering, options?: VirtualNetworkPeeringsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkPeeringsCreateOrUpdateResponse>, VirtualNetworkPeeringsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualNetworkName: string, virtualNetworkPeeringName: string, virtualNetworkPeeringParameters: VirtualNetworkPeering, options?: VirtualNetworkPeeringsCreateOrUpdateOptionalParams): Promise<VirtualNetworkPeeringsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualNetworkName: string, virtualNetworkPeeringName: string, options?: VirtualNetworkPeeringsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualNetworkName: string, virtualNetworkPeeringName: string, options?: VirtualNetworkPeeringsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualNetworkName: string, virtualNetworkPeeringName: string, options?: VirtualNetworkPeeringsGetOptionalParams): Promise<VirtualNetworkPeeringsGetResponse>;
    list(resourceGroupName: string, virtualNetworkName: string, options?: VirtualNetworkPeeringsListOptionalParams): PagedAsyncIterableIterator<VirtualNetworkPeering>;
}

// @public
export interface VirtualNetworkPeeringsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    syncRemoteAddressSpace?: SyncRemoteAddressSpace;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkPeeringsCreateOrUpdateResponse = VirtualNetworkPeering;

// @public
export interface VirtualNetworkPeeringsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkPeeringsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkPeeringsGetResponse = VirtualNetworkPeering;

// @public
export interface VirtualNetworkPeeringsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkPeeringsListNextResponse = VirtualNetworkPeeringListResult;

// @public
export interface VirtualNetworkPeeringsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkPeeringsListResponse = VirtualNetworkPeeringListResult;

// @public
export type VirtualNetworkPeeringState = string;

// @public
export type VirtualNetworkPrivateEndpointNetworkPolicies = string;

// @public
export type VirtualNetworkPrivateLinkServiceNetworkPolicies = string;

// @public
export interface VirtualNetworks {
    beginCreateOrUpdate(resourceGroupName: string, virtualNetworkName: string, parameters: VirtualNetwork, options?: VirtualNetworksCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworksCreateOrUpdateResponse>, VirtualNetworksCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualNetworkName: string, parameters: VirtualNetwork, options?: VirtualNetworksCreateOrUpdateOptionalParams): Promise<VirtualNetworksCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualNetworkName: string, options?: VirtualNetworksDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualNetworkName: string, options?: VirtualNetworksDeleteOptionalParams): Promise<void>;
    beginListDdosProtectionStatusAndWait(resourceGroupName: string, virtualNetworkName: string, options?: VirtualNetworksListDdosProtectionStatusOptionalParams): PagedAsyncIterableIterator<PublicIpDdosProtectionStatusResult>;
    checkIPAddressAvailability(resourceGroupName: string, virtualNetworkName: string, ipAddress: string, options?: VirtualNetworksCheckIPAddressAvailabilityOptionalParams): Promise<VirtualNetworksCheckIPAddressAvailabilityResponse>;
    get(resourceGroupName: string, virtualNetworkName: string, options?: VirtualNetworksGetOptionalParams): Promise<VirtualNetworksGetResponse>;
    list(resourceGroupName: string, options?: VirtualNetworksListOptionalParams): PagedAsyncIterableIterator<VirtualNetwork>;
    listAll(options?: VirtualNetworksListAllOptionalParams): PagedAsyncIterableIterator<VirtualNetwork>;
    listUsage(resourceGroupName: string, virtualNetworkName: string, options?: VirtualNetworksListUsageOptionalParams): PagedAsyncIterableIterator<VirtualNetworkUsage>;
    updateTags(resourceGroupName: string, virtualNetworkName: string, parameters: TagsObject, options?: VirtualNetworksUpdateTagsOptionalParams): Promise<VirtualNetworksUpdateTagsResponse>;
}

// @public
export interface VirtualNetworksCheckIPAddressAvailabilityOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksCheckIPAddressAvailabilityResponse = IPAddressAvailabilityResult;

// @public
export interface VirtualNetworksCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworksCreateOrUpdateResponse = VirtualNetwork;

// @public
export interface VirtualNetworksDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworksGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type VirtualNetworksGetResponse = VirtualNetwork;

// @public
export interface VirtualNetworksListAllNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListAllNextResponse = VirtualNetworkListResult;

// @public
export interface VirtualNetworksListAllOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListAllResponse = VirtualNetworkListResult;

// @public
export interface VirtualNetworksListDdosProtectionStatusNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListDdosProtectionStatusNextResponse = VirtualNetworkDdosProtectionStatusResult;

// @public
export interface VirtualNetworksListDdosProtectionStatusOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    skipToken?: string;
    top?: number;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworksListDdosProtectionStatusResponse = VirtualNetworkDdosProtectionStatusResult;

// @public
export interface VirtualNetworksListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListNextResponse = VirtualNetworkListResult;

// @public
export interface VirtualNetworksListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListResponse = VirtualNetworkListResult;

// @public
export interface VirtualNetworksListUsageNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListUsageNextResponse = VirtualNetworkListUsageResult;

// @public
export interface VirtualNetworksListUsageOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksListUsageResponse = VirtualNetworkListUsageResult;

// @public
export interface VirtualNetworksUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworksUpdateTagsResponse = VirtualNetwork;

// @public
export interface VirtualNetworkTap extends Resource {
    destinationLoadBalancerFrontEndIPConfiguration?: FrontendIPConfiguration;
    destinationNetworkInterfaceIPConfiguration?: NetworkInterfaceIPConfiguration;
    destinationPort?: number;
    readonly etag?: string;
    readonly networkInterfaceTapConfigurations?: NetworkInterfaceTapConfiguration[];
    readonly provisioningState?: ProvisioningState;
    readonly resourceGuid?: string;
}

// @public
export interface VirtualNetworkTapListResult {
    nextLink?: string;
    value?: VirtualNetworkTap[];
}

// @public
export interface VirtualNetworkTaps {
    beginCreateOrUpdate(resourceGroupName: string, tapName: string, parameters: VirtualNetworkTap, options?: VirtualNetworkTapsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualNetworkTapsCreateOrUpdateResponse>, VirtualNetworkTapsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, tapName: string, parameters: VirtualNetworkTap, options?: VirtualNetworkTapsCreateOrUpdateOptionalParams): Promise<VirtualNetworkTapsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, tapName: string, options?: VirtualNetworkTapsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, tapName: string, options?: VirtualNetworkTapsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, tapName: string, options?: VirtualNetworkTapsGetOptionalParams): Promise<VirtualNetworkTapsGetResponse>;
    listAll(options?: VirtualNetworkTapsListAllOptionalParams): PagedAsyncIterableIterator<VirtualNetworkTap>;
    listByResourceGroup(resourceGroupName: string, options?: VirtualNetworkTapsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VirtualNetworkTap>;
    updateTags(resourceGroupName: string, tapName: string, tapParameters: TagsObject, options?: VirtualNetworkTapsUpdateTagsOptionalParams): Promise<VirtualNetworkTapsUpdateTagsResponse>;
}

// @public
export interface VirtualNetworkTapsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualNetworkTapsCreateOrUpdateResponse = VirtualNetworkTap;

// @public
export interface VirtualNetworkTapsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualNetworkTapsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkTapsGetResponse = VirtualNetworkTap;

// @public
export interface VirtualNetworkTapsListAllNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkTapsListAllNextResponse = VirtualNetworkTapListResult;

// @public
export interface VirtualNetworkTapsListAllOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkTapsListAllResponse = VirtualNetworkTapListResult;

// @public
export interface VirtualNetworkTapsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkTapsListByResourceGroupNextResponse = VirtualNetworkTapListResult;

// @public
export interface VirtualNetworkTapsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkTapsListByResourceGroupResponse = VirtualNetworkTapListResult;

// @public
export interface VirtualNetworkTapsUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualNetworkTapsUpdateTagsResponse = VirtualNetworkTap;

// @public
export interface VirtualNetworkUsage {
    readonly currentValue?: number;
    readonly id?: string;
    readonly limit?: number;
    readonly name?: VirtualNetworkUsageName;
    readonly unit?: string;
}

// @public
export interface VirtualNetworkUsageName {
    readonly localizedValue?: string;
    readonly value?: string;
}

// @public
export interface VirtualRouter extends Resource {
    readonly etag?: string;
    hostedGateway?: SubResource;
    hostedSubnet?: SubResource;
    readonly peerings?: SubResource[];
    readonly provisioningState?: ProvisioningState;
    virtualRouterAsn?: number;
    virtualRouterIps?: string[];
}

// @public
export interface VirtualRouterAutoScaleConfiguration {
    minCapacity?: number;
}

// @public
export interface VirtualRouterListResult {
    nextLink?: string;
    value?: VirtualRouter[];
}

// @public
export interface VirtualRouterPeering extends SubResource {
    readonly etag?: string;
    name?: string;
    peerAsn?: number;
    peerIp?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface VirtualRouterPeeringListResult {
    nextLink?: string;
    value?: VirtualRouterPeering[];
}

// @public
export interface VirtualRouterPeerings {
    beginCreateOrUpdate(resourceGroupName: string, virtualRouterName: string, peeringName: string, parameters: VirtualRouterPeering, options?: VirtualRouterPeeringsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualRouterPeeringsCreateOrUpdateResponse>, VirtualRouterPeeringsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualRouterName: string, peeringName: string, parameters: VirtualRouterPeering, options?: VirtualRouterPeeringsCreateOrUpdateOptionalParams): Promise<VirtualRouterPeeringsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualRouterName: string, peeringName: string, options?: VirtualRouterPeeringsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualRouterName: string, peeringName: string, options?: VirtualRouterPeeringsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualRouterName: string, peeringName: string, options?: VirtualRouterPeeringsGetOptionalParams): Promise<VirtualRouterPeeringsGetResponse>;
    list(resourceGroupName: string, virtualRouterName: string, options?: VirtualRouterPeeringsListOptionalParams): PagedAsyncIterableIterator<VirtualRouterPeering>;
}

// @public
export interface VirtualRouterPeeringsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualRouterPeeringsCreateOrUpdateResponse = VirtualRouterPeering;

// @public
export interface VirtualRouterPeeringsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualRouterPeeringsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRouterPeeringsGetResponse = VirtualRouterPeering;

// @public
export interface VirtualRouterPeeringsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRouterPeeringsListNextResponse = VirtualRouterPeeringListResult;

// @public
export interface VirtualRouterPeeringsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRouterPeeringsListResponse = VirtualRouterPeeringListResult;

// @public
export interface VirtualRouters {
    beginCreateOrUpdate(resourceGroupName: string, virtualRouterName: string, parameters: VirtualRouter, options?: VirtualRoutersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualRoutersCreateOrUpdateResponse>, VirtualRoutersCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualRouterName: string, parameters: VirtualRouter, options?: VirtualRoutersCreateOrUpdateOptionalParams): Promise<VirtualRoutersCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualRouterName: string, options?: VirtualRoutersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualRouterName: string, options?: VirtualRoutersDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualRouterName: string, options?: VirtualRoutersGetOptionalParams): Promise<VirtualRoutersGetResponse>;
    list(options?: VirtualRoutersListOptionalParams): PagedAsyncIterableIterator<VirtualRouter>;
    listByResourceGroup(resourceGroupName: string, options?: VirtualRoutersListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VirtualRouter>;
}

// @public
export interface VirtualRoutersCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualRoutersCreateOrUpdateResponse = VirtualRouter;

// @public
export interface VirtualRoutersDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualRoutersGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type VirtualRoutersGetResponse = VirtualRouter;

// @public
export interface VirtualRoutersListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRoutersListByResourceGroupNextResponse = VirtualRouterListResult;

// @public
export interface VirtualRoutersListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRoutersListByResourceGroupResponse = VirtualRouterListResult;

// @public
export interface VirtualRoutersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRoutersListNextResponse = VirtualRouterListResult;

// @public
export interface VirtualRoutersListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualRoutersListResponse = VirtualRouterListResult;

// @public
export interface VirtualWAN extends Resource {
    allowBranchToBranchTraffic?: boolean;
    allowVnetToVnetTraffic?: boolean;
    disableVpnEncryption?: boolean;
    readonly etag?: string;
    readonly office365LocalBreakoutCategory?: OfficeTrafficCategory;
    readonly provisioningState?: ProvisioningState;
    typePropertiesType?: string;
    readonly virtualHubs?: SubResource[];
    readonly vpnSites?: SubResource[];
}

// @public
export interface VirtualWans {
    beginCreateOrUpdate(resourceGroupName: string, virtualWANName: string, wANParameters: VirtualWAN, options?: VirtualWansCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualWansCreateOrUpdateResponse>, VirtualWansCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualWANName: string, wANParameters: VirtualWAN, options?: VirtualWansCreateOrUpdateOptionalParams): Promise<VirtualWansCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, virtualWANName: string, options?: VirtualWansDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, virtualWANName: string, options?: VirtualWansDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, virtualWANName: string, options?: VirtualWansGetOptionalParams): Promise<VirtualWansGetResponse>;
    list(options?: VirtualWansListOptionalParams): PagedAsyncIterableIterator<VirtualWAN>;
    listByResourceGroup(resourceGroupName: string, options?: VirtualWansListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VirtualWAN>;
    updateTags(resourceGroupName: string, virtualWANName: string, wANParameters: TagsObject, options?: VirtualWansUpdateTagsOptionalParams): Promise<VirtualWansUpdateTagsResponse>;
}

// @public
export interface VirtualWansCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VirtualWansCreateOrUpdateResponse = VirtualWAN;

// @public
export interface VirtualWansDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VirtualWanSecurityProvider {
    name?: string;
    readonly type?: VirtualWanSecurityProviderType;
    url?: string;
}

// @public
export interface VirtualWanSecurityProviders {
    supportedProviders?: VirtualWanSecurityProvider[];
}

// @public
export type VirtualWanSecurityProviderType = string;

// @public
export interface VirtualWansGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualWansGetResponse = VirtualWAN;

// @public
export interface VirtualWansListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualWansListByResourceGroupNextResponse = ListVirtualWANsResult;

// @public
export interface VirtualWansListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualWansListByResourceGroupResponse = ListVirtualWANsResult;

// @public
export interface VirtualWansListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualWansListNextResponse = ListVirtualWANsResult;

// @public
export interface VirtualWansListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualWansListResponse = ListVirtualWANsResult;

// @public
export interface VirtualWansUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VirtualWansUpdateTagsResponse = VirtualWAN;

// @public
export interface VirtualWanVpnProfileParameters {
    authenticationMethod?: AuthenticationMethod;
    vpnServerConfigurationResourceId?: string;
}

// @public
export interface Vm extends Resource {
}

// @public
export type VnetLocalRouteOverrideCriteria = string;

// @public
export interface VnetRoute {
    readonly bgpConnections?: SubResource[];
    staticRoutes?: StaticRoute[];
    staticRoutesConfig?: StaticRoutesConfig;
}

// @public
export interface VngClientConnectionConfiguration extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    virtualNetworkGatewayPolicyGroups?: SubResource[];
    vpnClientAddressPool?: AddressSpace;
}

// @public
export type VpnAuthenticationType = string;

// @public
export interface VpnClientConfiguration {
    aadAudience?: string;
    aadIssuer?: string;
    aadTenant?: string;
    radiusServerAddress?: string;
    radiusServers?: RadiusServer[];
    radiusServerSecret?: string;
    vngClientConnectionConfigurations?: VngClientConnectionConfiguration[];
    vpnAuthenticationTypes?: VpnAuthenticationType[];
    vpnClientAddressPool?: AddressSpace;
    vpnClientIpsecPolicies?: IpsecPolicy[];
    vpnClientProtocols?: VpnClientProtocol[];
    vpnClientRevokedCertificates?: VpnClientRevokedCertificate[];
    vpnClientRootCertificates?: VpnClientRootCertificate[];
}

// @public
export interface VpnClientConnectionHealth {
    allocatedIpAddresses?: string[];
    readonly totalEgressBytesTransferred?: number;
    readonly totalIngressBytesTransferred?: number;
    vpnClientConnectionsCount?: number;
}

// @public
export interface VpnClientConnectionHealthDetail {
    readonly egressBytesTransferred?: number;
    readonly egressPacketsTransferred?: number;
    readonly ingressBytesTransferred?: number;
    readonly ingressPacketsTransferred?: number;
    readonly maxBandwidth?: number;
    readonly maxPacketsPerSecond?: number;
    readonly privateIpAddress?: string;
    readonly publicIpAddress?: string;
    readonly vpnConnectionDuration?: number;
    readonly vpnConnectionId?: string;
    readonly vpnConnectionTime?: string;
    readonly vpnUserName?: string;
}

// @public
export interface VpnClientConnectionHealthDetailListResult {
    value?: VpnClientConnectionHealthDetail[];
}

// @public
export interface VpnClientIPsecParameters {
    dhGroup: DhGroup;
    ikeEncryption: IkeEncryption;
    ikeIntegrity: IkeIntegrity;
    ipsecEncryption: IpsecEncryption;
    ipsecIntegrity: IpsecIntegrity;
    pfsGroup: PfsGroup;
    saDataSizeKilobytes: number;
    saLifeTimeSeconds: number;
}

// @public
export interface VpnClientParameters {
    authenticationMethod?: AuthenticationMethod;
    clientRootCertificates?: string[];
    processorArchitecture?: ProcessorArchitecture;
    radiusServerAuthCertificate?: string;
}

// @public
export type VpnClientProtocol = string;

// @public
export interface VpnClientRevokedCertificate extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    thumbprint?: string;
}

// @public
export interface VpnClientRootCertificate extends SubResource {
    readonly etag?: string;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    publicCertData: string;
}

// @public
export interface VpnConnection extends SubResource {
    connectionBandwidth?: number;
    readonly connectionStatus?: VpnConnectionStatus;
    dpdTimeoutSeconds?: number;
    readonly egressBytesTransferred?: number;
    enableBgp?: boolean;
    enableInternetSecurity?: boolean;
    enableRateLimiting?: boolean;
    readonly etag?: string;
    readonly ingressBytesTransferred?: number;
    ipsecPolicies?: IpsecPolicy[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    remoteVpnSite?: SubResource;
    routingConfiguration?: RoutingConfiguration;
    routingWeight?: number;
    sharedKey?: string;
    trafficSelectorPolicies?: TrafficSelectorPolicy[];
    useLocalAzureIpAddress?: boolean;
    usePolicyBasedTrafficSelectors?: boolean;
    vpnConnectionProtocolType?: VirtualNetworkGatewayConnectionProtocol;
    vpnLinkConnections?: VpnSiteLinkConnection[];
}

// @public
export interface VpnConnectionPacketCaptureStartParameters {
    filterData?: string;
    linkConnectionNames?: string[];
}

// @public
export interface VpnConnectionPacketCaptureStopParameters {
    linkConnectionNames?: string[];
    sasUrl?: string;
}

// @public
export interface VpnConnections {
    beginCreateOrUpdate(resourceGroupName: string, gatewayName: string, connectionName: string, vpnConnectionParameters: VpnConnection, options?: VpnConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VpnConnectionsCreateOrUpdateResponse>, VpnConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, gatewayName: string, connectionName: string, vpnConnectionParameters: VpnConnection, options?: VpnConnectionsCreateOrUpdateOptionalParams): Promise<VpnConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, gatewayName: string, connectionName: string, options?: VpnConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, gatewayName: string, connectionName: string, options?: VpnConnectionsDeleteOptionalParams): Promise<void>;
    beginStartPacketCapture(resourceGroupName: string, gatewayName: string, vpnConnectionName: string, options?: VpnConnectionsStartPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VpnConnectionsStartPacketCaptureResponse>, VpnConnectionsStartPacketCaptureResponse>>;
    beginStartPacketCaptureAndWait(resourceGroupName: string, gatewayName: string, vpnConnectionName: string, options?: VpnConnectionsStartPacketCaptureOptionalParams): Promise<VpnConnectionsStartPacketCaptureResponse>;
    beginStopPacketCapture(resourceGroupName: string, gatewayName: string, vpnConnectionName: string, options?: VpnConnectionsStopPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VpnConnectionsStopPacketCaptureResponse>, VpnConnectionsStopPacketCaptureResponse>>;
    beginStopPacketCaptureAndWait(resourceGroupName: string, gatewayName: string, vpnConnectionName: string, options?: VpnConnectionsStopPacketCaptureOptionalParams): Promise<VpnConnectionsStopPacketCaptureResponse>;
    get(resourceGroupName: string, gatewayName: string, connectionName: string, options?: VpnConnectionsGetOptionalParams): Promise<VpnConnectionsGetResponse>;
    listByVpnGateway(resourceGroupName: string, gatewayName: string, options?: VpnConnectionsListByVpnGatewayOptionalParams): PagedAsyncIterableIterator<VpnConnection>;
}

// @public
export interface VpnConnectionsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnConnectionsCreateOrUpdateResponse = VpnConnection;

// @public
export interface VpnConnectionsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VpnConnectionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnConnectionsGetResponse = VpnConnection;

// @public
export interface VpnConnectionsListByVpnGatewayNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnConnectionsListByVpnGatewayNextResponse = ListVpnConnectionsResult;

// @public
export interface VpnConnectionsListByVpnGatewayOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnConnectionsListByVpnGatewayResponse = ListVpnConnectionsResult;

// @public
export interface VpnConnectionsStartPacketCaptureOptionalParams extends coreClient.OperationOptions {
    parameters?: VpnConnectionPacketCaptureStartParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnConnectionsStartPacketCaptureResponse = {
    body: string;
};

// @public
export interface VpnConnectionsStopPacketCaptureOptionalParams extends coreClient.OperationOptions {
    parameters?: VpnConnectionPacketCaptureStopParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnConnectionsStopPacketCaptureResponse = {
    body: string;
};

// @public
export type VpnConnectionStatus = string;

// @public
export interface VpnDeviceScriptParameters {
    deviceFamily?: string;
    firmwareVersion?: string;
    vendor?: string;
}

// @public
export interface VpnGateway extends Resource {
    bgpSettings?: BgpSettings;
    connections?: VpnConnection[];
    enableBgpRouteTranslationForNat?: boolean;
    readonly etag?: string;
    readonly ipConfigurations?: VpnGatewayIpConfiguration[];
    isRoutingPreferenceInternet?: boolean;
    natRules?: VpnGatewayNatRule[];
    readonly provisioningState?: ProvisioningState;
    virtualHub?: SubResource;
    vpnGatewayScaleUnit?: number;
}

// @public
export type VpnGatewayGeneration = string;

// @public
export interface VpnGatewayIpConfiguration {
    id?: string;
    privateIpAddress?: string;
    publicIpAddress?: string;
}

// @public
export interface VpnGatewayNatRule extends SubResource {
    readonly egressVpnSiteLinkConnections?: SubResource[];
    readonly etag?: string;
    externalMappings?: VpnNatRuleMapping[];
    readonly ingressVpnSiteLinkConnections?: SubResource[];
    internalMappings?: VpnNatRuleMapping[];
    ipConfigurationId?: string;
    mode?: VpnNatRuleMode;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
    typePropertiesType?: VpnNatRuleType;
}

// @public
export interface VpnGatewayPacketCaptureStartParameters {
    filterData?: string;
}

// @public
export interface VpnGatewayPacketCaptureStopParameters {
    sasUrl?: string;
}

// @public
export interface VpnGateways {
    beginCreateOrUpdate(resourceGroupName: string, gatewayName: string, vpnGatewayParameters: VpnGateway, options?: VpnGatewaysCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VpnGatewaysCreateOrUpdateResponse>, VpnGatewaysCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, gatewayName: string, vpnGatewayParameters: VpnGateway, options?: VpnGatewaysCreateOrUpdateOptionalParams): Promise<VpnGatewaysCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysDeleteOptionalParams): Promise<void>;
    beginReset(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysResetOptionalParams): Promise<SimplePollerLike<OperationState<VpnGatewaysResetResponse>, VpnGatewaysResetResponse>>;
    beginResetAndWait(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysResetOptionalParams): Promise<VpnGatewaysResetResponse>;
    beginStartPacketCapture(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysStartPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VpnGatewaysStartPacketCaptureResponse>, VpnGatewaysStartPacketCaptureResponse>>;
    beginStartPacketCaptureAndWait(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysStartPacketCaptureOptionalParams): Promise<VpnGatewaysStartPacketCaptureResponse>;
    beginStopPacketCapture(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysStopPacketCaptureOptionalParams): Promise<SimplePollerLike<OperationState<VpnGatewaysStopPacketCaptureResponse>, VpnGatewaysStopPacketCaptureResponse>>;
    beginStopPacketCaptureAndWait(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysStopPacketCaptureOptionalParams): Promise<VpnGatewaysStopPacketCaptureResponse>;
    beginUpdateTags(resourceGroupName: string, gatewayName: string, vpnGatewayParameters: TagsObject, options?: VpnGatewaysUpdateTagsOptionalParams): Promise<SimplePollerLike<OperationState<VpnGatewaysUpdateTagsResponse>, VpnGatewaysUpdateTagsResponse>>;
    beginUpdateTagsAndWait(resourceGroupName: string, gatewayName: string, vpnGatewayParameters: TagsObject, options?: VpnGatewaysUpdateTagsOptionalParams): Promise<VpnGatewaysUpdateTagsResponse>;
    get(resourceGroupName: string, gatewayName: string, options?: VpnGatewaysGetOptionalParams): Promise<VpnGatewaysGetResponse>;
    list(options?: VpnGatewaysListOptionalParams): PagedAsyncIterableIterator<VpnGateway>;
    listByResourceGroup(resourceGroupName: string, options?: VpnGatewaysListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VpnGateway>;
}

// @public
export interface VpnGatewaysCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnGatewaysCreateOrUpdateResponse = VpnGateway;

// @public
export interface VpnGatewaysDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VpnGatewaysGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnGatewaysGetResponse = VpnGateway;

// @public
export interface VpnGatewaysListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnGatewaysListByResourceGroupNextResponse = ListVpnGatewaysResult;

// @public
export interface VpnGatewaysListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnGatewaysListByResourceGroupResponse = ListVpnGatewaysResult;

// @public
export interface VpnGatewaysListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnGatewaysListNextResponse = ListVpnGatewaysResult;

// @public
export interface VpnGatewaysListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnGatewaysListResponse = ListVpnGatewaysResult;

// @public
export interface VpnGatewaysResetOptionalParams extends coreClient.OperationOptions {
    ipConfigurationId?: string;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnGatewaysResetResponse = VpnGateway;

// @public
export interface VpnGatewaysStartPacketCaptureOptionalParams extends coreClient.OperationOptions {
    parameters?: VpnGatewayPacketCaptureStartParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnGatewaysStartPacketCaptureResponse = {
    body: string;
};

// @public
export interface VpnGatewaysStopPacketCaptureOptionalParams extends coreClient.OperationOptions {
    parameters?: VpnGatewayPacketCaptureStopParameters;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnGatewaysStopPacketCaptureResponse = {
    body: string;
};

// @public
export interface VpnGatewaysUpdateTagsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnGatewaysUpdateTagsResponse = VpnGateway;

// @public
export type VpnGatewayTunnelingProtocol = string;

// @public
export interface VpnLinkBgpSettings {
    asn?: number;
    bgpPeeringAddress?: string;
}

// @public
export type VpnLinkConnectionMode = string;

// @public
export interface VpnLinkConnections {
    beginGetIkeSas(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsGetIkeSasOptionalParams): Promise<SimplePollerLike<OperationState<VpnLinkConnectionsGetIkeSasResponse>, VpnLinkConnectionsGetIkeSasResponse>>;
    beginGetIkeSasAndWait(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsGetIkeSasOptionalParams): Promise<VpnLinkConnectionsGetIkeSasResponse>;
    beginResetConnection(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsResetConnectionOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginResetConnectionAndWait(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsResetConnectionOptionalParams): Promise<void>;
    beginSetOrInitDefaultSharedKey(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, connectionSharedKeyParameters: ConnectionSharedKeyResult, options?: VpnLinkConnectionsSetOrInitDefaultSharedKeyOptionalParams): Promise<SimplePollerLike<OperationState<VpnLinkConnectionsSetOrInitDefaultSharedKeyResponse>, VpnLinkConnectionsSetOrInitDefaultSharedKeyResponse>>;
    beginSetOrInitDefaultSharedKeyAndWait(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, connectionSharedKeyParameters: ConnectionSharedKeyResult, options?: VpnLinkConnectionsSetOrInitDefaultSharedKeyOptionalParams): Promise<VpnLinkConnectionsSetOrInitDefaultSharedKeyResponse>;
    getDefaultSharedKey(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsGetDefaultSharedKeyOptionalParams): Promise<VpnLinkConnectionsGetDefaultSharedKeyResponse>;
    listAllSharedKeys(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsGetAllSharedKeysOptionalParams): PagedAsyncIterableIterator<ConnectionSharedKeyResult>;
    listByVpnConnection(resourceGroupName: string, gatewayName: string, connectionName: string, options?: VpnLinkConnectionsListByVpnConnectionOptionalParams): PagedAsyncIterableIterator<VpnSiteLinkConnection>;
    listDefaultSharedKey(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnLinkConnectionsListDefaultSharedKeyOptionalParams): Promise<VpnLinkConnectionsListDefaultSharedKeyResponse>;
}

// @public
export interface VpnLinkConnectionsGetAllSharedKeysNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnLinkConnectionsGetAllSharedKeysNextResponse = ConnectionSharedKeyResultList;

// @public
export interface VpnLinkConnectionsGetAllSharedKeysOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnLinkConnectionsGetAllSharedKeysResponse = ConnectionSharedKeyResultList;

// @public
export interface VpnLinkConnectionsGetDefaultSharedKeyOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnLinkConnectionsGetDefaultSharedKeyResponse = ConnectionSharedKeyResult;

// @public
export interface VpnLinkConnectionsGetIkeSasOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnLinkConnectionsGetIkeSasResponse = {
    body: string;
};

// @public
export interface VpnLinkConnectionsListByVpnConnectionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnLinkConnectionsListByVpnConnectionNextResponse = ListVpnSiteLinkConnectionsResult;

// @public
export interface VpnLinkConnectionsListByVpnConnectionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnLinkConnectionsListByVpnConnectionResponse = ListVpnSiteLinkConnectionsResult;

// @public
export interface VpnLinkConnectionsListDefaultSharedKeyOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnLinkConnectionsListDefaultSharedKeyResponse = ConnectionSharedKeyResult;

// @public
export interface VpnLinkConnectionsResetConnectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VpnLinkConnectionsSetOrInitDefaultSharedKeyOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnLinkConnectionsSetOrInitDefaultSharedKeyResponse = ConnectionSharedKeyResult;

// @public
export interface VpnLinkProviderProperties {
    linkProviderName?: string;
    linkSpeedInMbps?: number;
}

// @public
export interface VpnNatRuleMapping {
    addressSpace?: string;
    portRange?: string;
}

// @public
export type VpnNatRuleMode = string;

// @public
export type VpnNatRuleType = string;

// @public
export interface VpnPacketCaptureStartParameters {
    filterData?: string;
}

// @public
export interface VpnPacketCaptureStopParameters {
    sasUrl?: string;
}

// @public
export type VpnPolicyMemberAttributeType = string;

// @public
export interface VpnProfileResponse {
    profileUrl?: string;
}

// @public
export interface VpnServerConfigRadiusClientRootCertificate {
    name?: string;
    thumbprint?: string;
}

// @public
export interface VpnServerConfigRadiusServerRootCertificate {
    name?: string;
    publicCertData?: string;
}

// @public
export interface VpnServerConfiguration extends Resource {
    aadAuthenticationParameters?: AadAuthenticationParameters;
    configurationPolicyGroups?: VpnServerConfigurationPolicyGroup[];
    readonly etag?: string;
    readonly etagPropertiesEtag?: string;
    namePropertiesName?: string;
    readonly p2SVpnGateways?: P2SVpnGateway[];
    readonly provisioningState?: string;
    radiusClientRootCertificates?: VpnServerConfigRadiusClientRootCertificate[];
    radiusServerAddress?: string;
    radiusServerRootCertificates?: VpnServerConfigRadiusServerRootCertificate[];
    radiusServers?: RadiusServer[];
    radiusServerSecret?: string;
    vpnAuthenticationTypes?: VpnAuthenticationType[];
    vpnClientIpsecPolicies?: IpsecPolicy[];
    vpnClientRevokedCertificates?: VpnServerConfigVpnClientRevokedCertificate[];
    vpnClientRootCertificates?: VpnServerConfigVpnClientRootCertificate[];
    vpnProtocols?: VpnGatewayTunnelingProtocol[];
}

// @public
export interface VpnServerConfigurationPolicyGroup extends SubResource {
    readonly etag?: string;
    isDefault?: boolean;
    name?: string;
    readonly p2SConnectionConfigurations?: SubResource[];
    policyMembers?: VpnServerConfigurationPolicyGroupMember[];
    priority?: number;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface VpnServerConfigurationPolicyGroupMember {
    attributeType?: VpnPolicyMemberAttributeType;
    attributeValue?: string;
    name?: string;
}

// @public
export interface VpnServerConfigurations {
    beginCreateOrUpdate(resourceGroupName: string, vpnServerConfigurationName: string, vpnServerConfigurationParameters: VpnServerConfiguration, options?: VpnServerConfigurationsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VpnServerConfigurationsCreateOrUpdateResponse>, VpnServerConfigurationsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, vpnServerConfigurationName: string, vpnServerConfigurationParameters: VpnServerConfiguration, options?: VpnServerConfigurationsCreateOrUpdateOptionalParams): Promise<VpnServerConfigurationsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, vpnServerConfigurationName: string, options?: VpnServerConfigurationsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, vpnServerConfigurationName: string, options?: VpnServerConfigurationsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, vpnServerConfigurationName: string, options?: VpnServerConfigurationsGetOptionalParams): Promise<VpnServerConfigurationsGetResponse>;
    list(options?: VpnServerConfigurationsListOptionalParams): PagedAsyncIterableIterator<VpnServerConfiguration>;
    listByResourceGroup(resourceGroupName: string, options?: VpnServerConfigurationsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VpnServerConfiguration>;
    updateTags(resourceGroupName: string, vpnServerConfigurationName: string, vpnServerConfigurationParameters: TagsObject, options?: VpnServerConfigurationsUpdateTagsOptionalParams): Promise<VpnServerConfigurationsUpdateTagsResponse>;
}

// @public
export interface VpnServerConfigurationsAssociatedWithVirtualWan {
    beginList(resourceGroupName: string, virtualWANName: string, options?: VpnServerConfigurationsAssociatedWithVirtualWanListOptionalParams): Promise<SimplePollerLike<OperationState<VpnServerConfigurationsAssociatedWithVirtualWanListResponse>, VpnServerConfigurationsAssociatedWithVirtualWanListResponse>>;
    beginListAndWait(resourceGroupName: string, virtualWANName: string, options?: VpnServerConfigurationsAssociatedWithVirtualWanListOptionalParams): Promise<VpnServerConfigurationsAssociatedWithVirtualWanListResponse>;
}

// @public
export interface VpnServerConfigurationsAssociatedWithVirtualWanListOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnServerConfigurationsAssociatedWithVirtualWanListResponse = VpnServerConfigurationsResponse;

// @public
export interface VpnServerConfigurationsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnServerConfigurationsCreateOrUpdateResponse = VpnServerConfiguration;

// @public
export interface VpnServerConfigurationsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VpnServerConfigurationsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnServerConfigurationsGetResponse = VpnServerConfiguration;

// @public
export interface VpnServerConfigurationsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnServerConfigurationsListByResourceGroupNextResponse = ListVpnServerConfigurationsResult;

// @public
export interface VpnServerConfigurationsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnServerConfigurationsListByResourceGroupResponse = ListVpnServerConfigurationsResult;

// @public
export interface VpnServerConfigurationsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnServerConfigurationsListNextResponse = ListVpnServerConfigurationsResult;

// @public
export interface VpnServerConfigurationsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnServerConfigurationsListResponse = ListVpnServerConfigurationsResult;

// @public
export interface VpnServerConfigurationsResponse {
    vpnServerConfigurationResourceIds?: string[];
}

// @public
export interface VpnServerConfigurationsUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnServerConfigurationsUpdateTagsResponse = VpnServerConfiguration;

// @public
export interface VpnServerConfigVpnClientRevokedCertificate {
    name?: string;
    thumbprint?: string;
}

// @public
export interface VpnServerConfigVpnClientRootCertificate {
    name?: string;
    publicCertData?: string;
}

// @public
export interface VpnSite extends Resource {
    addressSpace?: AddressSpace;
    bgpProperties?: BgpSettings;
    deviceProperties?: DeviceProperties;
    readonly etag?: string;
    ipAddress?: string;
    isSecuritySite?: boolean;
    o365Policy?: O365PolicyProperties;
    readonly provisioningState?: ProvisioningState;
    siteKey?: string;
    virtualWan?: SubResource;
    vpnSiteLinks?: VpnSiteLink[];
}

// @public
export interface VpnSiteId {
    readonly vpnSite?: string;
}

// @public
export interface VpnSiteLink extends SubResource {
    bgpProperties?: VpnLinkBgpSettings;
    readonly etag?: string;
    fqdn?: string;
    ipAddress?: string;
    linkProperties?: VpnLinkProviderProperties;
    name?: string;
    readonly provisioningState?: ProvisioningState;
    readonly type?: string;
}

// @public
export interface VpnSiteLinkConnection extends SubResource {
    connectionBandwidth?: number;
    readonly connectionStatus?: VpnConnectionStatus;
    dpdTimeoutSeconds?: number;
    readonly egressBytesTransferred?: number;
    egressNatRules?: SubResource[];
    enableBgp?: boolean;
    enableRateLimiting?: boolean;
    readonly etag?: string;
    readonly ingressBytesTransferred?: number;
    ingressNatRules?: SubResource[];
    ipsecPolicies?: IpsecPolicy[];
    name?: string;
    readonly provisioningState?: ProvisioningState;
    routingWeight?: number;
    sharedKey?: string;
    readonly type?: string;
    useLocalAzureIpAddress?: boolean;
    usePolicyBasedTrafficSelectors?: boolean;
    vpnConnectionProtocolType?: VirtualNetworkGatewayConnectionProtocol;
    vpnGatewayCustomBgpAddresses?: GatewayCustomBgpIpAddressIpConfiguration[];
    vpnLinkConnectionMode?: VpnLinkConnectionMode;
    vpnSiteLink?: SubResource;
}

// @public
export interface VpnSiteLinkConnections {
    get(resourceGroupName: string, gatewayName: string, connectionName: string, linkConnectionName: string, options?: VpnSiteLinkConnectionsGetOptionalParams): Promise<VpnSiteLinkConnectionsGetResponse>;
}

// @public
export interface VpnSiteLinkConnectionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSiteLinkConnectionsGetResponse = VpnSiteLinkConnection;

// @public
export interface VpnSiteLinks {
    get(resourceGroupName: string, vpnSiteName: string, vpnSiteLinkName: string, options?: VpnSiteLinksGetOptionalParams): Promise<VpnSiteLinksGetResponse>;
    listByVpnSite(resourceGroupName: string, vpnSiteName: string, options?: VpnSiteLinksListByVpnSiteOptionalParams): PagedAsyncIterableIterator<VpnSiteLink>;
}

// @public
export interface VpnSiteLinksGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSiteLinksGetResponse = VpnSiteLink;

// @public
export interface VpnSiteLinksListByVpnSiteNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSiteLinksListByVpnSiteNextResponse = ListVpnSiteLinksResult;

// @public
export interface VpnSiteLinksListByVpnSiteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSiteLinksListByVpnSiteResponse = ListVpnSiteLinksResult;

// @public
export interface VpnSites {
    beginCreateOrUpdate(resourceGroupName: string, vpnSiteName: string, vpnSiteParameters: VpnSite, options?: VpnSitesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VpnSitesCreateOrUpdateResponse>, VpnSitesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, vpnSiteName: string, vpnSiteParameters: VpnSite, options?: VpnSitesCreateOrUpdateOptionalParams): Promise<VpnSitesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, vpnSiteName: string, options?: VpnSitesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, vpnSiteName: string, options?: VpnSitesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, vpnSiteName: string, options?: VpnSitesGetOptionalParams): Promise<VpnSitesGetResponse>;
    list(options?: VpnSitesListOptionalParams): PagedAsyncIterableIterator<VpnSite>;
    listByResourceGroup(resourceGroupName: string, options?: VpnSitesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<VpnSite>;
    updateTags(resourceGroupName: string, vpnSiteName: string, vpnSiteParameters: TagsObject, options?: VpnSitesUpdateTagsOptionalParams): Promise<VpnSitesUpdateTagsResponse>;
}

// @public
export interface VpnSitesConfiguration {
    beginDownload(resourceGroupName: string, virtualWANName: string, request: GetVpnSitesConfigurationRequest, options?: VpnSitesConfigurationDownloadOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDownloadAndWait(resourceGroupName: string, virtualWANName: string, request: GetVpnSitesConfigurationRequest, options?: VpnSitesConfigurationDownloadOptionalParams): Promise<void>;
}

// @public
export interface VpnSitesConfigurationDownloadOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VpnSitesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type VpnSitesCreateOrUpdateResponse = VpnSite;

// @public
export interface VpnSitesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface VpnSitesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSitesGetResponse = VpnSite;

// @public
export interface VpnSitesListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSitesListByResourceGroupNextResponse = ListVpnSitesResult;

// @public
export interface VpnSitesListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSitesListByResourceGroupResponse = ListVpnSitesResult;

// @public
export interface VpnSitesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSitesListNextResponse = ListVpnSitesResult;

// @public
export interface VpnSitesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSitesListResponse = ListVpnSitesResult;

// @public
export interface VpnSitesUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VpnSitesUpdateTagsResponse = VpnSite;

// @public
export type VpnType = string;

// @public
export type WebApplicationFirewallAction = string;

// @public
export interface WebApplicationFirewallCustomRule {
    action: WebApplicationFirewallAction;
    readonly etag?: string;
    groupByUserSession?: GroupByUserSession[];
    matchConditions: MatchCondition[];
    name?: string;
    priority: number;
    rateLimitDuration?: ApplicationGatewayFirewallRateLimitDuration;
    rateLimitThreshold?: number;
    ruleType: WebApplicationFirewallRuleType;
    state?: WebApplicationFirewallState;
}

// @public
export type WebApplicationFirewallEnabledState = string;

// @public
export type WebApplicationFirewallMatchVariable = string;

// @public
export type WebApplicationFirewallMode = string;

// @public
export type WebApplicationFirewallOperator = string;

// @public
export interface WebApplicationFirewallPolicies {
    beginDelete(resourceGroupName: string, policyName: string, options?: WebApplicationFirewallPoliciesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, policyName: string, options?: WebApplicationFirewallPoliciesDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, policyName: string, parameters: WebApplicationFirewallPolicy, options?: WebApplicationFirewallPoliciesCreateOrUpdateOptionalParams): Promise<WebApplicationFirewallPoliciesCreateOrUpdateResponse>;
    get(resourceGroupName: string, policyName: string, options?: WebApplicationFirewallPoliciesGetOptionalParams): Promise<WebApplicationFirewallPoliciesGetResponse>;
    list(resourceGroupName: string, options?: WebApplicationFirewallPoliciesListOptionalParams): PagedAsyncIterableIterator<WebApplicationFirewallPolicy>;
    listAll(options?: WebApplicationFirewallPoliciesListAllOptionalParams): PagedAsyncIterableIterator<WebApplicationFirewallPolicy>;
}

// @public
export interface WebApplicationFirewallPoliciesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebApplicationFirewallPoliciesCreateOrUpdateResponse = WebApplicationFirewallPolicy;

// @public
export interface WebApplicationFirewallPoliciesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface WebApplicationFirewallPoliciesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebApplicationFirewallPoliciesGetResponse = WebApplicationFirewallPolicy;

// @public
export interface WebApplicationFirewallPoliciesListAllNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebApplicationFirewallPoliciesListAllNextResponse = WebApplicationFirewallPolicyListResult;

// @public
export interface WebApplicationFirewallPoliciesListAllOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebApplicationFirewallPoliciesListAllResponse = WebApplicationFirewallPolicyListResult;

// @public
export interface WebApplicationFirewallPoliciesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebApplicationFirewallPoliciesListNextResponse = WebApplicationFirewallPolicyListResult;

// @public
export interface WebApplicationFirewallPoliciesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebApplicationFirewallPoliciesListResponse = WebApplicationFirewallPolicyListResult;

// @public
export interface WebApplicationFirewallPolicy extends Resource {
    readonly applicationGatewayForContainers?: ApplicationGatewayForContainersReferenceDefinition[];
    readonly applicationGateways?: ApplicationGateway[];
    customRules?: WebApplicationFirewallCustomRule[];
    readonly etag?: string;
    readonly httpListeners?: SubResource[];
    managedRules?: ManagedRulesDefinition;
    readonly pathBasedRules?: SubResource[];
    policySettings?: PolicySettings;
    readonly provisioningState?: ProvisioningState;
    readonly resourceState?: WebApplicationFirewallPolicyResourceState;
}

// @public
export interface WebApplicationFirewallPolicyListResult {
    readonly nextLink?: string;
    readonly value?: WebApplicationFirewallPolicy[];
}

// @public
export type WebApplicationFirewallPolicyResourceState = string;

// @public
export type WebApplicationFirewallRuleType = string;

// @public
export interface WebApplicationFirewallScrubbingRules {
    matchVariable: ScrubbingRuleEntryMatchVariable;
    selector?: string;
    selectorMatchOperator: ScrubbingRuleEntryMatchOperator;
    state?: ScrubbingRuleEntryState;
}

// @public
export type WebApplicationFirewallScrubbingState = string;

// @public
export type WebApplicationFirewallState = string;

// @public
export type WebApplicationFirewallTransform = string;

// @public
export interface WebCategories {
    get(name: string, options?: WebCategoriesGetOptionalParams): Promise<WebCategoriesGetResponse>;
    listBySubscription(options?: WebCategoriesListBySubscriptionOptionalParams): PagedAsyncIterableIterator<AzureWebCategory>;
}

// @public
export interface WebCategoriesGetOptionalParams extends coreClient.OperationOptions {
    expand?: string;
}

// @public
export type WebCategoriesGetResponse = AzureWebCategory;

// @public
export interface WebCategoriesListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebCategoriesListBySubscriptionNextResponse = AzureWebCategoryListResult;

// @public
export interface WebCategoriesListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type WebCategoriesListBySubscriptionResponse = AzureWebCategoryListResult;

// (No @packageDocumentation comment for this package)

```
