virtualwans

package
v0.20240612.1084144 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 12, 2024 License: MPL-2.0 Imports: 15 Imported by: 1

README ¶

github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-11-01/virtualwans Documentation

The virtualwans SDK allows for interaction with the Azure Resource Manager Service network (API Version 2023-11-01).

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

Import Path

import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
import "github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-11-01/virtualwans"

Client Initialization

client := virtualwans.NewVirtualWANsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: VirtualWANsClient.ConfigurationPolicyGroupsCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewConfigurationPolicyGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnServerConfigurationValue", "configurationPolicyGroupValue")

payload := virtualwans.VpnServerConfigurationPolicyGroup{
	// ...
}


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

Example Usage: VirtualWANsClient.ConfigurationPolicyGroupsDelete

ctx := context.TODO()
id := virtualwans.NewConfigurationPolicyGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnServerConfigurationValue", "configurationPolicyGroupValue")

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

Example Usage: VirtualWANsClient.ConfigurationPolicyGroupsGet

ctx := context.TODO()
id := virtualwans.NewConfigurationPolicyGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnServerConfigurationValue", "configurationPolicyGroupValue")

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

Example Usage: VirtualWANsClient.ConfigurationPolicyGroupsListByVpnServerConfiguration

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

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

Example Usage: VirtualWANsClient.Generatevirtualwanvpnserverconfigurationvpnprofile

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

payload := virtualwans.VirtualWanVpnProfileParameters{
	// ...
}


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

Example Usage: VirtualWANsClient.HubRouteTablesCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewHubRouteTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "hubRouteTableValue")

payload := virtualwans.HubRouteTable{
	// ...
}


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

Example Usage: VirtualWANsClient.HubRouteTablesDelete

ctx := context.TODO()
id := virtualwans.NewHubRouteTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "hubRouteTableValue")

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

Example Usage: VirtualWANsClient.HubRouteTablesGet

ctx := context.TODO()
id := virtualwans.NewHubRouteTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "hubRouteTableValue")

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

Example Usage: VirtualWANsClient.HubRouteTablesList

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

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

Example Usage: VirtualWANsClient.HubVirtualNetworkConnectionsCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewHubVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "hubVirtualNetworkConnectionValue")

payload := virtualwans.HubVirtualNetworkConnection{
	// ...
}


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

Example Usage: VirtualWANsClient.HubVirtualNetworkConnectionsDelete

ctx := context.TODO()
id := virtualwans.NewHubVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "hubVirtualNetworkConnectionValue")

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

Example Usage: VirtualWANsClient.HubVirtualNetworkConnectionsGet

ctx := context.TODO()
id := virtualwans.NewHubVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "hubVirtualNetworkConnectionValue")

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

Example Usage: VirtualWANsClient.HubVirtualNetworkConnectionsList

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

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

Example Usage: VirtualWANsClient.NatRulesCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewNatRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnGatewayValue", "natRuleValue")

payload := virtualwans.VpnGatewayNatRule{
	// ...
}


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

Example Usage: VirtualWANsClient.NatRulesDelete

ctx := context.TODO()
id := virtualwans.NewNatRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnGatewayValue", "natRuleValue")

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

Example Usage: VirtualWANsClient.NatRulesGet

ctx := context.TODO()
id := virtualwans.NewNatRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnGatewayValue", "natRuleValue")

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

Example Usage: VirtualWANsClient.NatRulesListByVpnGateway

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

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

Example Usage: VirtualWANsClient.NetworkVirtualApplianceConnectionsCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewNetworkVirtualApplianceConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "networkVirtualApplianceValue", "networkVirtualApplianceConnectionValue")

payload := virtualwans.NetworkVirtualApplianceConnection{
	// ...
}


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

Example Usage: VirtualWANsClient.NetworkVirtualApplianceConnectionsDelete

ctx := context.TODO()
id := virtualwans.NewNetworkVirtualApplianceConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "networkVirtualApplianceValue", "networkVirtualApplianceConnectionValue")

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

Example Usage: VirtualWANsClient.NetworkVirtualApplianceConnectionsGet

ctx := context.TODO()
id := virtualwans.NewNetworkVirtualApplianceConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "networkVirtualApplianceValue", "networkVirtualApplianceConnectionValue")

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

Example Usage: VirtualWANsClient.NetworkVirtualApplianceConnectionsList

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

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

Example Usage: VirtualWANsClient.P2sVpnGatewaysCreateOrUpdate

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

payload := virtualwans.P2SVpnGateway{
	// ...
}


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

Example Usage: VirtualWANsClient.P2sVpnGatewaysDelete

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

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

Example Usage: VirtualWANsClient.P2sVpnGatewaysGet

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

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

Example Usage: VirtualWANsClient.P2sVpnGatewaysList

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

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

Example Usage: VirtualWANsClient.P2sVpnGatewaysListByResourceGroup

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

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

Example Usage: VirtualWANsClient.RouteMapsCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewRouteMapID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routeMapValue")

payload := virtualwans.RouteMap{
	// ...
}


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

Example Usage: VirtualWANsClient.RouteMapsDelete

ctx := context.TODO()
id := virtualwans.NewRouteMapID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routeMapValue")

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

Example Usage: VirtualWANsClient.RouteMapsGet

ctx := context.TODO()
id := virtualwans.NewRouteMapID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routeMapValue")

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

Example Usage: VirtualWANsClient.RouteMapsList

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

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

Example Usage: VirtualWANsClient.RoutingIntentCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewRoutingIntentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routingIntentValue")

payload := virtualwans.RoutingIntent{
	// ...
}


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

Example Usage: VirtualWANsClient.RoutingIntentDelete

ctx := context.TODO()
id := virtualwans.NewRoutingIntentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routingIntentValue")

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

Example Usage: VirtualWANsClient.RoutingIntentGet

ctx := context.TODO()
id := virtualwans.NewRoutingIntentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routingIntentValue")

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

Example Usage: VirtualWANsClient.RoutingIntentList

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

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

Example Usage: VirtualWANsClient.SupportedSecurityProviders

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

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

Example Usage: VirtualWANsClient.UpdateTags

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

payload := virtualwans.TagsObject{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubBgpConnectionCreateOrUpdate

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

payload := virtualwans.BgpConnection{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubBgpConnectionDelete

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

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

Example Usage: VirtualWANsClient.VirtualHubBgpConnectionGet

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

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

Example Usage: VirtualWANsClient.VirtualHubBgpConnectionsList

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

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

Example Usage: VirtualWANsClient.VirtualHubBgpConnectionsListAdvertisedRoutes

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

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

Example Usage: VirtualWANsClient.VirtualHubBgpConnectionsListLearnedRoutes

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

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

Example Usage: VirtualWANsClient.VirtualHubIPConfigurationCreateOrUpdate

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

payload := virtualwans.HubIPConfiguration{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubIPConfigurationDelete

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

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

Example Usage: VirtualWANsClient.VirtualHubIPConfigurationGet

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

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

Example Usage: VirtualWANsClient.VirtualHubIPConfigurationList

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

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

Example Usage: VirtualWANsClient.VirtualHubRouteTableV2sCreateOrUpdate

ctx := context.TODO()
id := virtualwans.NewVirtualHubRouteTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routeTableValue")

payload := virtualwans.VirtualHubRouteTableV2{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubRouteTableV2sDelete

ctx := context.TODO()
id := virtualwans.NewVirtualHubRouteTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routeTableValue")

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

Example Usage: VirtualWANsClient.VirtualHubRouteTableV2sGet

ctx := context.TODO()
id := virtualwans.NewVirtualHubRouteTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualHubValue", "routeTableValue")

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

Example Usage: VirtualWANsClient.VirtualHubRouteTableV2sList

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

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

Example Usage: VirtualWANsClient.VirtualHubsCreateOrUpdate

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

payload := virtualwans.VirtualHub{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubsDelete

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

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

Example Usage: VirtualWANsClient.VirtualHubsGet

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

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

Example Usage: VirtualWANsClient.VirtualHubsGetEffectiveVirtualHubRoutes

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

payload := virtualwans.EffectiveRoutesParameters{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubsGetInboundRoutes

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

payload := virtualwans.GetInboundRoutesParameters{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubsGetOutboundRoutes

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

payload := virtualwans.GetOutboundRoutesParameters{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualHubsList

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

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

Example Usage: VirtualWANsClient.VirtualHubsListByResourceGroup

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

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

Example Usage: VirtualWANsClient.VirtualHubsUpdateTags

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

payload := virtualwans.TagsObject{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualWansCreateOrUpdate

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

payload := virtualwans.VirtualWAN{
	// ...
}


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

Example Usage: VirtualWANsClient.VirtualWansDelete

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

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

Example Usage: VirtualWANsClient.VirtualWansGet

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

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

Example Usage: VirtualWANsClient.VirtualWansList

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

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

Example Usage: VirtualWANsClient.VirtualWansListByResourceGroup

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

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

Example Usage: VirtualWANsClient.VpnConnectionsCreateOrUpdate

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

payload := virtualwans.VpnConnection{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnConnectionsDelete

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

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

Example Usage: VirtualWANsClient.VpnConnectionsGet

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

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

Example Usage: VirtualWANsClient.VpnConnectionsListByVpnGateway

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

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

Example Usage: VirtualWANsClient.VpnConnectionsStartPacketCapture

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

payload := virtualwans.VpnConnectionPacketCaptureStartParameters{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnConnectionsStopPacketCapture

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

payload := virtualwans.VpnConnectionPacketCaptureStopParameters{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnGatewaysCreateOrUpdate

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

payload := virtualwans.VpnGateway{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnGatewaysDelete

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

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

Example Usage: VirtualWANsClient.VpnGatewaysGet

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

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

Example Usage: VirtualWANsClient.VpnGatewaysList

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

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

Example Usage: VirtualWANsClient.VpnGatewaysListByResourceGroup

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

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

Example Usage: VirtualWANsClient.VpnLinkConnectionsGetIkeSas

ctx := context.TODO()
id := virtualwans.NewVpnLinkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnGatewayValue", "vpnConnectionValue", "vpnLinkConnectionValue")

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

Example Usage: VirtualWANsClient.VpnLinkConnectionsListByVpnConnection

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

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

Example Usage: VirtualWANsClient.VpnServerConfigurationsAssociatedWithVirtualWanList

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

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

Example Usage: VirtualWANsClient.VpnServerConfigurationsCreateOrUpdate

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

payload := virtualwans.VpnServerConfiguration{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnServerConfigurationsDelete

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

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

Example Usage: VirtualWANsClient.VpnServerConfigurationsGet

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

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

Example Usage: VirtualWANsClient.VpnServerConfigurationsList

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

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

Example Usage: VirtualWANsClient.VpnServerConfigurationsListByResourceGroup

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

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

Example Usage: VirtualWANsClient.VpnSiteLinkConnectionsGet

ctx := context.TODO()
id := virtualwans.NewVpnLinkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnGatewayValue", "vpnConnectionValue", "vpnLinkConnectionValue")

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

Example Usage: VirtualWANsClient.VpnSiteLinksGet

ctx := context.TODO()
id := virtualwans.NewVpnSiteLinkID("12345678-1234-9876-4563-123456789012", "example-resource-group", "vpnSiteValue", "vpnSiteLinkValue")

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

Example Usage: VirtualWANsClient.VpnSiteLinksListByVpnSite

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

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

Example Usage: VirtualWANsClient.VpnSitesConfigurationDownload

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

payload := virtualwans.GetVpnSitesConfigurationRequest{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnSitesCreateOrUpdate

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

payload := virtualwans.VpnSite{
	// ...
}


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

Example Usage: VirtualWANsClient.VpnSitesDelete

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

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

Example Usage: VirtualWANsClient.VpnSitesGet

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

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

Example Usage: VirtualWANsClient.VpnSitesList

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

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

Example Usage: VirtualWANsClient.VpnSitesListByResourceGroup

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

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

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func PossibleValuesForAuthenticationMethod ¶ 

func PossibleValuesForAuthenticationMethod() []string

func PossibleValuesForDdosSettingsProtectionMode ¶ 

func PossibleValuesForDdosSettingsProtectionMode() []string

func PossibleValuesForDeleteOptions ¶ 

func PossibleValuesForDeleteOptions() []string

func PossibleValuesForDhGroup ¶ 

func PossibleValuesForDhGroup() []string

func PossibleValuesForFlowLogFormatType ¶ 

func PossibleValuesForFlowLogFormatType() []string

func PossibleValuesForGatewayLoadBalancerTunnelInterfaceType ¶ 

func PossibleValuesForGatewayLoadBalancerTunnelInterfaceType() []string

func PossibleValuesForGatewayLoadBalancerTunnelProtocol ¶ 

func PossibleValuesForGatewayLoadBalancerTunnelProtocol() []string

func PossibleValuesForHubBgpConnectionStatus ¶ 

func PossibleValuesForHubBgpConnectionStatus() []string

func PossibleValuesForHubRoutingPreference ¶ 

func PossibleValuesForHubRoutingPreference() []string

func PossibleValuesForIPAllocationMethod ¶ 

func PossibleValuesForIPAllocationMethod() []string

func PossibleValuesForIPVersion ¶ 

func PossibleValuesForIPVersion() []string

func PossibleValuesForIPsecEncryption ¶ 

func PossibleValuesForIPsecEncryption() []string

func PossibleValuesForIPsecIntegrity ¶ 

func PossibleValuesForIPsecIntegrity() []string

func PossibleValuesForIkeEncryption ¶ 

func PossibleValuesForIkeEncryption() []string

func PossibleValuesForIkeIntegrity ¶ 

func PossibleValuesForIkeIntegrity() []string

func PossibleValuesForLoadBalancerBackendAddressAdminState ¶ 

func PossibleValuesForLoadBalancerBackendAddressAdminState() []string

func PossibleValuesForNatGatewaySkuName ¶ 

func PossibleValuesForNatGatewaySkuName() []string

func PossibleValuesForNetworkInterfaceAuxiliaryMode ¶ 

func PossibleValuesForNetworkInterfaceAuxiliaryMode() []string

func PossibleValuesForNetworkInterfaceAuxiliarySku ¶ 

func PossibleValuesForNetworkInterfaceAuxiliarySku() []string

func PossibleValuesForNetworkInterfaceMigrationPhase ¶ 

func PossibleValuesForNetworkInterfaceMigrationPhase() []string

func PossibleValuesForNetworkInterfaceNicType ¶ 

func PossibleValuesForNetworkInterfaceNicType() []string

func PossibleValuesForNextStep ¶ 

func PossibleValuesForNextStep() []string

func PossibleValuesForOfficeTrafficCategory ¶ 

func PossibleValuesForOfficeTrafficCategory() []string

func PossibleValuesForPfsGroup ¶ 

func PossibleValuesForPfsGroup() []string

func PossibleValuesForPreferredRoutingGateway ¶ 

func PossibleValuesForPreferredRoutingGateway() []string

func PossibleValuesForProvisioningState ¶ 

func PossibleValuesForProvisioningState() []string

func PossibleValuesForPublicIPAddressDnsSettingsDomainNameLabelScope ¶ 

func PossibleValuesForPublicIPAddressDnsSettingsDomainNameLabelScope() []string

func PossibleValuesForPublicIPAddressMigrationPhase ¶ 

func PossibleValuesForPublicIPAddressMigrationPhase() []string

func PossibleValuesForPublicIPAddressSkuName ¶ 

func PossibleValuesForPublicIPAddressSkuName() []string

func PossibleValuesForPublicIPAddressSkuTier ¶ 

func PossibleValuesForPublicIPAddressSkuTier() []string

func PossibleValuesForRouteMapActionType ¶ 

func PossibleValuesForRouteMapActionType() []string

func PossibleValuesForRouteMapMatchCondition ¶ 

func PossibleValuesForRouteMapMatchCondition() []string

func PossibleValuesForRouteNextHopType ¶ 

func PossibleValuesForRouteNextHopType() []string

func PossibleValuesForRoutingState ¶ 

func PossibleValuesForRoutingState() []string

func PossibleValuesForSecurityRuleAccess ¶ 

func PossibleValuesForSecurityRuleAccess() []string

func PossibleValuesForSecurityRuleDirection ¶ 

func PossibleValuesForSecurityRuleDirection() []string

func PossibleValuesForSecurityRuleProtocol ¶ 

func PossibleValuesForSecurityRuleProtocol() []string

func PossibleValuesForSharingScope ¶ 

func PossibleValuesForSharingScope() []string

func PossibleValuesForSyncMode ¶ 

func PossibleValuesForSyncMode() []string

func PossibleValuesForTransportProtocol ¶ 

func PossibleValuesForTransportProtocol() []string

func PossibleValuesForVirtualNetworkGatewayConnectionProtocol ¶ 

func PossibleValuesForVirtualNetworkGatewayConnectionProtocol() []string

func PossibleValuesForVirtualNetworkPrivateEndpointNetworkPolicies ¶ 

func PossibleValuesForVirtualNetworkPrivateEndpointNetworkPolicies() []string

func PossibleValuesForVirtualNetworkPrivateLinkServiceNetworkPolicies ¶ 

func PossibleValuesForVirtualNetworkPrivateLinkServiceNetworkPolicies() []string

func PossibleValuesForVirtualWanSecurityProviderType ¶ 

func PossibleValuesForVirtualWanSecurityProviderType() []string

func PossibleValuesForVnetLocalRouteOverrideCriteria ¶ 

func PossibleValuesForVnetLocalRouteOverrideCriteria() []string

func PossibleValuesForVpnAuthenticationType ¶ 

func PossibleValuesForVpnAuthenticationType() []string

func PossibleValuesForVpnConnectionStatus ¶ 

func PossibleValuesForVpnConnectionStatus() []string

func PossibleValuesForVpnGatewayTunnelingProtocol ¶ 

func PossibleValuesForVpnGatewayTunnelingProtocol() []string

func PossibleValuesForVpnLinkConnectionMode ¶ 

func PossibleValuesForVpnLinkConnectionMode() []string

func PossibleValuesForVpnNatRuleMode ¶ 

func PossibleValuesForVpnNatRuleMode() []string

func PossibleValuesForVpnNatRuleType ¶ 

func PossibleValuesForVpnNatRuleType() []string

func PossibleValuesForVpnPolicyMemberAttributeType ¶ 

func PossibleValuesForVpnPolicyMemberAttributeType() []string

func ValidateConfigurationPolicyGroupID ¶ 

func ValidateConfigurationPolicyGroupID(input interface{}, key string) (warnings []string, errors []error)

ValidateConfigurationPolicyGroupID checks that 'input' can be parsed as a Configuration Policy Group ID

func ValidateHubRouteTableID ¶ 

func ValidateHubRouteTableID(input interface{}, key string) (warnings []string, errors []error)

ValidateHubRouteTableID checks that 'input' can be parsed as a Hub Route Table ID

func ValidateHubVirtualNetworkConnectionID ¶ 

func ValidateHubVirtualNetworkConnectionID(input interface{}, key string) (warnings []string, errors []error)

ValidateHubVirtualNetworkConnectionID checks that 'input' can be parsed as a Hub Virtual Network Connection ID

func ValidateNatRuleID ¶ 

func ValidateNatRuleID(input interface{}, key string) (warnings []string, errors []error)

ValidateNatRuleID checks that 'input' can be parsed as a Nat Rule ID

func ValidateNetworkVirtualApplianceConnectionID ¶ 

func ValidateNetworkVirtualApplianceConnectionID(input interface{}, key string) (warnings []string, errors []error)

ValidateNetworkVirtualApplianceConnectionID checks that 'input' can be parsed as a Network Virtual Appliance Connection ID

func ValidateNetworkVirtualApplianceID ¶ 

func ValidateNetworkVirtualApplianceID(input interface{}, key string) (warnings []string, errors []error)

ValidateNetworkVirtualApplianceID checks that 'input' can be parsed as a Network Virtual Appliance ID

func ValidateRouteMapID ¶ 

func ValidateRouteMapID(input interface{}, key string) (warnings []string, errors []error)

ValidateRouteMapID checks that 'input' can be parsed as a Route Map ID

func ValidateRoutingIntentID ¶ 

func ValidateRoutingIntentID(input interface{}, key string) (warnings []string, errors []error)

ValidateRoutingIntentID checks that 'input' can be parsed as a Routing Intent ID

func ValidateVirtualHubID ¶ 

func ValidateVirtualHubID(input interface{}, key string) (warnings []string, errors []error)

ValidateVirtualHubID checks that 'input' can be parsed as a Virtual Hub ID

func ValidateVirtualHubRouteTableID ¶ 

func ValidateVirtualHubRouteTableID(input interface{}, key string) (warnings []string, errors []error)

ValidateVirtualHubRouteTableID checks that 'input' can be parsed as a Virtual Hub Route Table ID

func ValidateVirtualWANID ¶ 

func ValidateVirtualWANID(input interface{}, key string) (warnings []string, errors []error)

ValidateVirtualWANID checks that 'input' can be parsed as a Virtual W A N ID

func ValidateVpnGatewayID ¶ 

func ValidateVpnGatewayID(input interface{}, key string) (warnings []string, errors []error)

ValidateVpnGatewayID checks that 'input' can be parsed as a Vpn Gateway ID

func ValidateVpnLinkConnectionID ¶ 

func ValidateVpnLinkConnectionID(input interface{}, key string) (warnings []string, errors []error)

ValidateVpnLinkConnectionID checks that 'input' can be parsed as a Vpn Link Connection ID

func ValidateVpnServerConfigurationID ¶ 

func ValidateVpnServerConfigurationID(input interface{}, key string) (warnings []string, errors []error)

ValidateVpnServerConfigurationID checks that 'input' can be parsed as a Vpn Server Configuration ID

func ValidateVpnSiteID ¶ 

func ValidateVpnSiteID(input interface{}, key string) (warnings []string, errors []error)

ValidateVpnSiteID checks that 'input' can be parsed as a Vpn Site ID

func ValidateVpnSiteLinkID ¶ 

func ValidateVpnSiteLinkID(input interface{}, key string) (warnings []string, errors []error)

ValidateVpnSiteLinkID checks that 'input' can be parsed as a Vpn Site Link ID

Types ¶

type AadAuthenticationParameters ¶ 

type AadAuthenticationParameters struct {
	AadAudience *string `json:"aadAudience,omitempty"`
	AadIssuer   *string `json:"aadIssuer,omitempty"`
	AadTenant   *string `json:"aadTenant,omitempty"`
}

type Action ¶ 

type Action struct {
	Parameters *[]Parameter        `json:"parameters,omitempty"`
	Type       *RouteMapActionType `json:"type,omitempty"`
}

type AddressSpace ¶ 

type AddressSpace struct {
	AddressPrefixes *[]string `json:"addressPrefixes,omitempty"`
}

type ApplicationGatewayBackendAddress ¶ 

type ApplicationGatewayBackendAddress struct {
	Fqdn      *string `json:"fqdn,omitempty"`
	IPAddress *string `json:"ipAddress,omitempty"`
}

type ApplicationGatewayBackendAddressPool ¶ 

type ApplicationGatewayBackendAddressPool struct {
	Etag       *string                                               `json:"etag,omitempty"`
	Id         *string                                               `json:"id,omitempty"`
	Name       *string                                               `json:"name,omitempty"`
	Properties *ApplicationGatewayBackendAddressPoolPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                               `json:"type,omitempty"`
}

type ApplicationGatewayBackendAddressPoolPropertiesFormat ¶ 

type ApplicationGatewayBackendAddressPoolPropertiesFormat struct {
	BackendAddresses        *[]ApplicationGatewayBackendAddress `json:"backendAddresses,omitempty"`
	BackendIPConfigurations *[]NetworkInterfaceIPConfiguration  `json:"backendIPConfigurations,omitempty"`
	ProvisioningState       *ProvisioningState                  `json:"provisioningState,omitempty"`
}

type ApplicationGatewayIPConfiguration ¶ 

type ApplicationGatewayIPConfiguration struct {
	Etag       *string                                            `json:"etag,omitempty"`
	Id         *string                                            `json:"id,omitempty"`
	Name       *string                                            `json:"name,omitempty"`
	Properties *ApplicationGatewayIPConfigurationPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                            `json:"type,omitempty"`
}

type ApplicationGatewayIPConfigurationPropertiesFormat ¶ 

type ApplicationGatewayIPConfigurationPropertiesFormat struct {
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	Subnet            *SubResource       `json:"subnet,omitempty"`
}

type ApplicationSecurityGroup ¶ 

type ApplicationSecurityGroup struct {
	Etag       *string                                   `json:"etag,omitempty"`
	Id         *string                                   `json:"id,omitempty"`
	Location   *string                                   `json:"location,omitempty"`
	Name       *string                                   `json:"name,omitempty"`
	Properties *ApplicationSecurityGroupPropertiesFormat `json:"properties,omitempty"`
	Tags       *map[string]string                        `json:"tags,omitempty"`
	Type       *string                                   `json:"type,omitempty"`
}

type ApplicationSecurityGroupPropertiesFormat ¶ 

type ApplicationSecurityGroupPropertiesFormat struct {
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	ResourceGuid      *string            `json:"resourceGuid,omitempty"`
}

type AuthenticationMethod ¶ 

type AuthenticationMethod string
const (
	AuthenticationMethodEAPMSCHAPvTwo AuthenticationMethod = "EAPMSCHAPv2"
	AuthenticationMethodEAPTLS        AuthenticationMethod = "EAPTLS"
)

func (*AuthenticationMethod) UnmarshalJSON ¶ 

func (s *AuthenticationMethod) UnmarshalJSON(bytes []byte) error

type BackendAddressPool ¶ 

type BackendAddressPool struct {
	Etag       *string                             `json:"etag,omitempty"`
	Id         *string                             `json:"id,omitempty"`
	Name       *string                             `json:"name,omitempty"`
	Properties *BackendAddressPoolPropertiesFormat `json:"properties,omitempty"`
	Type       *string                             `json:"type,omitempty"`
}

type BackendAddressPoolPropertiesFormat ¶ 

type BackendAddressPoolPropertiesFormat struct {
	BackendIPConfigurations      *[]NetworkInterfaceIPConfiguration    `json:"backendIPConfigurations,omitempty"`
	DrainPeriodInSeconds         *int64                                `json:"drainPeriodInSeconds,omitempty"`
	InboundNatRules              *[]SubResource                        `json:"inboundNatRules,omitempty"`
	LoadBalancerBackendAddresses *[]LoadBalancerBackendAddress         `json:"loadBalancerBackendAddresses,omitempty"`
	LoadBalancingRules           *[]SubResource                        `json:"loadBalancingRules,omitempty"`
	Location                     *string                               `json:"location,omitempty"`
	OutboundRule                 *SubResource                          `json:"outboundRule,omitempty"`
	OutboundRules                *[]SubResource                        `json:"outboundRules,omitempty"`
	ProvisioningState            *ProvisioningState                    `json:"provisioningState,omitempty"`
	SyncMode                     *SyncMode                             `json:"syncMode,omitempty"`
	TunnelInterfaces             *[]GatewayLoadBalancerTunnelInterface `json:"tunnelInterfaces,omitempty"`
	VirtualNetwork               *SubResource                          `json:"virtualNetwork,omitempty"`
}

type BgpConnection ¶ 

type BgpConnection struct {
	Etag       *string                  `json:"etag,omitempty"`
	Id         *string                  `json:"id,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *BgpConnectionProperties `json:"properties,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type BgpConnectionOperationPredicate ¶ 

type BgpConnectionOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (BgpConnectionOperationPredicate) Matches ¶ 

func (p BgpConnectionOperationPredicate) Matches(input BgpConnection) bool

type BgpConnectionProperties ¶ 

type BgpConnectionProperties struct {
	ConnectionState             *HubBgpConnectionStatus `json:"connectionState,omitempty"`
	HubVirtualNetworkConnection *SubResource            `json:"hubVirtualNetworkConnection,omitempty"`
	PeerAsn                     *int64                  `json:"peerAsn,omitempty"`
	PeerIP                      *string                 `json:"peerIp,omitempty"`
	ProvisioningState           *ProvisioningState      `json:"provisioningState,omitempty"`
}

type BgpSettings ¶ 

type BgpSettings struct {
	Asn                 *int64                              `json:"asn,omitempty"`
	BgpPeeringAddress   *string                             `json:"bgpPeeringAddress,omitempty"`
	BgpPeeringAddresses *[]IPConfigurationBgpPeeringAddress `json:"bgpPeeringAddresses,omitempty"`
	PeerWeight          *int64                              `json:"peerWeight,omitempty"`
}

type ConfigurationPolicyGroupId ¶ 

type ConfigurationPolicyGroupId struct {
	SubscriptionId               string
	ResourceGroupName            string
	VpnServerConfigurationName   string
	ConfigurationPolicyGroupName string
}

ConfigurationPolicyGroupId is a struct representing the Resource ID for a Configuration Policy Group

func NewConfigurationPolicyGroupID ¶ 

func NewConfigurationPolicyGroupID(subscriptionId string, resourceGroupName string, vpnServerConfigurationName string, configurationPolicyGroupName string) ConfigurationPolicyGroupId

NewConfigurationPolicyGroupID returns a new ConfigurationPolicyGroupId struct

func ParseConfigurationPolicyGroupID ¶ 

func ParseConfigurationPolicyGroupID(input string) (*ConfigurationPolicyGroupId, error)

ParseConfigurationPolicyGroupID parses 'input' into a ConfigurationPolicyGroupId

func ParseConfigurationPolicyGroupIDInsensitively ¶ 

func ParseConfigurationPolicyGroupIDInsensitively(input string) (*ConfigurationPolicyGroupId, error)

ParseConfigurationPolicyGroupIDInsensitively parses 'input' case-insensitively into a ConfigurationPolicyGroupId note: this method should only be used for API response data and not user input

func (*ConfigurationPolicyGroupId) FromParseResult ¶ 

func (id *ConfigurationPolicyGroupId) FromParseResult(input resourceids.ParseResult) error

func (ConfigurationPolicyGroupId) ID ¶ 

func (id ConfigurationPolicyGroupId) ID() string

ID returns the formatted Configuration Policy Group ID

func (ConfigurationPolicyGroupId) Segments ¶ 

func (id ConfigurationPolicyGroupId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Configuration Policy Group ID

func (ConfigurationPolicyGroupId) String ¶ 

func (id ConfigurationPolicyGroupId) String() string

String returns a human-readable description of this Configuration Policy Group ID

type ConfigurationPolicyGroupsCreateOrUpdateOperationResponse ¶ 

type ConfigurationPolicyGroupsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnServerConfigurationPolicyGroup
}

type ConfigurationPolicyGroupsDeleteOperationResponse ¶ 

type ConfigurationPolicyGroupsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type ConfigurationPolicyGroupsGetOperationResponse ¶ 

type ConfigurationPolicyGroupsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnServerConfigurationPolicyGroup
}

type ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteResult ¶ 

type ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnServerConfigurationPolicyGroup
}

type ConfigurationPolicyGroupsListByVpnServerConfigurationOperationResponse ¶ 

type ConfigurationPolicyGroupsListByVpnServerConfigurationOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnServerConfigurationPolicyGroup
}

type Criterion ¶ 

type Criterion struct {
	AsPath         *[]string               `json:"asPath,omitempty"`
	Community      *[]string               `json:"community,omitempty"`
	MatchCondition *RouteMapMatchCondition `json:"matchCondition,omitempty"`
	RoutePrefix    *[]string               `json:"routePrefix,omitempty"`
}

type CustomDnsConfigPropertiesFormat ¶ 

type CustomDnsConfigPropertiesFormat struct {
	Fqdn        *string   `json:"fqdn,omitempty"`
	IPAddresses *[]string `json:"ipAddresses,omitempty"`
}

type DdosSettings ¶ 

type DdosSettings struct {
	DdosProtectionPlan *SubResource                `json:"ddosProtectionPlan,omitempty"`
	ProtectionMode     *DdosSettingsProtectionMode `json:"protectionMode,omitempty"`
}

type DdosSettingsProtectionMode ¶ 

type DdosSettingsProtectionMode string
const (
	DdosSettingsProtectionModeDisabled                DdosSettingsProtectionMode = "Disabled"
	DdosSettingsProtectionModeEnabled                 DdosSettingsProtectionMode = "Enabled"
	DdosSettingsProtectionModeVirtualNetworkInherited DdosSettingsProtectionMode = "VirtualNetworkInherited"
)

func (*DdosSettingsProtectionMode) UnmarshalJSON ¶ 

func (s *DdosSettingsProtectionMode) UnmarshalJSON(bytes []byte) error

type Delegation ¶ 

type Delegation struct {
	Etag       *string                            `json:"etag,omitempty"`
	Id         *string                            `json:"id,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties *ServiceDelegationPropertiesFormat `json:"properties,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type DeleteOptions ¶ 

type DeleteOptions string
const (
	DeleteOptionsDelete DeleteOptions = "Delete"
	DeleteOptionsDetach DeleteOptions = "Detach"
)

func (*DeleteOptions) UnmarshalJSON ¶ 

func (s *DeleteOptions) UnmarshalJSON(bytes []byte) error

type DeviceProperties ¶ 

type DeviceProperties struct {
	DeviceModel     *string `json:"deviceModel,omitempty"`
	DeviceVendor    *string `json:"deviceVendor,omitempty"`
	LinkSpeedInMbps *int64  `json:"linkSpeedInMbps,omitempty"`
}

type DhGroup ¶ 

type DhGroup string
const (
	DhGroupDHGroupOne              DhGroup = "DHGroup1"
	DhGroupDHGroupOneFour          DhGroup = "DHGroup14"
	DhGroupDHGroupTwo              DhGroup = "DHGroup2"
	DhGroupDHGroupTwoFour          DhGroup = "DHGroup24"
	DhGroupDHGroupTwoZeroFourEight DhGroup = "DHGroup2048"
	DhGroupECPThreeEightFour       DhGroup = "ECP384"
	DhGroupECPTwoFiveSix           DhGroup = "ECP256"
	DhGroupNone                    DhGroup = "None"
)

func (*DhGroup) UnmarshalJSON ¶ 

func (s *DhGroup) UnmarshalJSON(bytes []byte) error

type EffectiveRouteMapRoute ¶ 

type EffectiveRouteMapRoute struct {
	AsPath         *string `json:"asPath,omitempty"`
	BgpCommunities *string `json:"bgpCommunities,omitempty"`
	Prefix         *string `json:"prefix,omitempty"`
}

type EffectiveRouteMapRouteList ¶ 

type EffectiveRouteMapRouteList struct {
	Value *[]EffectiveRouteMapRoute `json:"value,omitempty"`
}

type EffectiveRoutesParameters ¶ 

type EffectiveRoutesParameters struct {
	ResourceId             *string `json:"resourceId,omitempty"`
	VirtualWanResourceType *string `json:"virtualWanResourceType,omitempty"`
}

type FlowLog ¶ 

type FlowLog struct {
	Etag       *string                  `json:"etag,omitempty"`
	Id         *string                  `json:"id,omitempty"`
	Location   *string                  `json:"location,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *FlowLogPropertiesFormat `json:"properties,omitempty"`
	Tags       *map[string]string       `json:"tags,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type FlowLogFormatParameters ¶ 

type FlowLogFormatParameters struct {
	Type    *FlowLogFormatType `json:"type,omitempty"`
	Version *int64             `json:"version,omitempty"`
}

type FlowLogFormatType ¶ 

type FlowLogFormatType string
const (
	FlowLogFormatTypeJSON FlowLogFormatType = "JSON"
)

func (*FlowLogFormatType) UnmarshalJSON ¶ 

func (s *FlowLogFormatType) UnmarshalJSON(bytes []byte) error

type FlowLogPropertiesFormat ¶ 

type FlowLogPropertiesFormat struct {
	Enabled                    *bool                       `json:"enabled,omitempty"`
	FlowAnalyticsConfiguration *TrafficAnalyticsProperties `json:"flowAnalyticsConfiguration,omitempty"`
	Format                     *FlowLogFormatParameters    `json:"format,omitempty"`
	ProvisioningState          *ProvisioningState          `json:"provisioningState,omitempty"`
	RetentionPolicy            *RetentionPolicyParameters  `json:"retentionPolicy,omitempty"`
	StorageId                  string                      `json:"storageId"`
	TargetResourceGuid         *string                     `json:"targetResourceGuid,omitempty"`
	TargetResourceId           string                      `json:"targetResourceId"`
}

type FrontendIPConfiguration ¶ 

type FrontendIPConfiguration struct {
	Etag       *string                                  `json:"etag,omitempty"`
	Id         *string                                  `json:"id,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties *FrontendIPConfigurationPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
	Zones      *zones.Schema                            `json:"zones,omitempty"`
}

type FrontendIPConfigurationPropertiesFormat ¶ 

type FrontendIPConfigurationPropertiesFormat struct {
	GatewayLoadBalancer       *SubResource        `json:"gatewayLoadBalancer,omitempty"`
	InboundNatPools           *[]SubResource      `json:"inboundNatPools,omitempty"`
	InboundNatRules           *[]SubResource      `json:"inboundNatRules,omitempty"`
	LoadBalancingRules        *[]SubResource      `json:"loadBalancingRules,omitempty"`
	OutboundRules             *[]SubResource      `json:"outboundRules,omitempty"`
	PrivateIPAddress          *string             `json:"privateIPAddress,omitempty"`
	PrivateIPAddressVersion   *IPVersion          `json:"privateIPAddressVersion,omitempty"`
	PrivateIPAllocationMethod *IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
	ProvisioningState         *ProvisioningState  `json:"provisioningState,omitempty"`
	PublicIPAddress           *PublicIPAddress    `json:"publicIPAddress,omitempty"`
	PublicIPPrefix            *SubResource        `json:"publicIPPrefix,omitempty"`
	Subnet                    *Subnet             `json:"subnet,omitempty"`
}

type GatewayCustomBgpIPAddressIPConfiguration ¶ 

type GatewayCustomBgpIPAddressIPConfiguration struct {
	CustomBgpIPAddress string `json:"customBgpIpAddress"`
	IPConfigurationId  string `json:"ipConfigurationId"`
}

type GatewayLoadBalancerTunnelInterface ¶ 

type GatewayLoadBalancerTunnelInterface struct {
	Identifier *int64                                  `json:"identifier,omitempty"`
	Port       *int64                                  `json:"port,omitempty"`
	Protocol   *GatewayLoadBalancerTunnelProtocol      `json:"protocol,omitempty"`
	Type       *GatewayLoadBalancerTunnelInterfaceType `json:"type,omitempty"`
}

type GatewayLoadBalancerTunnelInterfaceType ¶ 

type GatewayLoadBalancerTunnelInterfaceType string
const (
	GatewayLoadBalancerTunnelInterfaceTypeExternal GatewayLoadBalancerTunnelInterfaceType = "External"
	GatewayLoadBalancerTunnelInterfaceTypeInternal GatewayLoadBalancerTunnelInterfaceType = "Internal"
	GatewayLoadBalancerTunnelInterfaceTypeNone     GatewayLoadBalancerTunnelInterfaceType = "None"
)

func (*GatewayLoadBalancerTunnelInterfaceType) UnmarshalJSON ¶ 

func (s *GatewayLoadBalancerTunnelInterfaceType) UnmarshalJSON(bytes []byte) error

type GatewayLoadBalancerTunnelProtocol ¶ 

type GatewayLoadBalancerTunnelProtocol string
const (
	GatewayLoadBalancerTunnelProtocolNative GatewayLoadBalancerTunnelProtocol = "Native"
	GatewayLoadBalancerTunnelProtocolNone   GatewayLoadBalancerTunnelProtocol = "None"
	GatewayLoadBalancerTunnelProtocolVXLAN  GatewayLoadBalancerTunnelProtocol = "VXLAN"
)

func (*GatewayLoadBalancerTunnelProtocol) UnmarshalJSON ¶ 

func (s *GatewayLoadBalancerTunnelProtocol) UnmarshalJSON(bytes []byte) error

type GeneratevirtualwanvpnserverconfigurationvpnprofileOperationResponse ¶ 

type GeneratevirtualwanvpnserverconfigurationvpnprofileOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnProfileResponse
}

type GetInboundRoutesParameters ¶ 

type GetInboundRoutesParameters struct {
	ConnectionType *string `json:"connectionType,omitempty"`
	ResourceUri    *string `json:"resourceUri,omitempty"`
}

type GetOutboundRoutesParameters ¶ 

type GetOutboundRoutesParameters struct {
	ConnectionType *string `json:"connectionType,omitempty"`
	ResourceUri    *string `json:"resourceUri,omitempty"`
}

type GetVpnSitesConfigurationRequest ¶ 

type GetVpnSitesConfigurationRequest struct {
	OutputBlobSasUrl string    `json:"outputBlobSasUrl"`
	VpnSites         *[]string `json:"vpnSites,omitempty"`
}

type HubBgpConnectionStatus ¶ 

type HubBgpConnectionStatus string
const (
	HubBgpConnectionStatusConnected    HubBgpConnectionStatus = "Connected"
	HubBgpConnectionStatusConnecting   HubBgpConnectionStatus = "Connecting"
	HubBgpConnectionStatusNotConnected HubBgpConnectionStatus = "NotConnected"
	HubBgpConnectionStatusUnknown      HubBgpConnectionStatus = "Unknown"
)

func (*HubBgpConnectionStatus) UnmarshalJSON ¶ 

func (s *HubBgpConnectionStatus) UnmarshalJSON(bytes []byte) error

type HubIPConfiguration ¶ 

type HubIPConfiguration struct {
	Etag       *string                             `json:"etag,omitempty"`
	Id         *string                             `json:"id,omitempty"`
	Name       *string                             `json:"name,omitempty"`
	Properties *HubIPConfigurationPropertiesFormat `json:"properties,omitempty"`
	Type       *string                             `json:"type,omitempty"`
}

type HubIPConfigurationOperationPredicate ¶ 

type HubIPConfigurationOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (HubIPConfigurationOperationPredicate) Matches ¶ 

func (p HubIPConfigurationOperationPredicate) Matches(input HubIPConfiguration) bool

type HubIPConfigurationPropertiesFormat ¶ 

type HubIPConfigurationPropertiesFormat struct {
	PrivateIPAddress          *string             `json:"privateIPAddress,omitempty"`
	PrivateIPAllocationMethod *IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
	ProvisioningState         *ProvisioningState  `json:"provisioningState,omitempty"`
	PublicIPAddress           *PublicIPAddress    `json:"publicIPAddress,omitempty"`
	Subnet                    *Subnet             `json:"subnet,omitempty"`
}

type HubRoute ¶ 

type HubRoute struct {
	DestinationType string   `json:"destinationType"`
	Destinations    []string `json:"destinations"`
	Name            string   `json:"name"`
	NextHop         string   `json:"nextHop"`
	NextHopType     string   `json:"nextHopType"`
}

type HubRouteTable ¶ 

type HubRouteTable struct {
	Etag       *string                  `json:"etag,omitempty"`
	Id         *string                  `json:"id,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *HubRouteTableProperties `json:"properties,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type HubRouteTableId ¶ 

type HubRouteTableId struct {
	SubscriptionId    string
	ResourceGroupName string
	VirtualHubName    string
	HubRouteTableName string
}

HubRouteTableId is a struct representing the Resource ID for a Hub Route Table

func NewHubRouteTableID ¶ 

func NewHubRouteTableID(subscriptionId string, resourceGroupName string, virtualHubName string, hubRouteTableName string) HubRouteTableId

NewHubRouteTableID returns a new HubRouteTableId struct

func ParseHubRouteTableID ¶ 

func ParseHubRouteTableID(input string) (*HubRouteTableId, error)

ParseHubRouteTableID parses 'input' into a HubRouteTableId

func ParseHubRouteTableIDInsensitively ¶ 

func ParseHubRouteTableIDInsensitively(input string) (*HubRouteTableId, error)

ParseHubRouteTableIDInsensitively parses 'input' case-insensitively into a HubRouteTableId note: this method should only be used for API response data and not user input

func (*HubRouteTableId) FromParseResult ¶ 

func (id *HubRouteTableId) FromParseResult(input resourceids.ParseResult) error

func (HubRouteTableId) ID ¶ 

func (id HubRouteTableId) ID() string

ID returns the formatted Hub Route Table ID

func (HubRouteTableId) Segments ¶ 

func (id HubRouteTableId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Hub Route Table ID

func (HubRouteTableId) String ¶ 

func (id HubRouteTableId) String() string

String returns a human-readable description of this Hub Route Table ID

type HubRouteTableOperationPredicate ¶ 

type HubRouteTableOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (HubRouteTableOperationPredicate) Matches ¶ 

func (p HubRouteTableOperationPredicate) Matches(input HubRouteTable) bool

type HubRouteTableProperties ¶ 

type HubRouteTableProperties struct {
	AssociatedConnections  *[]string          `json:"associatedConnections,omitempty"`
	Labels                 *[]string          `json:"labels,omitempty"`
	PropagatingConnections *[]string          `json:"propagatingConnections,omitempty"`
	ProvisioningState      *ProvisioningState `json:"provisioningState,omitempty"`
	Routes                 *[]HubRoute        `json:"routes,omitempty"`
}

type HubRouteTablesCreateOrUpdateOperationResponse ¶ 

type HubRouteTablesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *HubRouteTable
}

type HubRouteTablesDeleteOperationResponse ¶ 

type HubRouteTablesDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type HubRouteTablesGetOperationResponse ¶ 

type HubRouteTablesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *HubRouteTable
}

type HubRouteTablesListCompleteResult ¶ 

type HubRouteTablesListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []HubRouteTable
}

type HubRouteTablesListOperationResponse ¶ 

type HubRouteTablesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]HubRouteTable
}

type HubRoutingPreference ¶ 

type HubRoutingPreference string
const (
	HubRoutingPreferenceASPath       HubRoutingPreference = "ASPath"
	HubRoutingPreferenceExpressRoute HubRoutingPreference = "ExpressRoute"
	HubRoutingPreferenceVpnGateway   HubRoutingPreference = "VpnGateway"
)

func (*HubRoutingPreference) UnmarshalJSON ¶ 

func (s *HubRoutingPreference) UnmarshalJSON(bytes []byte) error

type HubVirtualNetworkConnection ¶ 

type HubVirtualNetworkConnection struct {
	Etag       *string                                `json:"etag,omitempty"`
	Id         *string                                `json:"id,omitempty"`
	Name       *string                                `json:"name,omitempty"`
	Properties *HubVirtualNetworkConnectionProperties `json:"properties,omitempty"`
}

type HubVirtualNetworkConnectionId ¶ 

type HubVirtualNetworkConnectionId struct {
	SubscriptionId                  string
	ResourceGroupName               string
	VirtualHubName                  string
	HubVirtualNetworkConnectionName string
}

HubVirtualNetworkConnectionId is a struct representing the Resource ID for a Hub Virtual Network Connection

func NewHubVirtualNetworkConnectionID ¶ 

func NewHubVirtualNetworkConnectionID(subscriptionId string, resourceGroupName string, virtualHubName string, hubVirtualNetworkConnectionName string) HubVirtualNetworkConnectionId

NewHubVirtualNetworkConnectionID returns a new HubVirtualNetworkConnectionId struct

func ParseHubVirtualNetworkConnectionID ¶ 

func ParseHubVirtualNetworkConnectionID(input string) (*HubVirtualNetworkConnectionId, error)

ParseHubVirtualNetworkConnectionID parses 'input' into a HubVirtualNetworkConnectionId

func ParseHubVirtualNetworkConnectionIDInsensitively ¶ 

func ParseHubVirtualNetworkConnectionIDInsensitively(input string) (*HubVirtualNetworkConnectionId, error)

ParseHubVirtualNetworkConnectionIDInsensitively parses 'input' case-insensitively into a HubVirtualNetworkConnectionId note: this method should only be used for API response data and not user input

func (*HubVirtualNetworkConnectionId) FromParseResult ¶ 

func (id *HubVirtualNetworkConnectionId) FromParseResult(input resourceids.ParseResult) error

func (HubVirtualNetworkConnectionId) ID ¶ 

func (id HubVirtualNetworkConnectionId) ID() string

ID returns the formatted Hub Virtual Network Connection ID

func (HubVirtualNetworkConnectionId) Segments ¶ 

func (id HubVirtualNetworkConnectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Hub Virtual Network Connection ID

func (HubVirtualNetworkConnectionId) String ¶ 

func (id HubVirtualNetworkConnectionId) String() string

String returns a human-readable description of this Hub Virtual Network Connection ID

type HubVirtualNetworkConnectionOperationPredicate ¶ 

type HubVirtualNetworkConnectionOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
}

func (HubVirtualNetworkConnectionOperationPredicate) Matches ¶ 

func (p HubVirtualNetworkConnectionOperationPredicate) Matches(input HubVirtualNetworkConnection) bool

type HubVirtualNetworkConnectionProperties ¶ 

type HubVirtualNetworkConnectionProperties struct {
	AllowHubToRemoteVnetTransit         *bool                 `json:"allowHubToRemoteVnetTransit,omitempty"`
	AllowRemoteVnetToUseHubVnetGateways *bool                 `json:"allowRemoteVnetToUseHubVnetGateways,omitempty"`
	EnableInternetSecurity              *bool                 `json:"enableInternetSecurity,omitempty"`
	ProvisioningState                   *ProvisioningState    `json:"provisioningState,omitempty"`
	RemoteVirtualNetwork                *SubResource          `json:"remoteVirtualNetwork,omitempty"`
	RoutingConfiguration                *RoutingConfiguration `json:"routingConfiguration,omitempty"`
}

type HubVirtualNetworkConnectionsCreateOrUpdateOperationResponse ¶ 

type HubVirtualNetworkConnectionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *HubVirtualNetworkConnection
}

type HubVirtualNetworkConnectionsDeleteOperationResponse ¶ 

type HubVirtualNetworkConnectionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type HubVirtualNetworkConnectionsGetOperationResponse ¶ 

type HubVirtualNetworkConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *HubVirtualNetworkConnection
}

type HubVirtualNetworkConnectionsListCompleteResult ¶ 

type HubVirtualNetworkConnectionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []HubVirtualNetworkConnection
}

type HubVirtualNetworkConnectionsListOperationResponse ¶ 

type HubVirtualNetworkConnectionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]HubVirtualNetworkConnection
}

type IPAllocationMethod ¶ 

type IPAllocationMethod string
const (
	IPAllocationMethodDynamic IPAllocationMethod = "Dynamic"
	IPAllocationMethodStatic  IPAllocationMethod = "Static"
)

func (*IPAllocationMethod) UnmarshalJSON ¶ 

func (s *IPAllocationMethod) UnmarshalJSON(bytes []byte) error

type IPConfiguration ¶ 

type IPConfiguration struct {
	Etag       *string                          `json:"etag,omitempty"`
	Id         *string                          `json:"id,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties *IPConfigurationPropertiesFormat `json:"properties,omitempty"`
}

type IPConfigurationBgpPeeringAddress ¶ 

type IPConfigurationBgpPeeringAddress struct {
	CustomBgpIPAddresses  *[]string `json:"customBgpIpAddresses,omitempty"`
	DefaultBgpIPAddresses *[]string `json:"defaultBgpIpAddresses,omitempty"`
	IPconfigurationId     *string   `json:"ipconfigurationId,omitempty"`
	TunnelIPAddresses     *[]string `json:"tunnelIpAddresses,omitempty"`
}

type IPConfigurationProfile ¶ 

type IPConfigurationProfile struct {
	Etag       *string                                 `json:"etag,omitempty"`
	Id         *string                                 `json:"id,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties *IPConfigurationProfilePropertiesFormat `json:"properties,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type IPConfigurationProfilePropertiesFormat ¶ 

type IPConfigurationProfilePropertiesFormat struct {
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	Subnet            *Subnet            `json:"subnet,omitempty"`
}

type IPConfigurationPropertiesFormat ¶ 

type IPConfigurationPropertiesFormat struct {
	PrivateIPAddress          *string             `json:"privateIPAddress,omitempty"`
	PrivateIPAllocationMethod *IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
	ProvisioningState         *ProvisioningState  `json:"provisioningState,omitempty"`
	PublicIPAddress           *PublicIPAddress    `json:"publicIPAddress,omitempty"`
	Subnet                    *Subnet             `json:"subnet,omitempty"`
}

type IPTag ¶ 

type IPTag struct {
	IPTagType *string `json:"ipTagType,omitempty"`
	Tag       *string `json:"tag,omitempty"`
}

type IPVersion ¶ 

type IPVersion string
const (
	IPVersionIPvFour IPVersion = "IPv4"
	IPVersionIPvSix  IPVersion = "IPv6"
)

func (*IPVersion) UnmarshalJSON ¶ 

func (s *IPVersion) UnmarshalJSON(bytes []byte) error

type IPsecEncryption ¶ 

type IPsecEncryption string
const (
	IPsecEncryptionAESOneNineTwo     IPsecEncryption = "AES192"
	IPsecEncryptionAESOneTwoEight    IPsecEncryption = "AES128"
	IPsecEncryptionAESTwoFiveSix     IPsecEncryption = "AES256"
	IPsecEncryptionDES               IPsecEncryption = "DES"
	IPsecEncryptionDESThree          IPsecEncryption = "DES3"
	IPsecEncryptionGCMAESOneNineTwo  IPsecEncryption = "GCMAES192"
	IPsecEncryptionGCMAESOneTwoEight IPsecEncryption = "GCMAES128"
	IPsecEncryptionGCMAESTwoFiveSix  IPsecEncryption = "GCMAES256"
	IPsecEncryptionNone              IPsecEncryption = "None"
)

func (*IPsecEncryption) UnmarshalJSON ¶ 

func (s *IPsecEncryption) UnmarshalJSON(bytes []byte) error

type IPsecIntegrity ¶ 

type IPsecIntegrity string
const (
	IPsecIntegrityGCMAESOneNineTwo  IPsecIntegrity = "GCMAES192"
	IPsecIntegrityGCMAESOneTwoEight IPsecIntegrity = "GCMAES128"
	IPsecIntegrityGCMAESTwoFiveSix  IPsecIntegrity = "GCMAES256"
	IPsecIntegrityMDFive            IPsecIntegrity = "MD5"
	IPsecIntegritySHAOne            IPsecIntegrity = "SHA1"
	IPsecIntegritySHATwoFiveSix     IPsecIntegrity = "SHA256"
)

func (*IPsecIntegrity) UnmarshalJSON ¶ 

func (s *IPsecIntegrity) UnmarshalJSON(bytes []byte) error

type IPsecPolicy ¶ 

type IPsecPolicy struct {
	DhGroup             DhGroup         `json:"dhGroup"`
	IPsecEncryption     IPsecEncryption `json:"ipsecEncryption"`
	IPsecIntegrity      IPsecIntegrity  `json:"ipsecIntegrity"`
	IkeEncryption       IkeEncryption   `json:"ikeEncryption"`
	IkeIntegrity        IkeIntegrity    `json:"ikeIntegrity"`
	PfsGroup            PfsGroup        `json:"pfsGroup"`
	SaDataSizeKilobytes int64           `json:"saDataSizeKilobytes"`
	SaLifeTimeSeconds   int64           `json:"saLifeTimeSeconds"`
}

type IkeEncryption ¶ 

type IkeEncryption string
const (
	IkeEncryptionAESOneNineTwo     IkeEncryption = "AES192"
	IkeEncryptionAESOneTwoEight    IkeEncryption = "AES128"
	IkeEncryptionAESTwoFiveSix     IkeEncryption = "AES256"
	IkeEncryptionDES               IkeEncryption = "DES"
	IkeEncryptionDESThree          IkeEncryption = "DES3"
	IkeEncryptionGCMAESOneTwoEight IkeEncryption = "GCMAES128"
	IkeEncryptionGCMAESTwoFiveSix  IkeEncryption = "GCMAES256"
)

func (*IkeEncryption) UnmarshalJSON ¶ 

func (s *IkeEncryption) UnmarshalJSON(bytes []byte) error

type IkeIntegrity ¶ 

type IkeIntegrity string
const (
	IkeIntegrityGCMAESOneTwoEight IkeIntegrity = "GCMAES128"
	IkeIntegrityGCMAESTwoFiveSix  IkeIntegrity = "GCMAES256"
	IkeIntegrityMDFive            IkeIntegrity = "MD5"
	IkeIntegritySHAOne            IkeIntegrity = "SHA1"
	IkeIntegritySHAThreeEightFour IkeIntegrity = "SHA384"
	IkeIntegritySHATwoFiveSix     IkeIntegrity = "SHA256"
)

func (*IkeIntegrity) UnmarshalJSON ¶ 

func (s *IkeIntegrity) UnmarshalJSON(bytes []byte) error

type InboundNatRule ¶ 

type InboundNatRule struct {
	Etag       *string                         `json:"etag,omitempty"`
	Id         *string                         `json:"id,omitempty"`
	Name       *string                         `json:"name,omitempty"`
	Properties *InboundNatRulePropertiesFormat `json:"properties,omitempty"`
	Type       *string                         `json:"type,omitempty"`
}

type InboundNatRulePropertiesFormat ¶ 

type InboundNatRulePropertiesFormat struct {
	BackendAddressPool      *SubResource                     `json:"backendAddressPool,omitempty"`
	BackendIPConfiguration  *NetworkInterfaceIPConfiguration `json:"backendIPConfiguration,omitempty"`
	BackendPort             *int64                           `json:"backendPort,omitempty"`
	EnableFloatingIP        *bool                            `json:"enableFloatingIP,omitempty"`
	EnableTcpReset          *bool                            `json:"enableTcpReset,omitempty"`
	FrontendIPConfiguration *SubResource                     `json:"frontendIPConfiguration,omitempty"`
	FrontendPort            *int64                           `json:"frontendPort,omitempty"`
	FrontendPortRangeEnd    *int64                           `json:"frontendPortRangeEnd,omitempty"`
	FrontendPortRangeStart  *int64                           `json:"frontendPortRangeStart,omitempty"`
	IdleTimeoutInMinutes    *int64                           `json:"idleTimeoutInMinutes,omitempty"`
	Protocol                *TransportProtocol               `json:"protocol,omitempty"`
	ProvisioningState       *ProvisioningState               `json:"provisioningState,omitempty"`
}

type LoadBalancerBackendAddress ¶ 

type LoadBalancerBackendAddress struct {
	Name       *string                                     `json:"name,omitempty"`
	Properties *LoadBalancerBackendAddressPropertiesFormat `json:"properties,omitempty"`
}

type LoadBalancerBackendAddressAdminState ¶ 

type LoadBalancerBackendAddressAdminState string
const (
	LoadBalancerBackendAddressAdminStateDown LoadBalancerBackendAddressAdminState = "Down"
	LoadBalancerBackendAddressAdminStateNone LoadBalancerBackendAddressAdminState = "None"
	LoadBalancerBackendAddressAdminStateUp   LoadBalancerBackendAddressAdminState = "Up"
)

func (*LoadBalancerBackendAddressAdminState) UnmarshalJSON ¶ 

func (s *LoadBalancerBackendAddressAdminState) UnmarshalJSON(bytes []byte) error

type LoadBalancerBackendAddressPropertiesFormat ¶ 

type LoadBalancerBackendAddressPropertiesFormat struct {
	AdminState                          *LoadBalancerBackendAddressAdminState `json:"adminState,omitempty"`
	IPAddress                           *string                               `json:"ipAddress,omitempty"`
	InboundNatRulesPortMapping          *[]NatRulePortMapping                 `json:"inboundNatRulesPortMapping,omitempty"`
	LoadBalancerFrontendIPConfiguration *SubResource                          `json:"loadBalancerFrontendIPConfiguration,omitempty"`
	NetworkInterfaceIPConfiguration     *SubResource                          `json:"networkInterfaceIPConfiguration,omitempty"`
	Subnet                              *SubResource                          `json:"subnet,omitempty"`
	VirtualNetwork                      *SubResource                          `json:"virtualNetwork,omitempty"`
}

type NatGateway ¶ 

type NatGateway struct {
	Etag       *string                     `json:"etag,omitempty"`
	Id         *string                     `json:"id,omitempty"`
	Location   *string                     `json:"location,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties *NatGatewayPropertiesFormat `json:"properties,omitempty"`
	Sku        *NatGatewaySku              `json:"sku,omitempty"`
	Tags       *map[string]string          `json:"tags,omitempty"`
	Type       *string                     `json:"type,omitempty"`
	Zones      *zones.Schema               `json:"zones,omitempty"`
}

type NatGatewayPropertiesFormat ¶ 

type NatGatewayPropertiesFormat struct {
	IdleTimeoutInMinutes *int64             `json:"idleTimeoutInMinutes,omitempty"`
	ProvisioningState    *ProvisioningState `json:"provisioningState,omitempty"`
	PublicIPAddresses    *[]SubResource     `json:"publicIpAddresses,omitempty"`
	PublicIPPrefixes     *[]SubResource     `json:"publicIpPrefixes,omitempty"`
	ResourceGuid         *string            `json:"resourceGuid,omitempty"`
	Subnets              *[]SubResource     `json:"subnets,omitempty"`
}

type NatGatewaySku ¶ 

type NatGatewaySku struct {
	Name *NatGatewaySkuName `json:"name,omitempty"`
}

type NatGatewaySkuName ¶ 

type NatGatewaySkuName string
const (
	NatGatewaySkuNameStandard NatGatewaySkuName = "Standard"
)

func (*NatGatewaySkuName) UnmarshalJSON ¶ 

func (s *NatGatewaySkuName) UnmarshalJSON(bytes []byte) error

type NatRuleId ¶ 

type NatRuleId struct {
	SubscriptionId    string
	ResourceGroupName string
	VpnGatewayName    string
	NatRuleName       string
}

NatRuleId is a struct representing the Resource ID for a Nat Rule

func NewNatRuleID ¶ 

func NewNatRuleID(subscriptionId string, resourceGroupName string, vpnGatewayName string, natRuleName string) NatRuleId

NewNatRuleID returns a new NatRuleId struct

func ParseNatRuleID ¶ 

func ParseNatRuleID(input string) (*NatRuleId, error)

ParseNatRuleID parses 'input' into a NatRuleId

func ParseNatRuleIDInsensitively ¶ 

func ParseNatRuleIDInsensitively(input string) (*NatRuleId, error)

ParseNatRuleIDInsensitively parses 'input' case-insensitively into a NatRuleId note: this method should only be used for API response data and not user input

func (*NatRuleId) FromParseResult ¶ 

func (id *NatRuleId) FromParseResult(input resourceids.ParseResult) error

func (NatRuleId) ID ¶ 

func (id NatRuleId) ID() string

ID returns the formatted Nat Rule ID

func (NatRuleId) Segments ¶ 

func (id NatRuleId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Nat Rule ID

func (NatRuleId) String ¶ 

func (id NatRuleId) String() string

String returns a human-readable description of this Nat Rule ID

type NatRulePortMapping ¶ 

type NatRulePortMapping struct {
	BackendPort        *int64  `json:"backendPort,omitempty"`
	FrontendPort       *int64  `json:"frontendPort,omitempty"`
	InboundNatRuleName *string `json:"inboundNatRuleName,omitempty"`
}

type NatRulesCreateOrUpdateOperationResponse ¶ 

type NatRulesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnGatewayNatRule
}

type NatRulesDeleteOperationResponse ¶ 

type NatRulesDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type NatRulesGetOperationResponse ¶ 

type NatRulesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnGatewayNatRule
}

type NatRulesListByVpnGatewayCompleteResult ¶ 

type NatRulesListByVpnGatewayCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnGatewayNatRule
}

type NatRulesListByVpnGatewayOperationResponse ¶ 

type NatRulesListByVpnGatewayOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnGatewayNatRule
}

type NetworkInterface ¶ 

type NetworkInterface struct {
	Etag             *string                           `json:"etag,omitempty"`
	ExtendedLocation *edgezones.Model                  `json:"extendedLocation,omitempty"`
	Id               *string                           `json:"id,omitempty"`
	Location         *string                           `json:"location,omitempty"`
	Name             *string                           `json:"name,omitempty"`
	Properties       *NetworkInterfacePropertiesFormat `json:"properties,omitempty"`
	Tags             *map[string]string                `json:"tags,omitempty"`
	Type             *string                           `json:"type,omitempty"`
}

type NetworkInterfaceAuxiliaryMode ¶ 

type NetworkInterfaceAuxiliaryMode string
const (
	NetworkInterfaceAuxiliaryModeAcceleratedConnections NetworkInterfaceAuxiliaryMode = "AcceleratedConnections"
	NetworkInterfaceAuxiliaryModeFloating               NetworkInterfaceAuxiliaryMode = "Floating"
	NetworkInterfaceAuxiliaryModeMaxConnections         NetworkInterfaceAuxiliaryMode = "MaxConnections"
	NetworkInterfaceAuxiliaryModeNone                   NetworkInterfaceAuxiliaryMode = "None"
)

func (*NetworkInterfaceAuxiliaryMode) UnmarshalJSON ¶ 

func (s *NetworkInterfaceAuxiliaryMode) UnmarshalJSON(bytes []byte) error

type NetworkInterfaceAuxiliarySku ¶ 

type NetworkInterfaceAuxiliarySku string
const (
	NetworkInterfaceAuxiliarySkuAEight NetworkInterfaceAuxiliarySku = "A8"
	NetworkInterfaceAuxiliarySkuAFour  NetworkInterfaceAuxiliarySku = "A4"
	NetworkInterfaceAuxiliarySkuAOne   NetworkInterfaceAuxiliarySku = "A1"
	NetworkInterfaceAuxiliarySkuATwo   NetworkInterfaceAuxiliarySku = "A2"
	NetworkInterfaceAuxiliarySkuNone   NetworkInterfaceAuxiliarySku = "None"
)

func (*NetworkInterfaceAuxiliarySku) UnmarshalJSON ¶ 

func (s *NetworkInterfaceAuxiliarySku) UnmarshalJSON(bytes []byte) error

type NetworkInterfaceDnsSettings ¶ 

type NetworkInterfaceDnsSettings struct {
	AppliedDnsServers        *[]string `json:"appliedDnsServers,omitempty"`
	DnsServers               *[]string `json:"dnsServers,omitempty"`
	InternalDnsNameLabel     *string   `json:"internalDnsNameLabel,omitempty"`
	InternalDomainNameSuffix *string   `json:"internalDomainNameSuffix,omitempty"`
	InternalFqdn             *string   `json:"internalFqdn,omitempty"`
}

type NetworkInterfaceIPConfiguration ¶ 

type NetworkInterfaceIPConfiguration struct {
	Etag       *string                                          `json:"etag,omitempty"`
	Id         *string                                          `json:"id,omitempty"`
	Name       *string                                          `json:"name,omitempty"`
	Properties *NetworkInterfaceIPConfigurationPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                          `json:"type,omitempty"`
}

type NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties ¶ 

type NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties struct {
	Fqdns              *[]string `json:"fqdns,omitempty"`
	GroupId            *string   `json:"groupId,omitempty"`
	RequiredMemberName *string   `json:"requiredMemberName,omitempty"`
}

type NetworkInterfaceIPConfigurationPropertiesFormat ¶ 

type NetworkInterfaceIPConfigurationPropertiesFormat struct {
	ApplicationGatewayBackendAddressPools *[]ApplicationGatewayBackendAddressPool                         `json:"applicationGatewayBackendAddressPools,omitempty"`
	ApplicationSecurityGroups             *[]ApplicationSecurityGroup                                     `json:"applicationSecurityGroups,omitempty"`
	GatewayLoadBalancer                   *SubResource                                                    `json:"gatewayLoadBalancer,omitempty"`
	LoadBalancerBackendAddressPools       *[]BackendAddressPool                                           `json:"loadBalancerBackendAddressPools,omitempty"`
	LoadBalancerInboundNatRules           *[]InboundNatRule                                               `json:"loadBalancerInboundNatRules,omitempty"`
	Primary                               *bool                                                           `json:"primary,omitempty"`
	PrivateIPAddress                      *string                                                         `json:"privateIPAddress,omitempty"`
	PrivateIPAddressPrefixLength          *int64                                                          `json:"privateIPAddressPrefixLength,omitempty"`
	PrivateIPAddressVersion               *IPVersion                                                      `json:"privateIPAddressVersion,omitempty"`
	PrivateIPAllocationMethod             *IPAllocationMethod                                             `json:"privateIPAllocationMethod,omitempty"`
	PrivateLinkConnectionProperties       *NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties `json:"privateLinkConnectionProperties,omitempty"`
	ProvisioningState                     *ProvisioningState                                              `json:"provisioningState,omitempty"`
	PublicIPAddress                       *PublicIPAddress                                                `json:"publicIPAddress,omitempty"`
	Subnet                                *Subnet                                                         `json:"subnet,omitempty"`
	VirtualNetworkTaps                    *[]VirtualNetworkTap                                            `json:"virtualNetworkTaps,omitempty"`
}

type NetworkInterfaceMigrationPhase ¶ 

type NetworkInterfaceMigrationPhase string
const (
	NetworkInterfaceMigrationPhaseAbort     NetworkInterfaceMigrationPhase = "Abort"
	NetworkInterfaceMigrationPhaseCommit    NetworkInterfaceMigrationPhase = "Commit"
	NetworkInterfaceMigrationPhaseCommitted NetworkInterfaceMigrationPhase = "Committed"
	NetworkInterfaceMigrationPhaseNone      NetworkInterfaceMigrationPhase = "None"
	NetworkInterfaceMigrationPhasePrepare   NetworkInterfaceMigrationPhase = "Prepare"
)

func (*NetworkInterfaceMigrationPhase) UnmarshalJSON ¶ 

func (s *NetworkInterfaceMigrationPhase) UnmarshalJSON(bytes []byte) error

type NetworkInterfaceNicType ¶ 

type NetworkInterfaceNicType string
const (
	NetworkInterfaceNicTypeElastic  NetworkInterfaceNicType = "Elastic"
	NetworkInterfaceNicTypeStandard NetworkInterfaceNicType = "Standard"
)

func (*NetworkInterfaceNicType) UnmarshalJSON ¶ 

func (s *NetworkInterfaceNicType) UnmarshalJSON(bytes []byte) error

type NetworkInterfacePropertiesFormat ¶ 

type NetworkInterfacePropertiesFormat struct {
	AuxiliaryMode               *NetworkInterfaceAuxiliaryMode      `json:"auxiliaryMode,omitempty"`
	AuxiliarySku                *NetworkInterfaceAuxiliarySku       `json:"auxiliarySku,omitempty"`
	DisableTcpStateTracking     *bool                               `json:"disableTcpStateTracking,omitempty"`
	DnsSettings                 *NetworkInterfaceDnsSettings        `json:"dnsSettings,omitempty"`
	DscpConfiguration           *SubResource                        `json:"dscpConfiguration,omitempty"`
	EnableAcceleratedNetworking *bool                               `json:"enableAcceleratedNetworking,omitempty"`
	EnableIPForwarding          *bool                               `json:"enableIPForwarding,omitempty"`
	HostedWorkloads             *[]string                           `json:"hostedWorkloads,omitempty"`
	IPConfigurations            *[]NetworkInterfaceIPConfiguration  `json:"ipConfigurations,omitempty"`
	MacAddress                  *string                             `json:"macAddress,omitempty"`
	MigrationPhase              *NetworkInterfaceMigrationPhase     `json:"migrationPhase,omitempty"`
	NetworkSecurityGroup        *NetworkSecurityGroup               `json:"networkSecurityGroup,omitempty"`
	NicType                     *NetworkInterfaceNicType            `json:"nicType,omitempty"`
	Primary                     *bool                               `json:"primary,omitempty"`
	PrivateEndpoint             *PrivateEndpoint                    `json:"privateEndpoint,omitempty"`
	PrivateLinkService          *PrivateLinkService                 `json:"privateLinkService,omitempty"`
	ProvisioningState           *ProvisioningState                  `json:"provisioningState,omitempty"`
	ResourceGuid                *string                             `json:"resourceGuid,omitempty"`
	TapConfigurations           *[]NetworkInterfaceTapConfiguration `json:"tapConfigurations,omitempty"`
	VirtualMachine              *SubResource                        `json:"virtualMachine,omitempty"`
	VnetEncryptionSupported     *bool                               `json:"vnetEncryptionSupported,omitempty"`
	WorkloadType                *string                             `json:"workloadType,omitempty"`
}

type NetworkInterfaceTapConfiguration ¶ 

type NetworkInterfaceTapConfiguration struct {
	Etag       *string                                           `json:"etag,omitempty"`
	Id         *string                                           `json:"id,omitempty"`
	Name       *string                                           `json:"name,omitempty"`
	Properties *NetworkInterfaceTapConfigurationPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                           `json:"type,omitempty"`
}

type NetworkInterfaceTapConfigurationPropertiesFormat ¶ 

type NetworkInterfaceTapConfigurationPropertiesFormat struct {
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	VirtualNetworkTap *VirtualNetworkTap `json:"virtualNetworkTap,omitempty"`
}

type NetworkSecurityGroup ¶ 

type NetworkSecurityGroup struct {
	Etag       *string                               `json:"etag,omitempty"`
	Id         *string                               `json:"id,omitempty"`
	Location   *string                               `json:"location,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties *NetworkSecurityGroupPropertiesFormat `json:"properties,omitempty"`
	Tags       *map[string]string                    `json:"tags,omitempty"`
	Type       *string                               `json:"type,omitempty"`
}

type NetworkSecurityGroupPropertiesFormat ¶ 

type NetworkSecurityGroupPropertiesFormat struct {
	DefaultSecurityRules *[]SecurityRule     `json:"defaultSecurityRules,omitempty"`
	FlowLogs             *[]FlowLog          `json:"flowLogs,omitempty"`
	FlushConnection      *bool               `json:"flushConnection,omitempty"`
	NetworkInterfaces    *[]NetworkInterface `json:"networkInterfaces,omitempty"`
	ProvisioningState    *ProvisioningState  `json:"provisioningState,omitempty"`
	ResourceGuid         *string             `json:"resourceGuid,omitempty"`
	SecurityRules        *[]SecurityRule     `json:"securityRules,omitempty"`
	Subnets              *[]Subnet           `json:"subnets,omitempty"`
}

type NetworkVirtualApplianceConnection ¶ 

type NetworkVirtualApplianceConnection struct {
	Id         *string                                      `json:"id,omitempty"`
	Name       *string                                      `json:"name,omitempty"`
	Properties *NetworkVirtualApplianceConnectionProperties `json:"properties,omitempty"`
}

type NetworkVirtualApplianceConnectionId ¶ 

type NetworkVirtualApplianceConnectionId struct {
	SubscriptionId                        string
	ResourceGroupName                     string
	NetworkVirtualApplianceName           string
	NetworkVirtualApplianceConnectionName string
}

NetworkVirtualApplianceConnectionId is a struct representing the Resource ID for a Network Virtual Appliance Connection

func NewNetworkVirtualApplianceConnectionID ¶ 

func NewNetworkVirtualApplianceConnectionID(subscriptionId string, resourceGroupName string, networkVirtualApplianceName string, networkVirtualApplianceConnectionName string) NetworkVirtualApplianceConnectionId

NewNetworkVirtualApplianceConnectionID returns a new NetworkVirtualApplianceConnectionId struct

func ParseNetworkVirtualApplianceConnectionID ¶ 

func ParseNetworkVirtualApplianceConnectionID(input string) (*NetworkVirtualApplianceConnectionId, error)

ParseNetworkVirtualApplianceConnectionID parses 'input' into a NetworkVirtualApplianceConnectionId

func ParseNetworkVirtualApplianceConnectionIDInsensitively ¶ 

func ParseNetworkVirtualApplianceConnectionIDInsensitively(input string) (*NetworkVirtualApplianceConnectionId, error)

ParseNetworkVirtualApplianceConnectionIDInsensitively parses 'input' case-insensitively into a NetworkVirtualApplianceConnectionId note: this method should only be used for API response data and not user input

func (*NetworkVirtualApplianceConnectionId) FromParseResult ¶ 

func (id *NetworkVirtualApplianceConnectionId) FromParseResult(input resourceids.ParseResult) error

func (NetworkVirtualApplianceConnectionId) ID ¶ 

func (id NetworkVirtualApplianceConnectionId) ID() string

ID returns the formatted Network Virtual Appliance Connection ID

func (NetworkVirtualApplianceConnectionId) Segments ¶ 

func (id NetworkVirtualApplianceConnectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Network Virtual Appliance Connection ID

func (NetworkVirtualApplianceConnectionId) String ¶ 

func (id NetworkVirtualApplianceConnectionId) String() string

String returns a human-readable description of this Network Virtual Appliance Connection ID

type NetworkVirtualApplianceConnectionOperationPredicate ¶ 

type NetworkVirtualApplianceConnectionOperationPredicate struct {
	Id   *string
	Name *string
}

func (NetworkVirtualApplianceConnectionOperationPredicate) Matches ¶ 

func (p NetworkVirtualApplianceConnectionOperationPredicate) Matches(input NetworkVirtualApplianceConnection) bool

type NetworkVirtualApplianceConnectionProperties ¶ 

type NetworkVirtualApplianceConnectionProperties struct {
	Asn                    *int64                `json:"asn,omitempty"`
	BgpPeerAddress         *[]string             `json:"bgpPeerAddress,omitempty"`
	EnableInternetSecurity *bool                 `json:"enableInternetSecurity,omitempty"`
	Name                   *string               `json:"name,omitempty"`
	ProvisioningState      *ProvisioningState    `json:"provisioningState,omitempty"`
	RoutingConfiguration   *RoutingConfiguration `json:"routingConfiguration,omitempty"`
	TunnelIdentifier       *int64                `json:"tunnelIdentifier,omitempty"`
}

type NetworkVirtualApplianceConnectionsCreateOrUpdateOperationResponse ¶ 

type NetworkVirtualApplianceConnectionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *NetworkVirtualApplianceConnection
}

type NetworkVirtualApplianceConnectionsDeleteOperationResponse ¶ 

type NetworkVirtualApplianceConnectionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type NetworkVirtualApplianceConnectionsGetOperationResponse ¶ 

type NetworkVirtualApplianceConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *NetworkVirtualApplianceConnection
}

type NetworkVirtualApplianceConnectionsListCompleteResult ¶ 

type NetworkVirtualApplianceConnectionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []NetworkVirtualApplianceConnection
}

type NetworkVirtualApplianceConnectionsListOperationResponse ¶ 

type NetworkVirtualApplianceConnectionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]NetworkVirtualApplianceConnection
}

type NetworkVirtualApplianceId ¶ 

type NetworkVirtualApplianceId struct {
	SubscriptionId              string
	ResourceGroupName           string
	NetworkVirtualApplianceName string
}

NetworkVirtualApplianceId is a struct representing the Resource ID for a Network Virtual Appliance

func NewNetworkVirtualApplianceID ¶ 

func NewNetworkVirtualApplianceID(subscriptionId string, resourceGroupName string, networkVirtualApplianceName string) NetworkVirtualApplianceId

NewNetworkVirtualApplianceID returns a new NetworkVirtualApplianceId struct

func ParseNetworkVirtualApplianceID ¶ 

func ParseNetworkVirtualApplianceID(input string) (*NetworkVirtualApplianceId, error)

ParseNetworkVirtualApplianceID parses 'input' into a NetworkVirtualApplianceId

func ParseNetworkVirtualApplianceIDInsensitively ¶ 

func ParseNetworkVirtualApplianceIDInsensitively(input string) (*NetworkVirtualApplianceId, error)

ParseNetworkVirtualApplianceIDInsensitively parses 'input' case-insensitively into a NetworkVirtualApplianceId note: this method should only be used for API response data and not user input

func (*NetworkVirtualApplianceId) FromParseResult ¶ 

func (id *NetworkVirtualApplianceId) FromParseResult(input resourceids.ParseResult) error

func (NetworkVirtualApplianceId) ID ¶ 

func (id NetworkVirtualApplianceId) ID() string

ID returns the formatted Network Virtual Appliance ID

func (NetworkVirtualApplianceId) Segments ¶ 

func (id NetworkVirtualApplianceId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Network Virtual Appliance ID

func (NetworkVirtualApplianceId) String ¶ 

func (id NetworkVirtualApplianceId) String() string

String returns a human-readable description of this Network Virtual Appliance ID

type NextStep ¶ 

type NextStep string
const (
	NextStepContinue  NextStep = "Continue"
	NextStepTerminate NextStep = "Terminate"
	NextStepUnknown   NextStep = "Unknown"
)

func (*NextStep) UnmarshalJSON ¶ 

func (s *NextStep) UnmarshalJSON(bytes []byte) error

type O365BreakOutCategoryPolicies ¶ 

type O365BreakOutCategoryPolicies struct {
	Allow    *bool `json:"allow,omitempty"`
	Default  *bool `json:"default,omitempty"`
	Optimize *bool `json:"optimize,omitempty"`
}

type O365PolicyProperties ¶ 

type O365PolicyProperties struct {
	BreakOutCategories *O365BreakOutCategoryPolicies `json:"breakOutCategories,omitempty"`
}

type OfficeTrafficCategory ¶ 

type OfficeTrafficCategory string
const (
	OfficeTrafficCategoryAll              OfficeTrafficCategory = "All"
	OfficeTrafficCategoryNone             OfficeTrafficCategory = "None"
	OfficeTrafficCategoryOptimize         OfficeTrafficCategory = "Optimize"
	OfficeTrafficCategoryOptimizeAndAllow OfficeTrafficCategory = "OptimizeAndAllow"
)

func (*OfficeTrafficCategory) UnmarshalJSON ¶ 

func (s *OfficeTrafficCategory) UnmarshalJSON(bytes []byte) error

type P2SConnectionConfiguration ¶ 

type P2SConnectionConfiguration struct {
	Etag       *string                               `json:"etag,omitempty"`
	Id         *string                               `json:"id,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties *P2SConnectionConfigurationProperties `json:"properties,omitempty"`
}

type P2SConnectionConfigurationProperties ¶ 

type P2SConnectionConfigurationProperties struct {
	ConfigurationPolicyGroupAssociations         *[]SubResource                       `json:"configurationPolicyGroupAssociations,omitempty"`
	EnableInternetSecurity                       *bool                                `json:"enableInternetSecurity,omitempty"`
	PreviousConfigurationPolicyGroupAssociations *[]VpnServerConfigurationPolicyGroup `json:"previousConfigurationPolicyGroupAssociations,omitempty"`
	ProvisioningState                            *ProvisioningState                   `json:"provisioningState,omitempty"`
	RoutingConfiguration                         *RoutingConfiguration                `json:"routingConfiguration,omitempty"`
	VpnClientAddressPool                         *AddressSpace                        `json:"vpnClientAddressPool,omitempty"`
}

type P2SVpnGateway ¶ 

type P2SVpnGateway struct {
	Etag       *string                  `json:"etag,omitempty"`
	Id         *string                  `json:"id,omitempty"`
	Location   *string                  `json:"location,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *P2SVpnGatewayProperties `json:"properties,omitempty"`
	Tags       *map[string]string       `json:"tags,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type P2SVpnGatewayOperationPredicate ¶ 

type P2SVpnGatewayOperationPredicate struct {
	Etag     *string
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (P2SVpnGatewayOperationPredicate) Matches ¶ 

func (p P2SVpnGatewayOperationPredicate) Matches(input P2SVpnGateway) bool

type P2SVpnGatewayProperties ¶ 

type P2SVpnGatewayProperties struct {
	CustomDnsServers            *[]string                     `json:"customDnsServers,omitempty"`
	IsRoutingPreferenceInternet *bool                         `json:"isRoutingPreferenceInternet,omitempty"`
	P2SConnectionConfigurations *[]P2SConnectionConfiguration `json:"p2SConnectionConfigurations,omitempty"`
	ProvisioningState           *ProvisioningState            `json:"provisioningState,omitempty"`
	VirtualHub                  *SubResource                  `json:"virtualHub,omitempty"`
	VpnClientConnectionHealth   *VpnClientConnectionHealth    `json:"vpnClientConnectionHealth,omitempty"`
	VpnGatewayScaleUnit         *int64                        `json:"vpnGatewayScaleUnit,omitempty"`
	VpnServerConfiguration      *SubResource                  `json:"vpnServerConfiguration,omitempty"`
}

type P2sVpnGatewaysCreateOrUpdateOperationResponse ¶ 

type P2sVpnGatewaysCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *P2SVpnGateway
}

type P2sVpnGatewaysDeleteOperationResponse ¶ 

type P2sVpnGatewaysDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type P2sVpnGatewaysGetOperationResponse ¶ 

type P2sVpnGatewaysGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *P2SVpnGateway
}

type P2sVpnGatewaysListByResourceGroupCompleteResult ¶ 

type P2sVpnGatewaysListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []P2SVpnGateway
}

type P2sVpnGatewaysListByResourceGroupOperationResponse ¶ 

type P2sVpnGatewaysListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]P2SVpnGateway
}

type P2sVpnGatewaysListCompleteResult ¶ 

type P2sVpnGatewaysListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []P2SVpnGateway
}

type P2sVpnGatewaysListOperationResponse ¶ 

type P2sVpnGatewaysListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]P2SVpnGateway
}

type Parameter ¶ 

type Parameter struct {
	AsPath      *[]string `json:"asPath,omitempty"`
	Community   *[]string `json:"community,omitempty"`
	RoutePrefix *[]string `json:"routePrefix,omitempty"`
}

type PeerRoute ¶ 

type PeerRoute struct {
	AsPath       *string `json:"asPath,omitempty"`
	LocalAddress *string `json:"localAddress,omitempty"`
	Network      *string `json:"network,omitempty"`
	NextHop      *string `json:"nextHop,omitempty"`
	Origin       *string `json:"origin,omitempty"`
	SourcePeer   *string `json:"sourcePeer,omitempty"`
	Weight       *int64  `json:"weight,omitempty"`
}

type PfsGroup ¶ 

type PfsGroup string
const (
	PfsGroupECPThreeEightFour   PfsGroup = "ECP384"
	PfsGroupECPTwoFiveSix       PfsGroup = "ECP256"
	PfsGroupNone                PfsGroup = "None"
	PfsGroupPFSMM               PfsGroup = "PFSMM"
	PfsGroupPFSOne              PfsGroup = "PFS1"
	PfsGroupPFSOneFour          PfsGroup = "PFS14"
	PfsGroupPFSTwo              PfsGroup = "PFS2"
	PfsGroupPFSTwoFour          PfsGroup = "PFS24"
	PfsGroupPFSTwoZeroFourEight PfsGroup = "PFS2048"
)

func (*PfsGroup) UnmarshalJSON ¶ 

func (s *PfsGroup) UnmarshalJSON(bytes []byte) error

type PreferredRoutingGateway ¶ 

type PreferredRoutingGateway string
const (
	PreferredRoutingGatewayExpressRoute PreferredRoutingGateway = "ExpressRoute"
	PreferredRoutingGatewayNone         PreferredRoutingGateway = "None"
	PreferredRoutingGatewayVpnGateway   PreferredRoutingGateway = "VpnGateway"
)

func (*PreferredRoutingGateway) UnmarshalJSON ¶ 

func (s *PreferredRoutingGateway) UnmarshalJSON(bytes []byte) error

type PrivateEndpoint ¶ 

type PrivateEndpoint struct {
	Etag             *string                    `json:"etag,omitempty"`
	ExtendedLocation *edgezones.Model           `json:"extendedLocation,omitempty"`
	Id               *string                    `json:"id,omitempty"`
	Location         *string                    `json:"location,omitempty"`
	Name             *string                    `json:"name,omitempty"`
	Properties       *PrivateEndpointProperties `json:"properties,omitempty"`
	Tags             *map[string]string         `json:"tags,omitempty"`
	Type             *string                    `json:"type,omitempty"`
}

type PrivateEndpointConnection ¶ 

type PrivateEndpointConnection struct {
	Etag       *string                              `json:"etag,omitempty"`
	Id         *string                              `json:"id,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type PrivateEndpointConnectionProperties ¶ 

type PrivateEndpointConnectionProperties struct {
	LinkIdentifier                    *string                            `json:"linkIdentifier,omitempty"`
	PrivateEndpoint                   *PrivateEndpoint                   `json:"privateEndpoint,omitempty"`
	PrivateEndpointLocation           *string                            `json:"privateEndpointLocation,omitempty"`
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"privateLinkServiceConnectionState,omitempty"`
	ProvisioningState                 *ProvisioningState                 `json:"provisioningState,omitempty"`
}

type PrivateEndpointIPConfiguration ¶ 

type PrivateEndpointIPConfiguration struct {
	Etag       *string                                   `json:"etag,omitempty"`
	Name       *string                                   `json:"name,omitempty"`
	Properties *PrivateEndpointIPConfigurationProperties `json:"properties,omitempty"`
	Type       *string                                   `json:"type,omitempty"`
}

type PrivateEndpointIPConfigurationProperties ¶ 

type PrivateEndpointIPConfigurationProperties struct {
	GroupId          *string `json:"groupId,omitempty"`
	MemberName       *string `json:"memberName,omitempty"`
	PrivateIPAddress *string `json:"privateIPAddress,omitempty"`
}

type PrivateEndpointProperties ¶ 

type PrivateEndpointProperties struct {
	ApplicationSecurityGroups           *[]ApplicationSecurityGroup        `json:"applicationSecurityGroups,omitempty"`
	CustomDnsConfigs                    *[]CustomDnsConfigPropertiesFormat `json:"customDnsConfigs,omitempty"`
	CustomNetworkInterfaceName          *string                            `json:"customNetworkInterfaceName,omitempty"`
	IPConfigurations                    *[]PrivateEndpointIPConfiguration  `json:"ipConfigurations,omitempty"`
	ManualPrivateLinkServiceConnections *[]PrivateLinkServiceConnection    `json:"manualPrivateLinkServiceConnections,omitempty"`
	NetworkInterfaces                   *[]NetworkInterface                `json:"networkInterfaces,omitempty"`
	PrivateLinkServiceConnections       *[]PrivateLinkServiceConnection    `json:"privateLinkServiceConnections,omitempty"`
	ProvisioningState                   *ProvisioningState                 `json:"provisioningState,omitempty"`
	Subnet                              *Subnet                            `json:"subnet,omitempty"`
}

type PrivateLinkService ¶ 

type PrivateLinkService struct {
	Etag             *string                       `json:"etag,omitempty"`
	ExtendedLocation *edgezones.Model              `json:"extendedLocation,omitempty"`
	Id               *string                       `json:"id,omitempty"`
	Location         *string                       `json:"location,omitempty"`
	Name             *string                       `json:"name,omitempty"`
	Properties       *PrivateLinkServiceProperties `json:"properties,omitempty"`
	Tags             *map[string]string            `json:"tags,omitempty"`
	Type             *string                       `json:"type,omitempty"`
}

type PrivateLinkServiceConnection ¶ 

type PrivateLinkServiceConnection struct {
	Etag       *string                                 `json:"etag,omitempty"`
	Id         *string                                 `json:"id,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties *PrivateLinkServiceConnectionProperties `json:"properties,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type PrivateLinkServiceConnectionProperties ¶ 

type PrivateLinkServiceConnectionProperties struct {
	GroupIds                          *[]string                          `json:"groupIds,omitempty"`
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"privateLinkServiceConnectionState,omitempty"`
	PrivateLinkServiceId              *string                            `json:"privateLinkServiceId,omitempty"`
	ProvisioningState                 *ProvisioningState                 `json:"provisioningState,omitempty"`
	RequestMessage                    *string                            `json:"requestMessage,omitempty"`
}

type PrivateLinkServiceConnectionState ¶ 

type PrivateLinkServiceConnectionState struct {
	ActionsRequired *string `json:"actionsRequired,omitempty"`
	Description     *string `json:"description,omitempty"`
	Status          *string `json:"status,omitempty"`
}

type PrivateLinkServiceIPConfiguration ¶ 

type PrivateLinkServiceIPConfiguration struct {
	Etag       *string                                      `json:"etag,omitempty"`
	Id         *string                                      `json:"id,omitempty"`
	Name       *string                                      `json:"name,omitempty"`
	Properties *PrivateLinkServiceIPConfigurationProperties `json:"properties,omitempty"`
	Type       *string                                      `json:"type,omitempty"`
}

type PrivateLinkServiceIPConfigurationProperties ¶ 

type PrivateLinkServiceIPConfigurationProperties struct {
	Primary                   *bool               `json:"primary,omitempty"`
	PrivateIPAddress          *string             `json:"privateIPAddress,omitempty"`
	PrivateIPAddressVersion   *IPVersion          `json:"privateIPAddressVersion,omitempty"`
	PrivateIPAllocationMethod *IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
	ProvisioningState         *ProvisioningState  `json:"provisioningState,omitempty"`
	Subnet                    *Subnet             `json:"subnet,omitempty"`
}

type PrivateLinkServiceProperties ¶ 

type PrivateLinkServiceProperties struct {
	Alias                                *string                              `json:"alias,omitempty"`
	AutoApproval                         *ResourceSet                         `json:"autoApproval,omitempty"`
	EnableProxyProtocol                  *bool                                `json:"enableProxyProtocol,omitempty"`
	Fqdns                                *[]string                            `json:"fqdns,omitempty"`
	IPConfigurations                     *[]PrivateLinkServiceIPConfiguration `json:"ipConfigurations,omitempty"`
	LoadBalancerFrontendIPConfigurations *[]FrontendIPConfiguration           `json:"loadBalancerFrontendIpConfigurations,omitempty"`
	NetworkInterfaces                    *[]NetworkInterface                  `json:"networkInterfaces,omitempty"`
	PrivateEndpointConnections           *[]PrivateEndpointConnection         `json:"privateEndpointConnections,omitempty"`
	ProvisioningState                    *ProvisioningState                   `json:"provisioningState,omitempty"`
	Visibility                           *ResourceSet                         `json:"visibility,omitempty"`
}

type PropagatedRouteTable ¶ 

type PropagatedRouteTable struct {
	Ids    *[]SubResource `json:"ids,omitempty"`
	Labels *[]string      `json:"labels,omitempty"`
}

type ProvisioningState ¶ 

type ProvisioningState string
const (
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	ProvisioningStateUpdating  ProvisioningState = "Updating"
)

func (*ProvisioningState) UnmarshalJSON ¶ 

func (s *ProvisioningState) UnmarshalJSON(bytes []byte) error

type PublicIPAddress ¶ 

type PublicIPAddress struct {
	Etag             *string                          `json:"etag,omitempty"`
	ExtendedLocation *edgezones.Model                 `json:"extendedLocation,omitempty"`
	Id               *string                          `json:"id,omitempty"`
	Location         *string                          `json:"location,omitempty"`
	Name             *string                          `json:"name,omitempty"`
	Properties       *PublicIPAddressPropertiesFormat `json:"properties,omitempty"`
	Sku              *PublicIPAddressSku              `json:"sku,omitempty"`
	Tags             *map[string]string               `json:"tags,omitempty"`
	Type             *string                          `json:"type,omitempty"`
	Zones            *zones.Schema                    `json:"zones,omitempty"`
}

type PublicIPAddressDnsSettings ¶ 

type PublicIPAddressDnsSettings struct {
	DomainNameLabel      *string                                         `json:"domainNameLabel,omitempty"`
	DomainNameLabelScope *PublicIPAddressDnsSettingsDomainNameLabelScope `json:"domainNameLabelScope,omitempty"`
	Fqdn                 *string                                         `json:"fqdn,omitempty"`
	ReverseFqdn          *string                                         `json:"reverseFqdn,omitempty"`
}

type PublicIPAddressDnsSettingsDomainNameLabelScope ¶ 

type PublicIPAddressDnsSettingsDomainNameLabelScope string
const (
	PublicIPAddressDnsSettingsDomainNameLabelScopeNoReuse            PublicIPAddressDnsSettingsDomainNameLabelScope = "NoReuse"
	PublicIPAddressDnsSettingsDomainNameLabelScopeResourceGroupReuse PublicIPAddressDnsSettingsDomainNameLabelScope = "ResourceGroupReuse"
	PublicIPAddressDnsSettingsDomainNameLabelScopeSubscriptionReuse  PublicIPAddressDnsSettingsDomainNameLabelScope = "SubscriptionReuse"
	PublicIPAddressDnsSettingsDomainNameLabelScopeTenantReuse        PublicIPAddressDnsSettingsDomainNameLabelScope = "TenantReuse"
)

func (*PublicIPAddressDnsSettingsDomainNameLabelScope) UnmarshalJSON ¶ 

func (s *PublicIPAddressDnsSettingsDomainNameLabelScope) UnmarshalJSON(bytes []byte) error

type PublicIPAddressMigrationPhase ¶ 

type PublicIPAddressMigrationPhase string
const (
	PublicIPAddressMigrationPhaseAbort     PublicIPAddressMigrationPhase = "Abort"
	PublicIPAddressMigrationPhaseCommit    PublicIPAddressMigrationPhase = "Commit"
	PublicIPAddressMigrationPhaseCommitted PublicIPAddressMigrationPhase = "Committed"
	PublicIPAddressMigrationPhaseNone      PublicIPAddressMigrationPhase = "None"
	PublicIPAddressMigrationPhasePrepare   PublicIPAddressMigrationPhase = "Prepare"
)

func (*PublicIPAddressMigrationPhase) UnmarshalJSON ¶ 

func (s *PublicIPAddressMigrationPhase) UnmarshalJSON(bytes []byte) error

type PublicIPAddressPropertiesFormat ¶ 

type PublicIPAddressPropertiesFormat struct {
	DdosSettings             *DdosSettings                  `json:"ddosSettings,omitempty"`
	DeleteOption             *DeleteOptions                 `json:"deleteOption,omitempty"`
	DnsSettings              *PublicIPAddressDnsSettings    `json:"dnsSettings,omitempty"`
	IPAddress                *string                        `json:"ipAddress,omitempty"`
	IPConfiguration          *IPConfiguration               `json:"ipConfiguration,omitempty"`
	IPTags                   *[]IPTag                       `json:"ipTags,omitempty"`
	IdleTimeoutInMinutes     *int64                         `json:"idleTimeoutInMinutes,omitempty"`
	LinkedPublicIPAddress    *PublicIPAddress               `json:"linkedPublicIPAddress,omitempty"`
	MigrationPhase           *PublicIPAddressMigrationPhase `json:"migrationPhase,omitempty"`
	NatGateway               *NatGateway                    `json:"natGateway,omitempty"`
	ProvisioningState        *ProvisioningState             `json:"provisioningState,omitempty"`
	PublicIPAddressVersion   *IPVersion                     `json:"publicIPAddressVersion,omitempty"`
	PublicIPAllocationMethod *IPAllocationMethod            `json:"publicIPAllocationMethod,omitempty"`
	PublicIPPrefix           *SubResource                   `json:"publicIPPrefix,omitempty"`
	ResourceGuid             *string                        `json:"resourceGuid,omitempty"`
	ServicePublicIPAddress   *PublicIPAddress               `json:"servicePublicIPAddress,omitempty"`
}

type PublicIPAddressSku ¶ 

type PublicIPAddressSku struct {
	Name *PublicIPAddressSkuName `json:"name,omitempty"`
	Tier *PublicIPAddressSkuTier `json:"tier,omitempty"`
}

type PublicIPAddressSkuName ¶ 

type PublicIPAddressSkuName string
const (
	PublicIPAddressSkuNameBasic    PublicIPAddressSkuName = "Basic"
	PublicIPAddressSkuNameStandard PublicIPAddressSkuName = "Standard"
)

func (*PublicIPAddressSkuName) UnmarshalJSON ¶ 

func (s *PublicIPAddressSkuName) UnmarshalJSON(bytes []byte) error

type PublicIPAddressSkuTier ¶ 

type PublicIPAddressSkuTier string
const (
	PublicIPAddressSkuTierGlobal   PublicIPAddressSkuTier = "Global"
	PublicIPAddressSkuTierRegional PublicIPAddressSkuTier = "Regional"
)

func (*PublicIPAddressSkuTier) UnmarshalJSON ¶ 

func (s *PublicIPAddressSkuTier) UnmarshalJSON(bytes []byte) error

type RadiusServer ¶ 

type RadiusServer struct {
	RadiusServerAddress string  `json:"radiusServerAddress"`
	RadiusServerScore   *int64  `json:"radiusServerScore,omitempty"`
	RadiusServerSecret  *string `json:"radiusServerSecret,omitempty"`
}
type ResourceNavigationLink struct {
	Etag       *string                       `json:"etag,omitempty"`
	Id         *string                       `json:"id,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *ResourceNavigationLinkFormat `json:"properties,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type ResourceNavigationLinkFormat ¶ 

type ResourceNavigationLinkFormat struct {
	Link               *string            `json:"link,omitempty"`
	LinkedResourceType *string            `json:"linkedResourceType,omitempty"`
	ProvisioningState  *ProvisioningState `json:"provisioningState,omitempty"`
}

type ResourceSet ¶ 

type ResourceSet struct {
	Subscriptions *[]string `json:"subscriptions,omitempty"`
}

type RetentionPolicyParameters ¶ 

type RetentionPolicyParameters struct {
	Days    *int64 `json:"days,omitempty"`
	Enabled *bool  `json:"enabled,omitempty"`
}

type Route ¶ 

type Route struct {
	Etag       *string                `json:"etag,omitempty"`
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *RoutePropertiesFormat `json:"properties,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type RouteMap ¶ 

type RouteMap struct {
	Etag       *string             `json:"etag,omitempty"`
	Id         *string             `json:"id,omitempty"`
	Name       *string             `json:"name,omitempty"`
	Properties *RouteMapProperties `json:"properties,omitempty"`
	Type       *string             `json:"type,omitempty"`
}

type RouteMapActionType ¶ 

type RouteMapActionType string
const (
	RouteMapActionTypeAdd     RouteMapActionType = "Add"
	RouteMapActionTypeDrop    RouteMapActionType = "Drop"
	RouteMapActionTypeRemove  RouteMapActionType = "Remove"
	RouteMapActionTypeReplace RouteMapActionType = "Replace"
	RouteMapActionTypeUnknown RouteMapActionType = "Unknown"
)

func (*RouteMapActionType) UnmarshalJSON ¶ 

func (s *RouteMapActionType) UnmarshalJSON(bytes []byte) error

type RouteMapId ¶ 

type RouteMapId struct {
	SubscriptionId    string
	ResourceGroupName string
	VirtualHubName    string
	RouteMapName      string
}

RouteMapId is a struct representing the Resource ID for a Route Map

func NewRouteMapID ¶ 

func NewRouteMapID(subscriptionId string, resourceGroupName string, virtualHubName string, routeMapName string) RouteMapId

NewRouteMapID returns a new RouteMapId struct

func ParseRouteMapID ¶ 

func ParseRouteMapID(input string) (*RouteMapId, error)

ParseRouteMapID parses 'input' into a RouteMapId

func ParseRouteMapIDInsensitively ¶ 

func ParseRouteMapIDInsensitively(input string) (*RouteMapId, error)

ParseRouteMapIDInsensitively parses 'input' case-insensitively into a RouteMapId note: this method should only be used for API response data and not user input

func (*RouteMapId) FromParseResult ¶ 

func (id *RouteMapId) FromParseResult(input resourceids.ParseResult) error

func (RouteMapId) ID ¶ 

func (id RouteMapId) ID() string

ID returns the formatted Route Map ID

func (RouteMapId) Segments ¶ 

func (id RouteMapId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Route Map ID

func (RouteMapId) String ¶ 

func (id RouteMapId) String() string

String returns a human-readable description of this Route Map ID

type RouteMapMatchCondition ¶ 

type RouteMapMatchCondition string
const (
	RouteMapMatchConditionContains    RouteMapMatchCondition = "Contains"
	RouteMapMatchConditionEquals      RouteMapMatchCondition = "Equals"
	RouteMapMatchConditionNotContains RouteMapMatchCondition = "NotContains"
	RouteMapMatchConditionNotEquals   RouteMapMatchCondition = "NotEquals"
	RouteMapMatchConditionUnknown     RouteMapMatchCondition = "Unknown"
)

func (*RouteMapMatchCondition) UnmarshalJSON ¶ 

func (s *RouteMapMatchCondition) UnmarshalJSON(bytes []byte) error

type RouteMapOperationPredicate ¶ 

type RouteMapOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (RouteMapOperationPredicate) Matches ¶ 

func (p RouteMapOperationPredicate) Matches(input RouteMap) bool

type RouteMapProperties ¶ 

type RouteMapProperties struct {
	AssociatedInboundConnections  *[]string          `json:"associatedInboundConnections,omitempty"`
	AssociatedOutboundConnections *[]string          `json:"associatedOutboundConnections,omitempty"`
	ProvisioningState             *ProvisioningState `json:"provisioningState,omitempty"`
	Rules                         *[]RouteMapRule    `json:"rules,omitempty"`
}

type RouteMapRule ¶ 

type RouteMapRule struct {
	Actions           *[]Action    `json:"actions,omitempty"`
	MatchCriteria     *[]Criterion `json:"matchCriteria,omitempty"`
	Name              *string      `json:"name,omitempty"`
	NextStepIfMatched *NextStep    `json:"nextStepIfMatched,omitempty"`
}

type RouteMapsCreateOrUpdateOperationResponse ¶ 

type RouteMapsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *RouteMap
}

type RouteMapsDeleteOperationResponse ¶ 

type RouteMapsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type RouteMapsGetOperationResponse ¶ 

type RouteMapsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *RouteMap
}

type RouteMapsListCompleteResult ¶ 

type RouteMapsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []RouteMap
}

type RouteMapsListOperationResponse ¶ 

type RouteMapsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]RouteMap
}

type RouteNextHopType ¶ 

type RouteNextHopType string
const (
	RouteNextHopTypeInternet              RouteNextHopType = "Internet"
	RouteNextHopTypeNone                  RouteNextHopType = "None"
	RouteNextHopTypeVirtualAppliance      RouteNextHopType = "VirtualAppliance"
	RouteNextHopTypeVirtualNetworkGateway RouteNextHopType = "VirtualNetworkGateway"
	RouteNextHopTypeVnetLocal             RouteNextHopType = "VnetLocal"
)

func (*RouteNextHopType) UnmarshalJSON ¶ 

func (s *RouteNextHopType) UnmarshalJSON(bytes []byte) error

type RoutePropertiesFormat ¶ 

type RoutePropertiesFormat struct {
	AddressPrefix     *string            `json:"addressPrefix,omitempty"`
	HasBgpOverride    *bool              `json:"hasBgpOverride,omitempty"`
	NextHopIPAddress  *string            `json:"nextHopIpAddress,omitempty"`
	NextHopType       RouteNextHopType   `json:"nextHopType"`
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
}

type RouteTable ¶ 

type RouteTable struct {
	Etag       *string                     `json:"etag,omitempty"`
	Id         *string                     `json:"id,omitempty"`
	Location   *string                     `json:"location,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties *RouteTablePropertiesFormat `json:"properties,omitempty"`
	Tags       *map[string]string          `json:"tags,omitempty"`
	Type       *string                     `json:"type,omitempty"`
}

type RouteTablePropertiesFormat ¶ 

type RouteTablePropertiesFormat struct {
	DisableBgpRoutePropagation *bool              `json:"disableBgpRoutePropagation,omitempty"`
	ProvisioningState          *ProvisioningState `json:"provisioningState,omitempty"`
	ResourceGuid               *string            `json:"resourceGuid,omitempty"`
	Routes                     *[]Route           `json:"routes,omitempty"`
	Subnets                    *[]Subnet          `json:"subnets,omitempty"`
}

type RoutingConfiguration ¶ 

type RoutingConfiguration struct {
	AssociatedRouteTable  *SubResource          `json:"associatedRouteTable,omitempty"`
	InboundRouteMap       *SubResource          `json:"inboundRouteMap,omitempty"`
	OutboundRouteMap      *SubResource          `json:"outboundRouteMap,omitempty"`
	PropagatedRouteTables *PropagatedRouteTable `json:"propagatedRouteTables,omitempty"`
	VnetRoutes            *VnetRoute            `json:"vnetRoutes,omitempty"`
}

type RoutingIntent ¶ 

type RoutingIntent struct {
	Etag       *string                  `json:"etag,omitempty"`
	Id         *string                  `json:"id,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *RoutingIntentProperties `json:"properties,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type RoutingIntentCreateOrUpdateOperationResponse ¶ 

type RoutingIntentCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *RoutingIntent
}

type RoutingIntentDeleteOperationResponse ¶ 

type RoutingIntentDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type RoutingIntentGetOperationResponse ¶ 

type RoutingIntentGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *RoutingIntent
}

type RoutingIntentId ¶ 

type RoutingIntentId struct {
	SubscriptionId    string
	ResourceGroupName string
	VirtualHubName    string
	RoutingIntentName string
}

RoutingIntentId is a struct representing the Resource ID for a Routing Intent

func NewRoutingIntentID ¶ 

func NewRoutingIntentID(subscriptionId string, resourceGroupName string, virtualHubName string, routingIntentName string) RoutingIntentId

NewRoutingIntentID returns a new RoutingIntentId struct

func ParseRoutingIntentID ¶ 

func ParseRoutingIntentID(input string) (*RoutingIntentId, error)

ParseRoutingIntentID parses 'input' into a RoutingIntentId

func ParseRoutingIntentIDInsensitively ¶ 

func ParseRoutingIntentIDInsensitively(input string) (*RoutingIntentId, error)

ParseRoutingIntentIDInsensitively parses 'input' case-insensitively into a RoutingIntentId note: this method should only be used for API response data and not user input

func (*RoutingIntentId) FromParseResult ¶ 

func (id *RoutingIntentId) FromParseResult(input resourceids.ParseResult) error

func (RoutingIntentId) ID ¶ 

func (id RoutingIntentId) ID() string

ID returns the formatted Routing Intent ID

func (RoutingIntentId) Segments ¶ 

func (id RoutingIntentId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Routing Intent ID

func (RoutingIntentId) String ¶ 

func (id RoutingIntentId) String() string

String returns a human-readable description of this Routing Intent ID

type RoutingIntentListCompleteResult ¶ 

type RoutingIntentListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []RoutingIntent
}

type RoutingIntentListOperationResponse ¶ 

type RoutingIntentListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]RoutingIntent
}

type RoutingIntentOperationPredicate ¶ 

type RoutingIntentOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (RoutingIntentOperationPredicate) Matches ¶ 

func (p RoutingIntentOperationPredicate) Matches(input RoutingIntent) bool

type RoutingIntentProperties ¶ 

type RoutingIntentProperties struct {
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	RoutingPolicies   *[]RoutingPolicy   `json:"routingPolicies,omitempty"`
}

type RoutingPolicy ¶ 

type RoutingPolicy struct {
	Destinations []string `json:"destinations"`
	Name         string   `json:"name"`
	NextHop      string   `json:"nextHop"`
}

type RoutingState ¶ 

type RoutingState string
const (
	RoutingStateFailed       RoutingState = "Failed"
	RoutingStateNone         RoutingState = "None"
	RoutingStateProvisioned  RoutingState = "Provisioned"
	RoutingStateProvisioning RoutingState = "Provisioning"
)

func (*RoutingState) UnmarshalJSON ¶ 

func (s *RoutingState) UnmarshalJSON(bytes []byte) error

type SecurityRule ¶ 

type SecurityRule struct {
	Etag       *string                       `json:"etag,omitempty"`
	Id         *string                       `json:"id,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *SecurityRulePropertiesFormat `json:"properties,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type SecurityRuleAccess ¶ 

type SecurityRuleAccess string
const (
	SecurityRuleAccessAllow SecurityRuleAccess = "Allow"
	SecurityRuleAccessDeny  SecurityRuleAccess = "Deny"
)

func (*SecurityRuleAccess) UnmarshalJSON ¶ 

func (s *SecurityRuleAccess) UnmarshalJSON(bytes []byte) error

type SecurityRuleDirection ¶ 

type SecurityRuleDirection string
const (
	SecurityRuleDirectionInbound  SecurityRuleDirection = "Inbound"
	SecurityRuleDirectionOutbound SecurityRuleDirection = "Outbound"
)

func (*SecurityRuleDirection) UnmarshalJSON ¶ 

func (s *SecurityRuleDirection) UnmarshalJSON(bytes []byte) error

type SecurityRulePropertiesFormat ¶ 

type SecurityRulePropertiesFormat struct {
	Access                               SecurityRuleAccess          `json:"access"`
	Description                          *string                     `json:"description,omitempty"`
	DestinationAddressPrefix             *string                     `json:"destinationAddressPrefix,omitempty"`
	DestinationAddressPrefixes           *[]string                   `json:"destinationAddressPrefixes,omitempty"`
	DestinationApplicationSecurityGroups *[]ApplicationSecurityGroup `json:"destinationApplicationSecurityGroups,omitempty"`
	DestinationPortRange                 *string                     `json:"destinationPortRange,omitempty"`
	DestinationPortRanges                *[]string                   `json:"destinationPortRanges,omitempty"`
	Direction                            SecurityRuleDirection       `json:"direction"`
	Priority                             int64                       `json:"priority"`
	Protocol                             SecurityRuleProtocol        `json:"protocol"`
	ProvisioningState                    *ProvisioningState          `json:"provisioningState,omitempty"`
	SourceAddressPrefix                  *string                     `json:"sourceAddressPrefix,omitempty"`
	SourceAddressPrefixes                *[]string                   `json:"sourceAddressPrefixes,omitempty"`
	SourceApplicationSecurityGroups      *[]ApplicationSecurityGroup `json:"sourceApplicationSecurityGroups,omitempty"`
	SourcePortRange                      *string                     `json:"sourcePortRange,omitempty"`
	SourcePortRanges                     *[]string                   `json:"sourcePortRanges,omitempty"`
}

type SecurityRuleProtocol ¶ 

type SecurityRuleProtocol string
const (
	SecurityRuleProtocolAh   SecurityRuleProtocol = "Ah"
	SecurityRuleProtocolAny  SecurityRuleProtocol = "*"
	SecurityRuleProtocolEsp  SecurityRuleProtocol = "Esp"
	SecurityRuleProtocolIcmp SecurityRuleProtocol = "Icmp"
	SecurityRuleProtocolTcp  SecurityRuleProtocol = "Tcp"
	SecurityRuleProtocolUdp  SecurityRuleProtocol = "Udp"
)

func (*SecurityRuleProtocol) UnmarshalJSON ¶ 

func (s *SecurityRuleProtocol) UnmarshalJSON(bytes []byte) error
type ServiceAssociationLink struct {
	Etag       *string                                 `json:"etag,omitempty"`
	Id         *string                                 `json:"id,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties *ServiceAssociationLinkPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type ServiceAssociationLinkPropertiesFormat ¶ 

type ServiceAssociationLinkPropertiesFormat struct {
	AllowDelete        *bool              `json:"allowDelete,omitempty"`
	Link               *string            `json:"link,omitempty"`
	LinkedResourceType *string            `json:"linkedResourceType,omitempty"`
	Locations          *[]string          `json:"locations,omitempty"`
	ProvisioningState  *ProvisioningState `json:"provisioningState,omitempty"`
}

type ServiceDelegationPropertiesFormat ¶ 

type ServiceDelegationPropertiesFormat struct {
	Actions           *[]string          `json:"actions,omitempty"`
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	ServiceName       *string            `json:"serviceName,omitempty"`
}

type ServiceEndpointPolicy ¶ 

type ServiceEndpointPolicy struct {
	Etag       *string                                `json:"etag,omitempty"`
	Id         *string                                `json:"id,omitempty"`
	Kind       *string                                `json:"kind,omitempty"`
	Location   *string                                `json:"location,omitempty"`
	Name       *string                                `json:"name,omitempty"`
	Properties *ServiceEndpointPolicyPropertiesFormat `json:"properties,omitempty"`
	Tags       *map[string]string                     `json:"tags,omitempty"`
	Type       *string                                `json:"type,omitempty"`
}

type ServiceEndpointPolicyDefinition ¶ 

type ServiceEndpointPolicyDefinition struct {
	Etag       *string                                          `json:"etag,omitempty"`
	Id         *string                                          `json:"id,omitempty"`
	Name       *string                                          `json:"name,omitempty"`
	Properties *ServiceEndpointPolicyDefinitionPropertiesFormat `json:"properties,omitempty"`
	Type       *string                                          `json:"type,omitempty"`
}

type ServiceEndpointPolicyDefinitionPropertiesFormat ¶ 

type ServiceEndpointPolicyDefinitionPropertiesFormat struct {
	Description       *string            `json:"description,omitempty"`
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	Service           *string            `json:"service,omitempty"`
	ServiceResources  *[]string          `json:"serviceResources,omitempty"`
}

type ServiceEndpointPolicyPropertiesFormat ¶ 

type ServiceEndpointPolicyPropertiesFormat struct {
	ContextualServiceEndpointPolicies *[]string                          `json:"contextualServiceEndpointPolicies,omitempty"`
	ProvisioningState                 *ProvisioningState                 `json:"provisioningState,omitempty"`
	ResourceGuid                      *string                            `json:"resourceGuid,omitempty"`
	ServiceAlias                      *string                            `json:"serviceAlias,omitempty"`
	ServiceEndpointPolicyDefinitions  *[]ServiceEndpointPolicyDefinition `json:"serviceEndpointPolicyDefinitions,omitempty"`
	Subnets                           *[]Subnet                          `json:"subnets,omitempty"`
}

type ServiceEndpointPropertiesFormat ¶ 

type ServiceEndpointPropertiesFormat struct {
	Locations         *[]string          `json:"locations,omitempty"`
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
	Service           *string            `json:"service,omitempty"`
}

type SharingScope ¶ 

type SharingScope string
const (
	SharingScopeDelegatedServices SharingScope = "DelegatedServices"
	SharingScopeTenant            SharingScope = "Tenant"
)

func (*SharingScope) UnmarshalJSON ¶ 

func (s *SharingScope) UnmarshalJSON(bytes []byte) error

type StaticRoute ¶ 

type StaticRoute struct {
	AddressPrefixes  *[]string `json:"addressPrefixes,omitempty"`
	Name             *string   `json:"name,omitempty"`
	NextHopIPAddress *string   `json:"nextHopIpAddress,omitempty"`
}

type StaticRoutesConfig ¶ 

type StaticRoutesConfig struct {
	PropagateStaticRoutes          *bool                           `json:"propagateStaticRoutes,omitempty"`
	VnetLocalRouteOverrideCriteria *VnetLocalRouteOverrideCriteria `json:"vnetLocalRouteOverrideCriteria,omitempty"`
}

type SubResource ¶ 

type SubResource struct {
	Id *string `json:"id,omitempty"`
}

type Subnet ¶ 

type Subnet struct {
	Etag       *string                 `json:"etag,omitempty"`
	Id         *string                 `json:"id,omitempty"`
	Name       *string                 `json:"name,omitempty"`
	Properties *SubnetPropertiesFormat `json:"properties,omitempty"`
	Type       *string                 `json:"type,omitempty"`
}

type SubnetPropertiesFormat ¶ 

type SubnetPropertiesFormat struct {
	AddressPrefix                      *string                                          `json:"addressPrefix,omitempty"`
	AddressPrefixes                    *[]string                                        `json:"addressPrefixes,omitempty"`
	ApplicationGatewayIPConfigurations *[]ApplicationGatewayIPConfiguration             `json:"applicationGatewayIPConfigurations,omitempty"`
	DefaultOutboundAccess              *bool                                            `json:"defaultOutboundAccess,omitempty"`
	Delegations                        *[]Delegation                                    `json:"delegations,omitempty"`
	IPAllocations                      *[]SubResource                                   `json:"ipAllocations,omitempty"`
	IPConfigurationProfiles            *[]IPConfigurationProfile                        `json:"ipConfigurationProfiles,omitempty"`
	IPConfigurations                   *[]IPConfiguration                               `json:"ipConfigurations,omitempty"`
	NatGateway                         *SubResource                                     `json:"natGateway,omitempty"`
	NetworkSecurityGroup               *NetworkSecurityGroup                            `json:"networkSecurityGroup,omitempty"`
	PrivateEndpointNetworkPolicies     *VirtualNetworkPrivateEndpointNetworkPolicies    `json:"privateEndpointNetworkPolicies,omitempty"`
	PrivateEndpoints                   *[]PrivateEndpoint                               `json:"privateEndpoints,omitempty"`
	PrivateLinkServiceNetworkPolicies  *VirtualNetworkPrivateLinkServiceNetworkPolicies `json:"privateLinkServiceNetworkPolicies,omitempty"`
	ProvisioningState                  *ProvisioningState                               `json:"provisioningState,omitempty"`
	Purpose                            *string                                          `json:"purpose,omitempty"`
	ResourceNavigationLinks            *[]ResourceNavigationLink                        `json:"resourceNavigationLinks,omitempty"`
	RouteTable                         *RouteTable                                      `json:"routeTable,omitempty"`
	ServiceAssociationLinks            *[]ServiceAssociationLink                        `json:"serviceAssociationLinks,omitempty"`
	ServiceEndpointPolicies            *[]ServiceEndpointPolicy                         `json:"serviceEndpointPolicies,omitempty"`
	ServiceEndpoints                   *[]ServiceEndpointPropertiesFormat               `json:"serviceEndpoints,omitempty"`
	SharingScope                       *SharingScope                                    `json:"sharingScope,omitempty"`
}

type SupportedSecurityProvidersOperationResponse ¶ 

type SupportedSecurityProvidersOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualWanSecurityProviders
}

type SyncMode ¶ 

type SyncMode string
const (
	SyncModeAutomatic SyncMode = "Automatic"
	SyncModeManual    SyncMode = "Manual"
)

func (*SyncMode) UnmarshalJSON ¶ 

func (s *SyncMode) UnmarshalJSON(bytes []byte) error

type TagsObject ¶ 

type TagsObject struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

type TrafficAnalyticsConfigurationProperties ¶ 

type TrafficAnalyticsConfigurationProperties struct {
	Enabled                  *bool   `json:"enabled,omitempty"`
	TrafficAnalyticsInterval *int64  `json:"trafficAnalyticsInterval,omitempty"`
	WorkspaceId              *string `json:"workspaceId,omitempty"`
	WorkspaceRegion          *string `json:"workspaceRegion,omitempty"`
	WorkspaceResourceId      *string `json:"workspaceResourceId,omitempty"`
}

type TrafficAnalyticsProperties ¶ 

type TrafficAnalyticsProperties struct {
	NetworkWatcherFlowAnalyticsConfiguration *TrafficAnalyticsConfigurationProperties `json:"networkWatcherFlowAnalyticsConfiguration,omitempty"`
}

type TrafficSelectorPolicy ¶ 

type TrafficSelectorPolicy struct {
	LocalAddressRanges  []string `json:"localAddressRanges"`
	RemoteAddressRanges []string `json:"remoteAddressRanges"`
}

type TransportProtocol ¶ 

type TransportProtocol string
const (
	TransportProtocolAll TransportProtocol = "All"
	TransportProtocolTcp TransportProtocol = "Tcp"
	TransportProtocolUdp TransportProtocol = "Udp"
)

func (*TransportProtocol) UnmarshalJSON ¶ 

func (s *TransportProtocol) UnmarshalJSON(bytes []byte) error

type UpdateTagsOperationResponse ¶ 

type UpdateTagsOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualWAN
}

type VirtualHub ¶ 

type VirtualHub struct {
	Etag       *string               `json:"etag,omitempty"`
	Id         *string               `json:"id,omitempty"`
	Kind       *string               `json:"kind,omitempty"`
	Location   *string               `json:"location,omitempty"`
	Name       *string               `json:"name,omitempty"`
	Properties *VirtualHubProperties `json:"properties,omitempty"`
	Tags       *map[string]string    `json:"tags,omitempty"`
	Type       *string               `json:"type,omitempty"`
}

type VirtualHubBgpConnectionCreateOrUpdateOperationResponse ¶ 

type VirtualHubBgpConnectionCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BgpConnection
}

type VirtualHubBgpConnectionDeleteOperationResponse ¶ 

type VirtualHubBgpConnectionDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VirtualHubBgpConnectionGetOperationResponse ¶ 

type VirtualHubBgpConnectionGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BgpConnection
}

type VirtualHubBgpConnectionsListAdvertisedRoutesOperationResponse ¶ 

type VirtualHubBgpConnectionsListAdvertisedRoutesOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *map[string][]PeerRoute
}

type VirtualHubBgpConnectionsListCompleteResult ¶ 

type VirtualHubBgpConnectionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []BgpConnection
}

type VirtualHubBgpConnectionsListLearnedRoutesOperationResponse ¶ 

type VirtualHubBgpConnectionsListLearnedRoutesOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *map[string][]PeerRoute
}

type VirtualHubBgpConnectionsListOperationResponse ¶ 

type VirtualHubBgpConnectionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]BgpConnection
}

type VirtualHubEffectiveRoute ¶ 

type VirtualHubEffectiveRoute struct {
	AddressPrefixes *[]string `json:"addressPrefixes,omitempty"`
	AsPath          *string   `json:"asPath,omitempty"`
	NextHopType     *string   `json:"nextHopType,omitempty"`
	NextHops        *[]string `json:"nextHops,omitempty"`
	RouteOrigin     *string   `json:"routeOrigin,omitempty"`
}

type VirtualHubEffectiveRouteList ¶ 

type VirtualHubEffectiveRouteList struct {
	Value *[]VirtualHubEffectiveRoute `json:"value,omitempty"`
}

type VirtualHubIPConfigurationCreateOrUpdateOperationResponse ¶ 

type VirtualHubIPConfigurationCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *HubIPConfiguration
}

type VirtualHubIPConfigurationDeleteOperationResponse ¶ 

type VirtualHubIPConfigurationDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VirtualHubIPConfigurationGetOperationResponse ¶ 

type VirtualHubIPConfigurationGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *HubIPConfiguration
}

type VirtualHubIPConfigurationListCompleteResult ¶ 

type VirtualHubIPConfigurationListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []HubIPConfiguration
}

type VirtualHubIPConfigurationListOperationResponse ¶ 

type VirtualHubIPConfigurationListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]HubIPConfiguration
}

type VirtualHubId ¶ 

type VirtualHubId struct {
	SubscriptionId    string
	ResourceGroupName string
	VirtualHubName    string
}

VirtualHubId is a struct representing the Resource ID for a Virtual Hub

func NewVirtualHubID ¶ 

func NewVirtualHubID(subscriptionId string, resourceGroupName string, virtualHubName string) VirtualHubId

NewVirtualHubID returns a new VirtualHubId struct

func ParseVirtualHubID ¶ 

func ParseVirtualHubID(input string) (*VirtualHubId, error)

ParseVirtualHubID parses 'input' into a VirtualHubId

func ParseVirtualHubIDInsensitively ¶ 

func ParseVirtualHubIDInsensitively(input string) (*VirtualHubId, error)

ParseVirtualHubIDInsensitively parses 'input' case-insensitively into a VirtualHubId note: this method should only be used for API response data and not user input

func (*VirtualHubId) FromParseResult ¶ 

func (id *VirtualHubId) FromParseResult(input resourceids.ParseResult) error

func (VirtualHubId) ID ¶ 

func (id VirtualHubId) ID() string

ID returns the formatted Virtual Hub ID

func (VirtualHubId) Segments ¶ 

func (id VirtualHubId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Virtual Hub ID

func (VirtualHubId) String ¶ 

func (id VirtualHubId) String() string

String returns a human-readable description of this Virtual Hub ID

type VirtualHubOperationPredicate ¶ 

type VirtualHubOperationPredicate struct {
	Etag     *string
	Id       *string
	Kind     *string
	Location *string
	Name     *string
	Type     *string
}

func (VirtualHubOperationPredicate) Matches ¶ 

func (p VirtualHubOperationPredicate) Matches(input VirtualHub) bool

type VirtualHubProperties ¶ 

type VirtualHubProperties struct {
	AddressPrefix                       *string                              `json:"addressPrefix,omitempty"`
	AllowBranchToBranchTraffic          *bool                                `json:"allowBranchToBranchTraffic,omitempty"`
	AzureFirewall                       *SubResource                         `json:"azureFirewall,omitempty"`
	BgpConnections                      *[]SubResource                       `json:"bgpConnections,omitempty"`
	ExpressRouteGateway                 *SubResource                         `json:"expressRouteGateway,omitempty"`
	HubRoutingPreference                *HubRoutingPreference                `json:"hubRoutingPreference,omitempty"`
	IPConfigurations                    *[]SubResource                       `json:"ipConfigurations,omitempty"`
	P2SVpnGateway                       *SubResource                         `json:"p2SVpnGateway,omitempty"`
	PreferredRoutingGateway             *PreferredRoutingGateway             `json:"preferredRoutingGateway,omitempty"`
	ProvisioningState                   *ProvisioningState                   `json:"provisioningState,omitempty"`
	RouteMaps                           *[]SubResource                       `json:"routeMaps,omitempty"`
	RouteTable                          *VirtualHubRouteTable                `json:"routeTable,omitempty"`
	RoutingState                        *RoutingState                        `json:"routingState,omitempty"`
	SecurityPartnerProvider             *SubResource                         `json:"securityPartnerProvider,omitempty"`
	SecurityProviderName                *string                              `json:"securityProviderName,omitempty"`
	Sku                                 *string                              `json:"sku,omitempty"`
	VirtualHubRouteTableV2s             *[]VirtualHubRouteTableV2            `json:"virtualHubRouteTableV2s,omitempty"`
	VirtualRouterAsn                    *int64                               `json:"virtualRouterAsn,omitempty"`
	VirtualRouterAutoScaleConfiguration *VirtualRouterAutoScaleConfiguration `json:"virtualRouterAutoScaleConfiguration,omitempty"`
	VirtualRouterIPs                    *[]string                            `json:"virtualRouterIps,omitempty"`
	VirtualWAN                          *SubResource                         `json:"virtualWan,omitempty"`
	VpnGateway                          *SubResource                         `json:"vpnGateway,omitempty"`
}

type VirtualHubRoute ¶ 

type VirtualHubRoute struct {
	AddressPrefixes  *[]string `json:"addressPrefixes,omitempty"`
	NextHopIPAddress *string   `json:"nextHopIpAddress,omitempty"`
}

type VirtualHubRouteTable ¶ 

type VirtualHubRouteTable struct {
	Routes *[]VirtualHubRoute `json:"routes,omitempty"`
}

type VirtualHubRouteTableId ¶ 

type VirtualHubRouteTableId struct {
	SubscriptionId    string
	ResourceGroupName string
	VirtualHubName    string
	RouteTableName    string
}

VirtualHubRouteTableId is a struct representing the Resource ID for a Virtual Hub Route Table

func NewVirtualHubRouteTableID ¶ 

func NewVirtualHubRouteTableID(subscriptionId string, resourceGroupName string, virtualHubName string, routeTableName string) VirtualHubRouteTableId

NewVirtualHubRouteTableID returns a new VirtualHubRouteTableId struct

func ParseVirtualHubRouteTableID ¶ 

func ParseVirtualHubRouteTableID(input string) (*VirtualHubRouteTableId, error)

ParseVirtualHubRouteTableID parses 'input' into a VirtualHubRouteTableId

func ParseVirtualHubRouteTableIDInsensitively ¶ 

func ParseVirtualHubRouteTableIDInsensitively(input string) (*VirtualHubRouteTableId, error)

ParseVirtualHubRouteTableIDInsensitively parses 'input' case-insensitively into a VirtualHubRouteTableId note: this method should only be used for API response data and not user input

func (*VirtualHubRouteTableId) FromParseResult ¶ 

func (id *VirtualHubRouteTableId) FromParseResult(input resourceids.ParseResult) error

func (VirtualHubRouteTableId) ID ¶ 

func (id VirtualHubRouteTableId) ID() string

ID returns the formatted Virtual Hub Route Table ID

func (VirtualHubRouteTableId) Segments ¶ 

func (id VirtualHubRouteTableId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Virtual Hub Route Table ID

func (VirtualHubRouteTableId) String ¶ 

func (id VirtualHubRouteTableId) String() string

String returns a human-readable description of this Virtual Hub Route Table ID

type VirtualHubRouteTableV2 ¶ 

type VirtualHubRouteTableV2 struct {
	Etag       *string                           `json:"etag,omitempty"`
	Id         *string                           `json:"id,omitempty"`
	Name       *string                           `json:"name,omitempty"`
	Properties *VirtualHubRouteTableV2Properties `json:"properties,omitempty"`
}

type VirtualHubRouteTableV2OperationPredicate ¶ 

type VirtualHubRouteTableV2OperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
}

func (VirtualHubRouteTableV2OperationPredicate) Matches ¶ 

func (p VirtualHubRouteTableV2OperationPredicate) Matches(input VirtualHubRouteTableV2) bool

type VirtualHubRouteTableV2Properties ¶ 

type VirtualHubRouteTableV2Properties struct {
	AttachedConnections *[]string            `json:"attachedConnections,omitempty"`
	ProvisioningState   *ProvisioningState   `json:"provisioningState,omitempty"`
	Routes              *[]VirtualHubRouteV2 `json:"routes,omitempty"`
}

type VirtualHubRouteTableV2sCreateOrUpdateOperationResponse ¶ 

type VirtualHubRouteTableV2sCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualHubRouteTableV2
}

type VirtualHubRouteTableV2sDeleteOperationResponse ¶ 

type VirtualHubRouteTableV2sDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VirtualHubRouteTableV2sGetOperationResponse ¶ 

type VirtualHubRouteTableV2sGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualHubRouteTableV2
}

type VirtualHubRouteTableV2sListCompleteResult ¶ 

type VirtualHubRouteTableV2sListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualHubRouteTableV2
}

type VirtualHubRouteTableV2sListOperationResponse ¶ 

type VirtualHubRouteTableV2sListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualHubRouteTableV2
}

type VirtualHubRouteV2 ¶ 

type VirtualHubRouteV2 struct {
	DestinationType *string   `json:"destinationType,omitempty"`
	Destinations    *[]string `json:"destinations,omitempty"`
	NextHopType     *string   `json:"nextHopType,omitempty"`
	NextHops        *[]string `json:"nextHops,omitempty"`
}

type VirtualHubsCreateOrUpdateOperationResponse ¶ 

type VirtualHubsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualHub
}

type VirtualHubsDeleteOperationResponse ¶ 

type VirtualHubsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VirtualHubsGetEffectiveVirtualHubRoutesOperationResponse ¶ 

type VirtualHubsGetEffectiveVirtualHubRoutesOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualHubEffectiveRouteList
}

type VirtualHubsGetInboundRoutesOperationResponse ¶ 

type VirtualHubsGetInboundRoutesOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EffectiveRouteMapRouteList
}

type VirtualHubsGetOperationResponse ¶ 

type VirtualHubsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualHub
}

type VirtualHubsGetOutboundRoutesOperationResponse ¶ 

type VirtualHubsGetOutboundRoutesOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EffectiveRouteMapRouteList
}

type VirtualHubsListByResourceGroupCompleteResult ¶ 

type VirtualHubsListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualHub
}

type VirtualHubsListByResourceGroupOperationResponse ¶ 

type VirtualHubsListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualHub
}

type VirtualHubsListCompleteResult ¶ 

type VirtualHubsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualHub
}

type VirtualHubsListOperationResponse ¶ 

type VirtualHubsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualHub
}

type VirtualHubsUpdateTagsOperationResponse ¶ 

type VirtualHubsUpdateTagsOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualHub
}

type VirtualNetworkGatewayConnectionProtocol ¶ 

type VirtualNetworkGatewayConnectionProtocol string
const (
	VirtualNetworkGatewayConnectionProtocolIKEvOne VirtualNetworkGatewayConnectionProtocol = "IKEv1"
	VirtualNetworkGatewayConnectionProtocolIKEvTwo VirtualNetworkGatewayConnectionProtocol = "IKEv2"
)

func (*VirtualNetworkGatewayConnectionProtocol) UnmarshalJSON ¶ 

func (s *VirtualNetworkGatewayConnectionProtocol) UnmarshalJSON(bytes []byte) error

type VirtualNetworkPrivateEndpointNetworkPolicies ¶ 

type VirtualNetworkPrivateEndpointNetworkPolicies string
const (
	VirtualNetworkPrivateEndpointNetworkPoliciesDisabled                    VirtualNetworkPrivateEndpointNetworkPolicies = "Disabled"
	VirtualNetworkPrivateEndpointNetworkPoliciesEnabled                     VirtualNetworkPrivateEndpointNetworkPolicies = "Enabled"
	VirtualNetworkPrivateEndpointNetworkPoliciesNetworkSecurityGroupEnabled VirtualNetworkPrivateEndpointNetworkPolicies = "NetworkSecurityGroupEnabled"
	VirtualNetworkPrivateEndpointNetworkPoliciesRouteTableEnabled           VirtualNetworkPrivateEndpointNetworkPolicies = "RouteTableEnabled"
)

func (*VirtualNetworkPrivateEndpointNetworkPolicies) UnmarshalJSON ¶ 

func (s *VirtualNetworkPrivateEndpointNetworkPolicies) UnmarshalJSON(bytes []byte) error

type VirtualNetworkPrivateLinkServiceNetworkPolicies ¶ 

type VirtualNetworkPrivateLinkServiceNetworkPolicies string
const (
	VirtualNetworkPrivateLinkServiceNetworkPoliciesDisabled VirtualNetworkPrivateLinkServiceNetworkPolicies = "Disabled"
	VirtualNetworkPrivateLinkServiceNetworkPoliciesEnabled  VirtualNetworkPrivateLinkServiceNetworkPolicies = "Enabled"
)

func (*VirtualNetworkPrivateLinkServiceNetworkPolicies) UnmarshalJSON ¶ 

func (s *VirtualNetworkPrivateLinkServiceNetworkPolicies) UnmarshalJSON(bytes []byte) error

type VirtualNetworkTap ¶ 

type VirtualNetworkTap struct {
	Etag       *string                            `json:"etag,omitempty"`
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties *VirtualNetworkTapPropertiesFormat `json:"properties,omitempty"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type VirtualNetworkTapPropertiesFormat ¶ 

type VirtualNetworkTapPropertiesFormat struct {
	DestinationLoadBalancerFrontEndIPConfiguration *FrontendIPConfiguration            `json:"destinationLoadBalancerFrontEndIPConfiguration,omitempty"`
	DestinationNetworkInterfaceIPConfiguration     *NetworkInterfaceIPConfiguration    `json:"destinationNetworkInterfaceIPConfiguration,omitempty"`
	DestinationPort                                *int64                              `json:"destinationPort,omitempty"`
	NetworkInterfaceTapConfigurations              *[]NetworkInterfaceTapConfiguration `json:"networkInterfaceTapConfigurations,omitempty"`
	ProvisioningState                              *ProvisioningState                  `json:"provisioningState,omitempty"`
	ResourceGuid                                   *string                             `json:"resourceGuid,omitempty"`
}

type VirtualRouterAutoScaleConfiguration ¶ 

type VirtualRouterAutoScaleConfiguration struct {
	MinCapacity *int64 `json:"minCapacity,omitempty"`
}

type VirtualWAN ¶ 

type VirtualWAN struct {
	Etag       *string               `json:"etag,omitempty"`
	Id         *string               `json:"id,omitempty"`
	Location   *string               `json:"location,omitempty"`
	Name       *string               `json:"name,omitempty"`
	Properties *VirtualWanProperties `json:"properties,omitempty"`
	Tags       *map[string]string    `json:"tags,omitempty"`
	Type       *string               `json:"type,omitempty"`
}

type VirtualWANId ¶ 

type VirtualWANId struct {
	SubscriptionId    string
	ResourceGroupName string
	VirtualWanName    string
}

VirtualWANId is a struct representing the Resource ID for a Virtual W A N

func NewVirtualWANID ¶ 

func NewVirtualWANID(subscriptionId string, resourceGroupName string, virtualWanName string) VirtualWANId

NewVirtualWANID returns a new VirtualWANId struct

func ParseVirtualWANID ¶ 

func ParseVirtualWANID(input string) (*VirtualWANId, error)

ParseVirtualWANID parses 'input' into a VirtualWANId

func ParseVirtualWANIDInsensitively ¶ 

func ParseVirtualWANIDInsensitively(input string) (*VirtualWANId, error)

ParseVirtualWANIDInsensitively parses 'input' case-insensitively into a VirtualWANId note: this method should only be used for API response data and not user input

func (*VirtualWANId) FromParseResult ¶ 

func (id *VirtualWANId) FromParseResult(input resourceids.ParseResult) error

func (VirtualWANId) ID ¶ 

func (id VirtualWANId) ID() string

ID returns the formatted Virtual W A N ID

func (VirtualWANId) Segments ¶ 

func (id VirtualWANId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Virtual W A N ID

func (VirtualWANId) String ¶ 

func (id VirtualWANId) String() string

String returns a human-readable description of this Virtual W A N ID

type VirtualWANOperationPredicate ¶ 

type VirtualWANOperationPredicate struct {
	Etag     *string
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (VirtualWANOperationPredicate) Matches ¶ 

func (p VirtualWANOperationPredicate) Matches(input VirtualWAN) bool

type VirtualWANsClient ¶ 

type VirtualWANsClient struct {
	Client *resourcemanager.Client
}

func NewVirtualWANsClientWithBaseURI ¶ 

func NewVirtualWANsClientWithBaseURI(sdkApi sdkEnv.Api) (*VirtualWANsClient, error)

func (VirtualWANsClient) ConfigurationPolicyGroupsCreateOrUpdate ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsCreateOrUpdate(ctx context.Context, id ConfigurationPolicyGroupId, input VpnServerConfigurationPolicyGroup) (result ConfigurationPolicyGroupsCreateOrUpdateOperationResponse, err error)

ConfigurationPolicyGroupsCreateOrUpdate ...

func (VirtualWANsClient) ConfigurationPolicyGroupsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsCreateOrUpdateThenPoll(ctx context.Context, id ConfigurationPolicyGroupId, input VpnServerConfigurationPolicyGroup) error

ConfigurationPolicyGroupsCreateOrUpdateThenPoll performs ConfigurationPolicyGroupsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) ConfigurationPolicyGroupsDelete ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsDelete(ctx context.Context, id ConfigurationPolicyGroupId) (result ConfigurationPolicyGroupsDeleteOperationResponse, err error)

ConfigurationPolicyGroupsDelete ...

func (VirtualWANsClient) ConfigurationPolicyGroupsDeleteThenPoll ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsDeleteThenPoll(ctx context.Context, id ConfigurationPolicyGroupId) error

ConfigurationPolicyGroupsDeleteThenPoll performs ConfigurationPolicyGroupsDelete then polls until it's completed

func (VirtualWANsClient) ConfigurationPolicyGroupsGet ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsGet(ctx context.Context, id ConfigurationPolicyGroupId) (result ConfigurationPolicyGroupsGetOperationResponse, err error)

ConfigurationPolicyGroupsGet ...

func (VirtualWANsClient) ConfigurationPolicyGroupsListByVpnServerConfiguration ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsListByVpnServerConfiguration(ctx context.Context, id VpnServerConfigurationId) (result ConfigurationPolicyGroupsListByVpnServerConfigurationOperationResponse, err error)

ConfigurationPolicyGroupsListByVpnServerConfiguration ...

func (VirtualWANsClient) ConfigurationPolicyGroupsListByVpnServerConfigurationComplete ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsListByVpnServerConfigurationComplete(ctx context.Context, id VpnServerConfigurationId) (ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteResult, error)

ConfigurationPolicyGroupsListByVpnServerConfigurationComplete retrieves all the results into a single object

func (VirtualWANsClient) ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteMatchingPredicate(ctx context.Context, id VpnServerConfigurationId, predicate VpnServerConfigurationPolicyGroupOperationPredicate) (result ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteResult, err error)

ConfigurationPolicyGroupsListByVpnServerConfigurationCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) Generatevirtualwanvpnserverconfigurationvpnprofile ¶ 

func (c VirtualWANsClient) Generatevirtualwanvpnserverconfigurationvpnprofile(ctx context.Context, id VirtualWANId, input VirtualWanVpnProfileParameters) (result GeneratevirtualwanvpnserverconfigurationvpnprofileOperationResponse, err error)

Generatevirtualwanvpnserverconfigurationvpnprofile ...

func (VirtualWANsClient) GeneratevirtualwanvpnserverconfigurationvpnprofileThenPoll ¶ 

func (c VirtualWANsClient) GeneratevirtualwanvpnserverconfigurationvpnprofileThenPoll(ctx context.Context, id VirtualWANId, input VirtualWanVpnProfileParameters) error

GeneratevirtualwanvpnserverconfigurationvpnprofileThenPoll performs Generatevirtualwanvpnserverconfigurationvpnprofile then polls until it's completed

func (VirtualWANsClient) HubRouteTablesCreateOrUpdate ¶ 

func (c VirtualWANsClient) HubRouteTablesCreateOrUpdate(ctx context.Context, id HubRouteTableId, input HubRouteTable) (result HubRouteTablesCreateOrUpdateOperationResponse, err error)

HubRouteTablesCreateOrUpdate ...

func (VirtualWANsClient) HubRouteTablesCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) HubRouteTablesCreateOrUpdateThenPoll(ctx context.Context, id HubRouteTableId, input HubRouteTable) error

HubRouteTablesCreateOrUpdateThenPoll performs HubRouteTablesCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) HubRouteTablesDelete ¶ 

func (c VirtualWANsClient) HubRouteTablesDelete(ctx context.Context, id HubRouteTableId) (result HubRouteTablesDeleteOperationResponse, err error)

HubRouteTablesDelete ...

func (VirtualWANsClient) HubRouteTablesDeleteThenPoll ¶ 

func (c VirtualWANsClient) HubRouteTablesDeleteThenPoll(ctx context.Context, id HubRouteTableId) error

HubRouteTablesDeleteThenPoll performs HubRouteTablesDelete then polls until it's completed

func (VirtualWANsClient) HubRouteTablesGet ¶ 

func (c VirtualWANsClient) HubRouteTablesGet(ctx context.Context, id HubRouteTableId) (result HubRouteTablesGetOperationResponse, err error)

HubRouteTablesGet ...

func (VirtualWANsClient) HubRouteTablesList ¶ 

func (c VirtualWANsClient) HubRouteTablesList(ctx context.Context, id VirtualHubId) (result HubRouteTablesListOperationResponse, err error)

HubRouteTablesList ...

func (VirtualWANsClient) HubRouteTablesListComplete ¶ 

func (c VirtualWANsClient) HubRouteTablesListComplete(ctx context.Context, id VirtualHubId) (HubRouteTablesListCompleteResult, error)

HubRouteTablesListComplete retrieves all the results into a single object

func (VirtualWANsClient) HubRouteTablesListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) HubRouteTablesListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate HubRouteTableOperationPredicate) (result HubRouteTablesListCompleteResult, err error)

HubRouteTablesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) HubVirtualNetworkConnectionsCreateOrUpdate ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsCreateOrUpdate(ctx context.Context, id HubVirtualNetworkConnectionId, input HubVirtualNetworkConnection) (result HubVirtualNetworkConnectionsCreateOrUpdateOperationResponse, err error)

HubVirtualNetworkConnectionsCreateOrUpdate ...

func (VirtualWANsClient) HubVirtualNetworkConnectionsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsCreateOrUpdateThenPoll(ctx context.Context, id HubVirtualNetworkConnectionId, input HubVirtualNetworkConnection) error

HubVirtualNetworkConnectionsCreateOrUpdateThenPoll performs HubVirtualNetworkConnectionsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) HubVirtualNetworkConnectionsDelete ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsDelete(ctx context.Context, id HubVirtualNetworkConnectionId) (result HubVirtualNetworkConnectionsDeleteOperationResponse, err error)

HubVirtualNetworkConnectionsDelete ...

func (VirtualWANsClient) HubVirtualNetworkConnectionsDeleteThenPoll ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsDeleteThenPoll(ctx context.Context, id HubVirtualNetworkConnectionId) error

HubVirtualNetworkConnectionsDeleteThenPoll performs HubVirtualNetworkConnectionsDelete then polls until it's completed

func (VirtualWANsClient) HubVirtualNetworkConnectionsGet ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsGet(ctx context.Context, id HubVirtualNetworkConnectionId) (result HubVirtualNetworkConnectionsGetOperationResponse, err error)

HubVirtualNetworkConnectionsGet ...

func (VirtualWANsClient) HubVirtualNetworkConnectionsList ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsList(ctx context.Context, id VirtualHubId) (result HubVirtualNetworkConnectionsListOperationResponse, err error)

HubVirtualNetworkConnectionsList ...

func (VirtualWANsClient) HubVirtualNetworkConnectionsListComplete ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsListComplete(ctx context.Context, id VirtualHubId) (HubVirtualNetworkConnectionsListCompleteResult, error)

HubVirtualNetworkConnectionsListComplete retrieves all the results into a single object

func (VirtualWANsClient) HubVirtualNetworkConnectionsListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) HubVirtualNetworkConnectionsListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate HubVirtualNetworkConnectionOperationPredicate) (result HubVirtualNetworkConnectionsListCompleteResult, err error)

HubVirtualNetworkConnectionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) NatRulesCreateOrUpdate ¶ 

func (c VirtualWANsClient) NatRulesCreateOrUpdate(ctx context.Context, id NatRuleId, input VpnGatewayNatRule) (result NatRulesCreateOrUpdateOperationResponse, err error)

NatRulesCreateOrUpdate ...

func (VirtualWANsClient) NatRulesCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) NatRulesCreateOrUpdateThenPoll(ctx context.Context, id NatRuleId, input VpnGatewayNatRule) error

NatRulesCreateOrUpdateThenPoll performs NatRulesCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) NatRulesDelete ¶ 

func (c VirtualWANsClient) NatRulesDelete(ctx context.Context, id NatRuleId) (result NatRulesDeleteOperationResponse, err error)

NatRulesDelete ...

func (VirtualWANsClient) NatRulesDeleteThenPoll ¶ 

func (c VirtualWANsClient) NatRulesDeleteThenPoll(ctx context.Context, id NatRuleId) error

NatRulesDeleteThenPoll performs NatRulesDelete then polls until it's completed

func (VirtualWANsClient) NatRulesGet ¶ 

func (c VirtualWANsClient) NatRulesGet(ctx context.Context, id NatRuleId) (result NatRulesGetOperationResponse, err error)

NatRulesGet ...

func (VirtualWANsClient) NatRulesListByVpnGateway ¶ 

func (c VirtualWANsClient) NatRulesListByVpnGateway(ctx context.Context, id VpnGatewayId) (result NatRulesListByVpnGatewayOperationResponse, err error)

NatRulesListByVpnGateway ...

func (VirtualWANsClient) NatRulesListByVpnGatewayComplete ¶ 

func (c VirtualWANsClient) NatRulesListByVpnGatewayComplete(ctx context.Context, id VpnGatewayId) (NatRulesListByVpnGatewayCompleteResult, error)

NatRulesListByVpnGatewayComplete retrieves all the results into a single object

func (VirtualWANsClient) NatRulesListByVpnGatewayCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) NatRulesListByVpnGatewayCompleteMatchingPredicate(ctx context.Context, id VpnGatewayId, predicate VpnGatewayNatRuleOperationPredicate) (result NatRulesListByVpnGatewayCompleteResult, err error)

NatRulesListByVpnGatewayCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsCreateOrUpdate ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsCreateOrUpdate(ctx context.Context, id NetworkVirtualApplianceConnectionId, input NetworkVirtualApplianceConnection) (result NetworkVirtualApplianceConnectionsCreateOrUpdateOperationResponse, err error)

NetworkVirtualApplianceConnectionsCreateOrUpdate ...

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsCreateOrUpdateThenPoll(ctx context.Context, id NetworkVirtualApplianceConnectionId, input NetworkVirtualApplianceConnection) error

NetworkVirtualApplianceConnectionsCreateOrUpdateThenPoll performs NetworkVirtualApplianceConnectionsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsDelete ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsDelete(ctx context.Context, id NetworkVirtualApplianceConnectionId) (result NetworkVirtualApplianceConnectionsDeleteOperationResponse, err error)

NetworkVirtualApplianceConnectionsDelete ...

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsDeleteThenPoll ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsDeleteThenPoll(ctx context.Context, id NetworkVirtualApplianceConnectionId) error

NetworkVirtualApplianceConnectionsDeleteThenPoll performs NetworkVirtualApplianceConnectionsDelete then polls until it's completed

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsGet ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsGet(ctx context.Context, id NetworkVirtualApplianceConnectionId) (result NetworkVirtualApplianceConnectionsGetOperationResponse, err error)

NetworkVirtualApplianceConnectionsGet ...

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsList ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsList(ctx context.Context, id NetworkVirtualApplianceId) (result NetworkVirtualApplianceConnectionsListOperationResponse, err error)

NetworkVirtualApplianceConnectionsList ...

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsListComplete ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsListComplete(ctx context.Context, id NetworkVirtualApplianceId) (NetworkVirtualApplianceConnectionsListCompleteResult, error)

NetworkVirtualApplianceConnectionsListComplete retrieves all the results into a single object

func (VirtualWANsClient) NetworkVirtualApplianceConnectionsListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) NetworkVirtualApplianceConnectionsListCompleteMatchingPredicate(ctx context.Context, id NetworkVirtualApplianceId, predicate NetworkVirtualApplianceConnectionOperationPredicate) (result NetworkVirtualApplianceConnectionsListCompleteResult, err error)

NetworkVirtualApplianceConnectionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) P2sVpnGatewaysCreateOrUpdate ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysCreateOrUpdate(ctx context.Context, id commonids.VirtualWANP2SVPNGatewayId, input P2SVpnGateway) (result P2sVpnGatewaysCreateOrUpdateOperationResponse, err error)

P2sVpnGatewaysCreateOrUpdate ...

func (VirtualWANsClient) P2sVpnGatewaysCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysCreateOrUpdateThenPoll(ctx context.Context, id commonids.VirtualWANP2SVPNGatewayId, input P2SVpnGateway) error

P2sVpnGatewaysCreateOrUpdateThenPoll performs P2sVpnGatewaysCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) P2sVpnGatewaysDelete ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysDelete(ctx context.Context, id commonids.VirtualWANP2SVPNGatewayId) (result P2sVpnGatewaysDeleteOperationResponse, err error)

P2sVpnGatewaysDelete ...

func (VirtualWANsClient) P2sVpnGatewaysDeleteThenPoll ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysDeleteThenPoll(ctx context.Context, id commonids.VirtualWANP2SVPNGatewayId) error

P2sVpnGatewaysDeleteThenPoll performs P2sVpnGatewaysDelete then polls until it's completed

func (VirtualWANsClient) P2sVpnGatewaysGet ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysGet(ctx context.Context, id commonids.VirtualWANP2SVPNGatewayId) (result P2sVpnGatewaysGetOperationResponse, err error)

P2sVpnGatewaysGet ...

func (VirtualWANsClient) P2sVpnGatewaysList ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysList(ctx context.Context, id commonids.SubscriptionId) (result P2sVpnGatewaysListOperationResponse, err error)

P2sVpnGatewaysList ...

func (VirtualWANsClient) P2sVpnGatewaysListByResourceGroup ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result P2sVpnGatewaysListByResourceGroupOperationResponse, err error)

P2sVpnGatewaysListByResourceGroup ...

func (VirtualWANsClient) P2sVpnGatewaysListByResourceGroupComplete ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (P2sVpnGatewaysListByResourceGroupCompleteResult, error)

P2sVpnGatewaysListByResourceGroupComplete retrieves all the results into a single object

func (VirtualWANsClient) P2sVpnGatewaysListByResourceGroupCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate P2SVpnGatewayOperationPredicate) (result P2sVpnGatewaysListByResourceGroupCompleteResult, err error)

P2sVpnGatewaysListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) P2sVpnGatewaysListComplete ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysListComplete(ctx context.Context, id commonids.SubscriptionId) (P2sVpnGatewaysListCompleteResult, error)

P2sVpnGatewaysListComplete retrieves all the results into a single object

func (VirtualWANsClient) P2sVpnGatewaysListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) P2sVpnGatewaysListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate P2SVpnGatewayOperationPredicate) (result P2sVpnGatewaysListCompleteResult, err error)

P2sVpnGatewaysListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) RouteMapsCreateOrUpdate ¶ 

func (c VirtualWANsClient) RouteMapsCreateOrUpdate(ctx context.Context, id RouteMapId, input RouteMap) (result RouteMapsCreateOrUpdateOperationResponse, err error)

RouteMapsCreateOrUpdate ...

func (VirtualWANsClient) RouteMapsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) RouteMapsCreateOrUpdateThenPoll(ctx context.Context, id RouteMapId, input RouteMap) error

RouteMapsCreateOrUpdateThenPoll performs RouteMapsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) RouteMapsDelete ¶ 

func (c VirtualWANsClient) RouteMapsDelete(ctx context.Context, id RouteMapId) (result RouteMapsDeleteOperationResponse, err error)

RouteMapsDelete ...

func (VirtualWANsClient) RouteMapsDeleteThenPoll ¶ 

func (c VirtualWANsClient) RouteMapsDeleteThenPoll(ctx context.Context, id RouteMapId) error

RouteMapsDeleteThenPoll performs RouteMapsDelete then polls until it's completed

func (VirtualWANsClient) RouteMapsGet ¶ 

func (c VirtualWANsClient) RouteMapsGet(ctx context.Context, id RouteMapId) (result RouteMapsGetOperationResponse, err error)

RouteMapsGet ...

func (VirtualWANsClient) RouteMapsList ¶ 

func (c VirtualWANsClient) RouteMapsList(ctx context.Context, id VirtualHubId) (result RouteMapsListOperationResponse, err error)

RouteMapsList ...

func (VirtualWANsClient) RouteMapsListComplete ¶ 

func (c VirtualWANsClient) RouteMapsListComplete(ctx context.Context, id VirtualHubId) (RouteMapsListCompleteResult, error)

RouteMapsListComplete retrieves all the results into a single object

func (VirtualWANsClient) RouteMapsListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) RouteMapsListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate RouteMapOperationPredicate) (result RouteMapsListCompleteResult, err error)

RouteMapsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) RoutingIntentCreateOrUpdate ¶ 

func (c VirtualWANsClient) RoutingIntentCreateOrUpdate(ctx context.Context, id RoutingIntentId, input RoutingIntent) (result RoutingIntentCreateOrUpdateOperationResponse, err error)

RoutingIntentCreateOrUpdate ...

func (VirtualWANsClient) RoutingIntentCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) RoutingIntentCreateOrUpdateThenPoll(ctx context.Context, id RoutingIntentId, input RoutingIntent) error

RoutingIntentCreateOrUpdateThenPoll performs RoutingIntentCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) RoutingIntentDelete ¶ 

func (c VirtualWANsClient) RoutingIntentDelete(ctx context.Context, id RoutingIntentId) (result RoutingIntentDeleteOperationResponse, err error)

RoutingIntentDelete ...

func (VirtualWANsClient) RoutingIntentDeleteThenPoll ¶ 

func (c VirtualWANsClient) RoutingIntentDeleteThenPoll(ctx context.Context, id RoutingIntentId) error

RoutingIntentDeleteThenPoll performs RoutingIntentDelete then polls until it's completed

func (VirtualWANsClient) RoutingIntentGet ¶ 

func (c VirtualWANsClient) RoutingIntentGet(ctx context.Context, id RoutingIntentId) (result RoutingIntentGetOperationResponse, err error)

RoutingIntentGet ...

func (VirtualWANsClient) RoutingIntentList ¶ 

func (c VirtualWANsClient) RoutingIntentList(ctx context.Context, id VirtualHubId) (result RoutingIntentListOperationResponse, err error)

RoutingIntentList ...

func (VirtualWANsClient) RoutingIntentListComplete ¶ 

func (c VirtualWANsClient) RoutingIntentListComplete(ctx context.Context, id VirtualHubId) (RoutingIntentListCompleteResult, error)

RoutingIntentListComplete retrieves all the results into a single object

func (VirtualWANsClient) RoutingIntentListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) RoutingIntentListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate RoutingIntentOperationPredicate) (result RoutingIntentListCompleteResult, err error)

RoutingIntentListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) SupportedSecurityProviders ¶ 

func (c VirtualWANsClient) SupportedSecurityProviders(ctx context.Context, id VirtualWANId) (result SupportedSecurityProvidersOperationResponse, err error)

SupportedSecurityProviders ...

func (VirtualWANsClient) UpdateTags ¶ 

func (c VirtualWANsClient) UpdateTags(ctx context.Context, id VirtualWANId, input TagsObject) (result UpdateTagsOperationResponse, err error)

UpdateTags ...

func (VirtualWANsClient) VirtualHubBgpConnectionCreateOrUpdate ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionCreateOrUpdate(ctx context.Context, id commonids.VirtualHubBGPConnectionId, input BgpConnection) (result VirtualHubBgpConnectionCreateOrUpdateOperationResponse, err error)

VirtualHubBgpConnectionCreateOrUpdate ...

func (VirtualWANsClient) VirtualHubBgpConnectionCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionCreateOrUpdateThenPoll(ctx context.Context, id commonids.VirtualHubBGPConnectionId, input BgpConnection) error

VirtualHubBgpConnectionCreateOrUpdateThenPoll performs VirtualHubBgpConnectionCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VirtualHubBgpConnectionDelete ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionDelete(ctx context.Context, id commonids.VirtualHubBGPConnectionId) (result VirtualHubBgpConnectionDeleteOperationResponse, err error)

VirtualHubBgpConnectionDelete ...

func (VirtualWANsClient) VirtualHubBgpConnectionDeleteThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionDeleteThenPoll(ctx context.Context, id commonids.VirtualHubBGPConnectionId) error

VirtualHubBgpConnectionDeleteThenPoll performs VirtualHubBgpConnectionDelete then polls until it's completed

func (VirtualWANsClient) VirtualHubBgpConnectionGet ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionGet(ctx context.Context, id commonids.VirtualHubBGPConnectionId) (result VirtualHubBgpConnectionGetOperationResponse, err error)

VirtualHubBgpConnectionGet ...

func (VirtualWANsClient) VirtualHubBgpConnectionsList ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsList(ctx context.Context, id VirtualHubId) (result VirtualHubBgpConnectionsListOperationResponse, err error)

VirtualHubBgpConnectionsList ...

func (VirtualWANsClient) VirtualHubBgpConnectionsListAdvertisedRoutes ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsListAdvertisedRoutes(ctx context.Context, id commonids.VirtualHubBGPConnectionId) (result VirtualHubBgpConnectionsListAdvertisedRoutesOperationResponse, err error)

VirtualHubBgpConnectionsListAdvertisedRoutes ...

func (VirtualWANsClient) VirtualHubBgpConnectionsListAdvertisedRoutesThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsListAdvertisedRoutesThenPoll(ctx context.Context, id commonids.VirtualHubBGPConnectionId) error

VirtualHubBgpConnectionsListAdvertisedRoutesThenPoll performs VirtualHubBgpConnectionsListAdvertisedRoutes then polls until it's completed

func (VirtualWANsClient) VirtualHubBgpConnectionsListComplete ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsListComplete(ctx context.Context, id VirtualHubId) (VirtualHubBgpConnectionsListCompleteResult, error)

VirtualHubBgpConnectionsListComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualHubBgpConnectionsListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate BgpConnectionOperationPredicate) (result VirtualHubBgpConnectionsListCompleteResult, err error)

VirtualHubBgpConnectionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VirtualHubBgpConnectionsListLearnedRoutes ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsListLearnedRoutes(ctx context.Context, id commonids.VirtualHubBGPConnectionId) (result VirtualHubBgpConnectionsListLearnedRoutesOperationResponse, err error)

VirtualHubBgpConnectionsListLearnedRoutes ...

func (VirtualWANsClient) VirtualHubBgpConnectionsListLearnedRoutesThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubBgpConnectionsListLearnedRoutesThenPoll(ctx context.Context, id commonids.VirtualHubBGPConnectionId) error

VirtualHubBgpConnectionsListLearnedRoutesThenPoll performs VirtualHubBgpConnectionsListLearnedRoutes then polls until it's completed

func (VirtualWANsClient) VirtualHubIPConfigurationCreateOrUpdate ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationCreateOrUpdate(ctx context.Context, id commonids.VirtualHubIPConfigurationId, input HubIPConfiguration) (result VirtualHubIPConfigurationCreateOrUpdateOperationResponse, err error)

VirtualHubIPConfigurationCreateOrUpdate ...

func (VirtualWANsClient) VirtualHubIPConfigurationCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationCreateOrUpdateThenPoll(ctx context.Context, id commonids.VirtualHubIPConfigurationId, input HubIPConfiguration) error

VirtualHubIPConfigurationCreateOrUpdateThenPoll performs VirtualHubIPConfigurationCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VirtualHubIPConfigurationDelete ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationDelete(ctx context.Context, id commonids.VirtualHubIPConfigurationId) (result VirtualHubIPConfigurationDeleteOperationResponse, err error)

VirtualHubIPConfigurationDelete ...

func (VirtualWANsClient) VirtualHubIPConfigurationDeleteThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationDeleteThenPoll(ctx context.Context, id commonids.VirtualHubIPConfigurationId) error

VirtualHubIPConfigurationDeleteThenPoll performs VirtualHubIPConfigurationDelete then polls until it's completed

func (VirtualWANsClient) VirtualHubIPConfigurationGet ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationGet(ctx context.Context, id commonids.VirtualHubIPConfigurationId) (result VirtualHubIPConfigurationGetOperationResponse, err error)

VirtualHubIPConfigurationGet ...

func (VirtualWANsClient) VirtualHubIPConfigurationList ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationList(ctx context.Context, id VirtualHubId) (result VirtualHubIPConfigurationListOperationResponse, err error)

VirtualHubIPConfigurationList ...

func (VirtualWANsClient) VirtualHubIPConfigurationListComplete ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationListComplete(ctx context.Context, id VirtualHubId) (VirtualHubIPConfigurationListCompleteResult, error)

VirtualHubIPConfigurationListComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualHubIPConfigurationListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualHubIPConfigurationListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate HubIPConfigurationOperationPredicate) (result VirtualHubIPConfigurationListCompleteResult, err error)

VirtualHubIPConfigurationListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VirtualHubRouteTableV2sCreateOrUpdate ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sCreateOrUpdate(ctx context.Context, id VirtualHubRouteTableId, input VirtualHubRouteTableV2) (result VirtualHubRouteTableV2sCreateOrUpdateOperationResponse, err error)

VirtualHubRouteTableV2sCreateOrUpdate ...

func (VirtualWANsClient) VirtualHubRouteTableV2sCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sCreateOrUpdateThenPoll(ctx context.Context, id VirtualHubRouteTableId, input VirtualHubRouteTableV2) error

VirtualHubRouteTableV2sCreateOrUpdateThenPoll performs VirtualHubRouteTableV2sCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VirtualHubRouteTableV2sDelete ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sDelete(ctx context.Context, id VirtualHubRouteTableId) (result VirtualHubRouteTableV2sDeleteOperationResponse, err error)

VirtualHubRouteTableV2sDelete ...

func (VirtualWANsClient) VirtualHubRouteTableV2sDeleteThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sDeleteThenPoll(ctx context.Context, id VirtualHubRouteTableId) error

VirtualHubRouteTableV2sDeleteThenPoll performs VirtualHubRouteTableV2sDelete then polls until it's completed

func (VirtualWANsClient) VirtualHubRouteTableV2sGet ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sGet(ctx context.Context, id VirtualHubRouteTableId) (result VirtualHubRouteTableV2sGetOperationResponse, err error)

VirtualHubRouteTableV2sGet ...

func (VirtualWANsClient) VirtualHubRouteTableV2sList ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sList(ctx context.Context, id VirtualHubId) (result VirtualHubRouteTableV2sListOperationResponse, err error)

VirtualHubRouteTableV2sList ...

func (VirtualWANsClient) VirtualHubRouteTableV2sListComplete ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sListComplete(ctx context.Context, id VirtualHubId) (VirtualHubRouteTableV2sListCompleteResult, error)

VirtualHubRouteTableV2sListComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualHubRouteTableV2sListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualHubRouteTableV2sListCompleteMatchingPredicate(ctx context.Context, id VirtualHubId, predicate VirtualHubRouteTableV2OperationPredicate) (result VirtualHubRouteTableV2sListCompleteResult, err error)

VirtualHubRouteTableV2sListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VirtualHubsCreateOrUpdate ¶ 

func (c VirtualWANsClient) VirtualHubsCreateOrUpdate(ctx context.Context, id VirtualHubId, input VirtualHub) (result VirtualHubsCreateOrUpdateOperationResponse, err error)

VirtualHubsCreateOrUpdate ...

func (VirtualWANsClient) VirtualHubsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubsCreateOrUpdateThenPoll(ctx context.Context, id VirtualHubId, input VirtualHub) error

VirtualHubsCreateOrUpdateThenPoll performs VirtualHubsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VirtualHubsDelete ¶ 

func (c VirtualWANsClient) VirtualHubsDelete(ctx context.Context, id VirtualHubId) (result VirtualHubsDeleteOperationResponse, err error)

VirtualHubsDelete ...

func (VirtualWANsClient) VirtualHubsDeleteThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubsDeleteThenPoll(ctx context.Context, id VirtualHubId) error

VirtualHubsDeleteThenPoll performs VirtualHubsDelete then polls until it's completed

func (VirtualWANsClient) VirtualHubsGet ¶ 

func (c VirtualWANsClient) VirtualHubsGet(ctx context.Context, id VirtualHubId) (result VirtualHubsGetOperationResponse, err error)

VirtualHubsGet ...

func (VirtualWANsClient) VirtualHubsGetEffectiveVirtualHubRoutes ¶ 

func (c VirtualWANsClient) VirtualHubsGetEffectiveVirtualHubRoutes(ctx context.Context, id VirtualHubId, input EffectiveRoutesParameters) (result VirtualHubsGetEffectiveVirtualHubRoutesOperationResponse, err error)

VirtualHubsGetEffectiveVirtualHubRoutes ...

func (VirtualWANsClient) VirtualHubsGetEffectiveVirtualHubRoutesThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubsGetEffectiveVirtualHubRoutesThenPoll(ctx context.Context, id VirtualHubId, input EffectiveRoutesParameters) error

VirtualHubsGetEffectiveVirtualHubRoutesThenPoll performs VirtualHubsGetEffectiveVirtualHubRoutes then polls until it's completed

func (VirtualWANsClient) VirtualHubsGetInboundRoutes ¶ 

func (c VirtualWANsClient) VirtualHubsGetInboundRoutes(ctx context.Context, id VirtualHubId, input GetInboundRoutesParameters) (result VirtualHubsGetInboundRoutesOperationResponse, err error)

VirtualHubsGetInboundRoutes ...

func (VirtualWANsClient) VirtualHubsGetInboundRoutesThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubsGetInboundRoutesThenPoll(ctx context.Context, id VirtualHubId, input GetInboundRoutesParameters) error

VirtualHubsGetInboundRoutesThenPoll performs VirtualHubsGetInboundRoutes then polls until it's completed

func (VirtualWANsClient) VirtualHubsGetOutboundRoutes ¶ 

func (c VirtualWANsClient) VirtualHubsGetOutboundRoutes(ctx context.Context, id VirtualHubId, input GetOutboundRoutesParameters) (result VirtualHubsGetOutboundRoutesOperationResponse, err error)

VirtualHubsGetOutboundRoutes ...

func (VirtualWANsClient) VirtualHubsGetOutboundRoutesThenPoll ¶ 

func (c VirtualWANsClient) VirtualHubsGetOutboundRoutesThenPoll(ctx context.Context, id VirtualHubId, input GetOutboundRoutesParameters) error

VirtualHubsGetOutboundRoutesThenPoll performs VirtualHubsGetOutboundRoutes then polls until it's completed

func (VirtualWANsClient) VirtualHubsList ¶ 

func (c VirtualWANsClient) VirtualHubsList(ctx context.Context, id commonids.SubscriptionId) (result VirtualHubsListOperationResponse, err error)

VirtualHubsList ...

func (VirtualWANsClient) VirtualHubsListByResourceGroup ¶ 

func (c VirtualWANsClient) VirtualHubsListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VirtualHubsListByResourceGroupOperationResponse, err error)

VirtualHubsListByResourceGroup ...

func (VirtualWANsClient) VirtualHubsListByResourceGroupComplete ¶ 

func (c VirtualWANsClient) VirtualHubsListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VirtualHubsListByResourceGroupCompleteResult, error)

VirtualHubsListByResourceGroupComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualHubsListByResourceGroupCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualHubsListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VirtualHubOperationPredicate) (result VirtualHubsListByResourceGroupCompleteResult, err error)

VirtualHubsListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VirtualHubsListComplete ¶ 

func (c VirtualWANsClient) VirtualHubsListComplete(ctx context.Context, id commonids.SubscriptionId) (VirtualHubsListCompleteResult, error)

VirtualHubsListComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualHubsListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualHubsListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VirtualHubOperationPredicate) (result VirtualHubsListCompleteResult, err error)

VirtualHubsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VirtualHubsUpdateTags ¶ 

func (c VirtualWANsClient) VirtualHubsUpdateTags(ctx context.Context, id VirtualHubId, input TagsObject) (result VirtualHubsUpdateTagsOperationResponse, err error)

VirtualHubsUpdateTags ...

func (VirtualWANsClient) VirtualWansCreateOrUpdate ¶ 

func (c VirtualWANsClient) VirtualWansCreateOrUpdate(ctx context.Context, id VirtualWANId, input VirtualWAN) (result VirtualWansCreateOrUpdateOperationResponse, err error)

VirtualWansCreateOrUpdate ...

func (VirtualWANsClient) VirtualWansCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VirtualWansCreateOrUpdateThenPoll(ctx context.Context, id VirtualWANId, input VirtualWAN) error

VirtualWansCreateOrUpdateThenPoll performs VirtualWansCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VirtualWansDelete ¶ 

func (c VirtualWANsClient) VirtualWansDelete(ctx context.Context, id VirtualWANId) (result VirtualWansDeleteOperationResponse, err error)

VirtualWansDelete ...

func (VirtualWANsClient) VirtualWansDeleteThenPoll ¶ 

func (c VirtualWANsClient) VirtualWansDeleteThenPoll(ctx context.Context, id VirtualWANId) error

VirtualWansDeleteThenPoll performs VirtualWansDelete then polls until it's completed

func (VirtualWANsClient) VirtualWansGet ¶ 

func (c VirtualWANsClient) VirtualWansGet(ctx context.Context, id VirtualWANId) (result VirtualWansGetOperationResponse, err error)

VirtualWansGet ...

func (VirtualWANsClient) VirtualWansList ¶ 

func (c VirtualWANsClient) VirtualWansList(ctx context.Context, id commonids.SubscriptionId) (result VirtualWansListOperationResponse, err error)

VirtualWansList ...

func (VirtualWANsClient) VirtualWansListByResourceGroup ¶ 

func (c VirtualWANsClient) VirtualWansListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VirtualWansListByResourceGroupOperationResponse, err error)

VirtualWansListByResourceGroup ...

func (VirtualWANsClient) VirtualWansListByResourceGroupComplete ¶ 

func (c VirtualWANsClient) VirtualWansListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VirtualWansListByResourceGroupCompleteResult, error)

VirtualWansListByResourceGroupComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualWansListByResourceGroupCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualWansListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VirtualWANOperationPredicate) (result VirtualWansListByResourceGroupCompleteResult, err error)

VirtualWansListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VirtualWansListComplete ¶ 

func (c VirtualWANsClient) VirtualWansListComplete(ctx context.Context, id commonids.SubscriptionId) (VirtualWansListCompleteResult, error)

VirtualWansListComplete retrieves all the results into a single object

func (VirtualWANsClient) VirtualWansListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VirtualWansListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VirtualWANOperationPredicate) (result VirtualWansListCompleteResult, err error)

VirtualWansListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnConnectionsCreateOrUpdate ¶ 

func (c VirtualWANsClient) VpnConnectionsCreateOrUpdate(ctx context.Context, id commonids.VPNConnectionId, input VpnConnection) (result VpnConnectionsCreateOrUpdateOperationResponse, err error)

VpnConnectionsCreateOrUpdate ...

func (VirtualWANsClient) VpnConnectionsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VpnConnectionsCreateOrUpdateThenPoll(ctx context.Context, id commonids.VPNConnectionId, input VpnConnection) error

VpnConnectionsCreateOrUpdateThenPoll performs VpnConnectionsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VpnConnectionsDelete ¶ 

func (c VirtualWANsClient) VpnConnectionsDelete(ctx context.Context, id commonids.VPNConnectionId) (result VpnConnectionsDeleteOperationResponse, err error)

VpnConnectionsDelete ...

func (VirtualWANsClient) VpnConnectionsDeleteThenPoll ¶ 

func (c VirtualWANsClient) VpnConnectionsDeleteThenPoll(ctx context.Context, id commonids.VPNConnectionId) error

VpnConnectionsDeleteThenPoll performs VpnConnectionsDelete then polls until it's completed

func (VirtualWANsClient) VpnConnectionsGet ¶ 

func (c VirtualWANsClient) VpnConnectionsGet(ctx context.Context, id commonids.VPNConnectionId) (result VpnConnectionsGetOperationResponse, err error)

VpnConnectionsGet ...

func (VirtualWANsClient) VpnConnectionsListByVpnGateway ¶ 

func (c VirtualWANsClient) VpnConnectionsListByVpnGateway(ctx context.Context, id VpnGatewayId) (result VpnConnectionsListByVpnGatewayOperationResponse, err error)

VpnConnectionsListByVpnGateway ...

func (VirtualWANsClient) VpnConnectionsListByVpnGatewayComplete ¶ 

func (c VirtualWANsClient) VpnConnectionsListByVpnGatewayComplete(ctx context.Context, id VpnGatewayId) (VpnConnectionsListByVpnGatewayCompleteResult, error)

VpnConnectionsListByVpnGatewayComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnConnectionsListByVpnGatewayCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnConnectionsListByVpnGatewayCompleteMatchingPredicate(ctx context.Context, id VpnGatewayId, predicate VpnConnectionOperationPredicate) (result VpnConnectionsListByVpnGatewayCompleteResult, err error)

VpnConnectionsListByVpnGatewayCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnConnectionsStartPacketCapture ¶ 

func (c VirtualWANsClient) VpnConnectionsStartPacketCapture(ctx context.Context, id commonids.VPNConnectionId, input VpnConnectionPacketCaptureStartParameters) (result VpnConnectionsStartPacketCaptureOperationResponse, err error)

VpnConnectionsStartPacketCapture ...

func (VirtualWANsClient) VpnConnectionsStartPacketCaptureThenPoll ¶ 

func (c VirtualWANsClient) VpnConnectionsStartPacketCaptureThenPoll(ctx context.Context, id commonids.VPNConnectionId, input VpnConnectionPacketCaptureStartParameters) error

VpnConnectionsStartPacketCaptureThenPoll performs VpnConnectionsStartPacketCapture then polls until it's completed

func (VirtualWANsClient) VpnConnectionsStopPacketCapture ¶ 

func (c VirtualWANsClient) VpnConnectionsStopPacketCapture(ctx context.Context, id commonids.VPNConnectionId, input VpnConnectionPacketCaptureStopParameters) (result VpnConnectionsStopPacketCaptureOperationResponse, err error)

VpnConnectionsStopPacketCapture ...

func (VirtualWANsClient) VpnConnectionsStopPacketCaptureThenPoll ¶ 

func (c VirtualWANsClient) VpnConnectionsStopPacketCaptureThenPoll(ctx context.Context, id commonids.VPNConnectionId, input VpnConnectionPacketCaptureStopParameters) error

VpnConnectionsStopPacketCaptureThenPoll performs VpnConnectionsStopPacketCapture then polls until it's completed

func (VirtualWANsClient) VpnGatewaysCreateOrUpdate ¶ 

func (c VirtualWANsClient) VpnGatewaysCreateOrUpdate(ctx context.Context, id VpnGatewayId, input VpnGateway) (result VpnGatewaysCreateOrUpdateOperationResponse, err error)

VpnGatewaysCreateOrUpdate ...

func (VirtualWANsClient) VpnGatewaysCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VpnGatewaysCreateOrUpdateThenPoll(ctx context.Context, id VpnGatewayId, input VpnGateway) error

VpnGatewaysCreateOrUpdateThenPoll performs VpnGatewaysCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VpnGatewaysDelete ¶ 

func (c VirtualWANsClient) VpnGatewaysDelete(ctx context.Context, id VpnGatewayId) (result VpnGatewaysDeleteOperationResponse, err error)

VpnGatewaysDelete ...

func (VirtualWANsClient) VpnGatewaysDeleteThenPoll ¶ 

func (c VirtualWANsClient) VpnGatewaysDeleteThenPoll(ctx context.Context, id VpnGatewayId) error

VpnGatewaysDeleteThenPoll performs VpnGatewaysDelete then polls until it's completed

func (VirtualWANsClient) VpnGatewaysGet ¶ 

func (c VirtualWANsClient) VpnGatewaysGet(ctx context.Context, id VpnGatewayId) (result VpnGatewaysGetOperationResponse, err error)

VpnGatewaysGet ...

func (VirtualWANsClient) VpnGatewaysList ¶ 

func (c VirtualWANsClient) VpnGatewaysList(ctx context.Context, id commonids.SubscriptionId) (result VpnGatewaysListOperationResponse, err error)

VpnGatewaysList ...

func (VirtualWANsClient) VpnGatewaysListByResourceGroup ¶ 

func (c VirtualWANsClient) VpnGatewaysListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VpnGatewaysListByResourceGroupOperationResponse, err error)

VpnGatewaysListByResourceGroup ...

func (VirtualWANsClient) VpnGatewaysListByResourceGroupComplete ¶ 

func (c VirtualWANsClient) VpnGatewaysListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VpnGatewaysListByResourceGroupCompleteResult, error)

VpnGatewaysListByResourceGroupComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnGatewaysListByResourceGroupCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnGatewaysListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VpnGatewayOperationPredicate) (result VpnGatewaysListByResourceGroupCompleteResult, err error)

VpnGatewaysListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnGatewaysListComplete ¶ 

func (c VirtualWANsClient) VpnGatewaysListComplete(ctx context.Context, id commonids.SubscriptionId) (VpnGatewaysListCompleteResult, error)

VpnGatewaysListComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnGatewaysListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnGatewaysListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VpnGatewayOperationPredicate) (result VpnGatewaysListCompleteResult, err error)

VpnGatewaysListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnLinkConnectionsGetIkeSas ¶ 

func (c VirtualWANsClient) VpnLinkConnectionsGetIkeSas(ctx context.Context, id VpnLinkConnectionId) (result VpnLinkConnectionsGetIkeSasOperationResponse, err error)

VpnLinkConnectionsGetIkeSas ...

func (VirtualWANsClient) VpnLinkConnectionsGetIkeSasThenPoll ¶ 

func (c VirtualWANsClient) VpnLinkConnectionsGetIkeSasThenPoll(ctx context.Context, id VpnLinkConnectionId) error

VpnLinkConnectionsGetIkeSasThenPoll performs VpnLinkConnectionsGetIkeSas then polls until it's completed

func (VirtualWANsClient) VpnLinkConnectionsListByVpnConnection ¶ 

func (c VirtualWANsClient) VpnLinkConnectionsListByVpnConnection(ctx context.Context, id commonids.VPNConnectionId) (result VpnLinkConnectionsListByVpnConnectionOperationResponse, err error)

VpnLinkConnectionsListByVpnConnection ...

func (VirtualWANsClient) VpnLinkConnectionsListByVpnConnectionComplete ¶ 

func (c VirtualWANsClient) VpnLinkConnectionsListByVpnConnectionComplete(ctx context.Context, id commonids.VPNConnectionId) (VpnLinkConnectionsListByVpnConnectionCompleteResult, error)

VpnLinkConnectionsListByVpnConnectionComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnLinkConnectionsListByVpnConnectionCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnLinkConnectionsListByVpnConnectionCompleteMatchingPredicate(ctx context.Context, id commonids.VPNConnectionId, predicate VpnSiteLinkConnectionOperationPredicate) (result VpnLinkConnectionsListByVpnConnectionCompleteResult, err error)

VpnLinkConnectionsListByVpnConnectionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnServerConfigurationsAssociatedWithVirtualWanList ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsAssociatedWithVirtualWanList(ctx context.Context, id VirtualWANId) (result VpnServerConfigurationsAssociatedWithVirtualWanListOperationResponse, err error)

VpnServerConfigurationsAssociatedWithVirtualWanList ...

func (VirtualWANsClient) VpnServerConfigurationsAssociatedWithVirtualWanListThenPoll ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsAssociatedWithVirtualWanListThenPoll(ctx context.Context, id VirtualWANId) error

VpnServerConfigurationsAssociatedWithVirtualWanListThenPoll performs VpnServerConfigurationsAssociatedWithVirtualWanList then polls until it's completed

func (VirtualWANsClient) VpnServerConfigurationsCreateOrUpdate ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsCreateOrUpdate(ctx context.Context, id VpnServerConfigurationId, input VpnServerConfiguration) (result VpnServerConfigurationsCreateOrUpdateOperationResponse, err error)

VpnServerConfigurationsCreateOrUpdate ...

func (VirtualWANsClient) VpnServerConfigurationsCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsCreateOrUpdateThenPoll(ctx context.Context, id VpnServerConfigurationId, input VpnServerConfiguration) error

VpnServerConfigurationsCreateOrUpdateThenPoll performs VpnServerConfigurationsCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VpnServerConfigurationsDelete ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsDelete(ctx context.Context, id VpnServerConfigurationId) (result VpnServerConfigurationsDeleteOperationResponse, err error)

VpnServerConfigurationsDelete ...

func (VirtualWANsClient) VpnServerConfigurationsDeleteThenPoll ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsDeleteThenPoll(ctx context.Context, id VpnServerConfigurationId) error

VpnServerConfigurationsDeleteThenPoll performs VpnServerConfigurationsDelete then polls until it's completed

func (VirtualWANsClient) VpnServerConfigurationsGet ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsGet(ctx context.Context, id VpnServerConfigurationId) (result VpnServerConfigurationsGetOperationResponse, err error)

VpnServerConfigurationsGet ...

func (VirtualWANsClient) VpnServerConfigurationsList ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsList(ctx context.Context, id commonids.SubscriptionId) (result VpnServerConfigurationsListOperationResponse, err error)

VpnServerConfigurationsList ...

func (VirtualWANsClient) VpnServerConfigurationsListByResourceGroup ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VpnServerConfigurationsListByResourceGroupOperationResponse, err error)

VpnServerConfigurationsListByResourceGroup ...

func (VirtualWANsClient) VpnServerConfigurationsListByResourceGroupComplete ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VpnServerConfigurationsListByResourceGroupCompleteResult, error)

VpnServerConfigurationsListByResourceGroupComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnServerConfigurationsListByResourceGroupCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VpnServerConfigurationOperationPredicate) (result VpnServerConfigurationsListByResourceGroupCompleteResult, err error)

VpnServerConfigurationsListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnServerConfigurationsListComplete ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsListComplete(ctx context.Context, id commonids.SubscriptionId) (VpnServerConfigurationsListCompleteResult, error)

VpnServerConfigurationsListComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnServerConfigurationsListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnServerConfigurationsListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VpnServerConfigurationOperationPredicate) (result VpnServerConfigurationsListCompleteResult, err error)

VpnServerConfigurationsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnSiteLinkConnectionsGet ¶ 

func (c VirtualWANsClient) VpnSiteLinkConnectionsGet(ctx context.Context, id VpnLinkConnectionId) (result VpnSiteLinkConnectionsGetOperationResponse, err error)

VpnSiteLinkConnectionsGet ...

func (VirtualWANsClient) VpnSiteLinksGet ¶ 

func (c VirtualWANsClient) VpnSiteLinksGet(ctx context.Context, id VpnSiteLinkId) (result VpnSiteLinksGetOperationResponse, err error)

VpnSiteLinksGet ...

func (VirtualWANsClient) VpnSiteLinksListByVpnSite ¶ 

func (c VirtualWANsClient) VpnSiteLinksListByVpnSite(ctx context.Context, id VpnSiteId) (result VpnSiteLinksListByVpnSiteOperationResponse, err error)

VpnSiteLinksListByVpnSite ...

func (VirtualWANsClient) VpnSiteLinksListByVpnSiteComplete ¶ 

func (c VirtualWANsClient) VpnSiteLinksListByVpnSiteComplete(ctx context.Context, id VpnSiteId) (VpnSiteLinksListByVpnSiteCompleteResult, error)

VpnSiteLinksListByVpnSiteComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnSiteLinksListByVpnSiteCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnSiteLinksListByVpnSiteCompleteMatchingPredicate(ctx context.Context, id VpnSiteId, predicate VpnSiteLinkOperationPredicate) (result VpnSiteLinksListByVpnSiteCompleteResult, err error)

VpnSiteLinksListByVpnSiteCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnSitesConfigurationDownload ¶ 

func (c VirtualWANsClient) VpnSitesConfigurationDownload(ctx context.Context, id VirtualWANId, input GetVpnSitesConfigurationRequest) (result VpnSitesConfigurationDownloadOperationResponse, err error)

VpnSitesConfigurationDownload ...

func (VirtualWANsClient) VpnSitesConfigurationDownloadThenPoll ¶ 

func (c VirtualWANsClient) VpnSitesConfigurationDownloadThenPoll(ctx context.Context, id VirtualWANId, input GetVpnSitesConfigurationRequest) error

VpnSitesConfigurationDownloadThenPoll performs VpnSitesConfigurationDownload then polls until it's completed

func (VirtualWANsClient) VpnSitesCreateOrUpdate ¶ 

func (c VirtualWANsClient) VpnSitesCreateOrUpdate(ctx context.Context, id VpnSiteId, input VpnSite) (result VpnSitesCreateOrUpdateOperationResponse, err error)

VpnSitesCreateOrUpdate ...

func (VirtualWANsClient) VpnSitesCreateOrUpdateThenPoll ¶ 

func (c VirtualWANsClient) VpnSitesCreateOrUpdateThenPoll(ctx context.Context, id VpnSiteId, input VpnSite) error

VpnSitesCreateOrUpdateThenPoll performs VpnSitesCreateOrUpdate then polls until it's completed

func (VirtualWANsClient) VpnSitesDelete ¶ 

func (c VirtualWANsClient) VpnSitesDelete(ctx context.Context, id VpnSiteId) (result VpnSitesDeleteOperationResponse, err error)

VpnSitesDelete ...

func (VirtualWANsClient) VpnSitesDeleteThenPoll ¶ 

func (c VirtualWANsClient) VpnSitesDeleteThenPoll(ctx context.Context, id VpnSiteId) error

VpnSitesDeleteThenPoll performs VpnSitesDelete then polls until it's completed

func (VirtualWANsClient) VpnSitesGet ¶ 

func (c VirtualWANsClient) VpnSitesGet(ctx context.Context, id VpnSiteId) (result VpnSitesGetOperationResponse, err error)

VpnSitesGet ...

func (VirtualWANsClient) VpnSitesList ¶ 

func (c VirtualWANsClient) VpnSitesList(ctx context.Context, id commonids.SubscriptionId) (result VpnSitesListOperationResponse, err error)

VpnSitesList ...

func (VirtualWANsClient) VpnSitesListByResourceGroup ¶ 

func (c VirtualWANsClient) VpnSitesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VpnSitesListByResourceGroupOperationResponse, err error)

VpnSitesListByResourceGroup ...

func (VirtualWANsClient) VpnSitesListByResourceGroupComplete ¶ 

func (c VirtualWANsClient) VpnSitesListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VpnSitesListByResourceGroupCompleteResult, error)

VpnSitesListByResourceGroupComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnSitesListByResourceGroupCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnSitesListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VpnSiteOperationPredicate) (result VpnSitesListByResourceGroupCompleteResult, err error)

VpnSitesListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (VirtualWANsClient) VpnSitesListComplete ¶ 

func (c VirtualWANsClient) VpnSitesListComplete(ctx context.Context, id commonids.SubscriptionId) (VpnSitesListCompleteResult, error)

VpnSitesListComplete retrieves all the results into a single object

func (VirtualWANsClient) VpnSitesListCompleteMatchingPredicate ¶ 

func (c VirtualWANsClient) VpnSitesListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VpnSiteOperationPredicate) (result VpnSitesListCompleteResult, err error)

VpnSitesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

type VirtualWanProperties ¶ 

type VirtualWanProperties struct {
	AllowBranchToBranchTraffic     *bool                  `json:"allowBranchToBranchTraffic,omitempty"`
	AllowVnetToVnetTraffic         *bool                  `json:"allowVnetToVnetTraffic,omitempty"`
	DisableVpnEncryption           *bool                  `json:"disableVpnEncryption,omitempty"`
	Office365LocalBreakoutCategory *OfficeTrafficCategory `json:"office365LocalBreakoutCategory,omitempty"`
	ProvisioningState              *ProvisioningState     `json:"provisioningState,omitempty"`
	Type                           *string                `json:"type,omitempty"`
	VirtualHubs                    *[]SubResource         `json:"virtualHubs,omitempty"`
	VpnSites                       *[]SubResource         `json:"vpnSites,omitempty"`
}

type VirtualWanSecurityProvider ¶ 

type VirtualWanSecurityProvider struct {
	Name *string                         `json:"name,omitempty"`
	Type *VirtualWanSecurityProviderType `json:"type,omitempty"`
	Url  *string                         `json:"url,omitempty"`
}

type VirtualWanSecurityProviderType ¶ 

type VirtualWanSecurityProviderType string
const (
	VirtualWanSecurityProviderTypeExternal VirtualWanSecurityProviderType = "External"
	VirtualWanSecurityProviderTypeNative   VirtualWanSecurityProviderType = "Native"
)

func (*VirtualWanSecurityProviderType) UnmarshalJSON ¶ 

func (s *VirtualWanSecurityProviderType) UnmarshalJSON(bytes []byte) error

type VirtualWanSecurityProviders ¶ 

type VirtualWanSecurityProviders struct {
	SupportedProviders *[]VirtualWanSecurityProvider `json:"supportedProviders,omitempty"`
}

type VirtualWanVpnProfileParameters ¶ 

type VirtualWanVpnProfileParameters struct {
	AuthenticationMethod             *AuthenticationMethod `json:"authenticationMethod,omitempty"`
	VpnServerConfigurationResourceId *string               `json:"vpnServerConfigurationResourceId,omitempty"`
}

type VirtualWansCreateOrUpdateOperationResponse ¶ 

type VirtualWansCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualWAN
}

type VirtualWansDeleteOperationResponse ¶ 

type VirtualWansDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VirtualWansGetOperationResponse ¶ 

type VirtualWansGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualWAN
}

type VirtualWansListByResourceGroupCompleteResult ¶ 

type VirtualWansListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualWAN
}

type VirtualWansListByResourceGroupOperationResponse ¶ 

type VirtualWansListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualWAN
}

type VirtualWansListCompleteResult ¶ 

type VirtualWansListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualWAN
}

type VirtualWansListOperationResponse ¶ 

type VirtualWansListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualWAN
}

type VnetLocalRouteOverrideCriteria ¶ 

type VnetLocalRouteOverrideCriteria string
const (
	VnetLocalRouteOverrideCriteriaContains VnetLocalRouteOverrideCriteria = "Contains"
	VnetLocalRouteOverrideCriteriaEqual    VnetLocalRouteOverrideCriteria = "Equal"
)

func (*VnetLocalRouteOverrideCriteria) UnmarshalJSON ¶ 

func (s *VnetLocalRouteOverrideCriteria) UnmarshalJSON(bytes []byte) error

type VnetRoute ¶ 

type VnetRoute struct {
	BgpConnections     *[]SubResource      `json:"bgpConnections,omitempty"`
	StaticRoutes       *[]StaticRoute      `json:"staticRoutes,omitempty"`
	StaticRoutesConfig *StaticRoutesConfig `json:"staticRoutesConfig,omitempty"`
}

type VpnAuthenticationType ¶ 

type VpnAuthenticationType string
const (
	VpnAuthenticationTypeAAD         VpnAuthenticationType = "AAD"
	VpnAuthenticationTypeCertificate VpnAuthenticationType = "Certificate"
	VpnAuthenticationTypeRadius      VpnAuthenticationType = "Radius"
)

func (*VpnAuthenticationType) UnmarshalJSON ¶ 

func (s *VpnAuthenticationType) UnmarshalJSON(bytes []byte) error

type VpnClientConnectionHealth ¶ 

type VpnClientConnectionHealth struct {
	AllocatedIPAddresses         *[]string `json:"allocatedIpAddresses,omitempty"`
	TotalEgressBytesTransferred  *int64    `json:"totalEgressBytesTransferred,omitempty"`
	TotalIngressBytesTransferred *int64    `json:"totalIngressBytesTransferred,omitempty"`
	VpnClientConnectionsCount    *int64    `json:"vpnClientConnectionsCount,omitempty"`
}

type VpnConnection ¶ 

type VpnConnection struct {
	Etag       *string                  `json:"etag,omitempty"`
	Id         *string                  `json:"id,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *VpnConnectionProperties `json:"properties,omitempty"`
}

type VpnConnectionOperationPredicate ¶ 

type VpnConnectionOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
}

func (VpnConnectionOperationPredicate) Matches ¶ 

func (p VpnConnectionOperationPredicate) Matches(input VpnConnection) bool

type VpnConnectionPacketCaptureStartParameters ¶ 

type VpnConnectionPacketCaptureStartParameters struct {
	FilterData          *string   `json:"filterData,omitempty"`
	LinkConnectionNames *[]string `json:"linkConnectionNames,omitempty"`
}

type VpnConnectionPacketCaptureStopParameters ¶ 

type VpnConnectionPacketCaptureStopParameters struct {
	LinkConnectionNames *[]string `json:"linkConnectionNames,omitempty"`
	SasUrl              *string   `json:"sasUrl,omitempty"`
}

type VpnConnectionProperties ¶ 

type VpnConnectionProperties struct {
	ConnectionBandwidth            *int64                                   `json:"connectionBandwidth,omitempty"`
	ConnectionStatus               *VpnConnectionStatus                     `json:"connectionStatus,omitempty"`
	DpdTimeoutSeconds              *int64                                   `json:"dpdTimeoutSeconds,omitempty"`
	EgressBytesTransferred         *int64                                   `json:"egressBytesTransferred,omitempty"`
	EnableBgp                      *bool                                    `json:"enableBgp,omitempty"`
	EnableInternetSecurity         *bool                                    `json:"enableInternetSecurity,omitempty"`
	EnableRateLimiting             *bool                                    `json:"enableRateLimiting,omitempty"`
	IPsecPolicies                  *[]IPsecPolicy                           `json:"ipsecPolicies,omitempty"`
	IngressBytesTransferred        *int64                                   `json:"ingressBytesTransferred,omitempty"`
	ProvisioningState              *ProvisioningState                       `json:"provisioningState,omitempty"`
	RemoteVpnSite                  *SubResource                             `json:"remoteVpnSite,omitempty"`
	RoutingConfiguration           *RoutingConfiguration                    `json:"routingConfiguration,omitempty"`
	RoutingWeight                  *int64                                   `json:"routingWeight,omitempty"`
	SharedKey                      *string                                  `json:"sharedKey,omitempty"`
	TrafficSelectorPolicies        *[]TrafficSelectorPolicy                 `json:"trafficSelectorPolicies,omitempty"`
	UseLocalAzureIPAddress         *bool                                    `json:"useLocalAzureIpAddress,omitempty"`
	UsePolicyBasedTrafficSelectors *bool                                    `json:"usePolicyBasedTrafficSelectors,omitempty"`
	VpnConnectionProtocolType      *VirtualNetworkGatewayConnectionProtocol `json:"vpnConnectionProtocolType,omitempty"`
	VpnLinkConnections             *[]VpnSiteLinkConnection                 `json:"vpnLinkConnections,omitempty"`
}

type VpnConnectionStatus ¶ 

type VpnConnectionStatus string
const (
	VpnConnectionStatusConnected    VpnConnectionStatus = "Connected"
	VpnConnectionStatusConnecting   VpnConnectionStatus = "Connecting"
	VpnConnectionStatusNotConnected VpnConnectionStatus = "NotConnected"
	VpnConnectionStatusUnknown      VpnConnectionStatus = "Unknown"
)

func (*VpnConnectionStatus) UnmarshalJSON ¶ 

func (s *VpnConnectionStatus) UnmarshalJSON(bytes []byte) error

type VpnConnectionsCreateOrUpdateOperationResponse ¶ 

type VpnConnectionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnConnection
}

type VpnConnectionsDeleteOperationResponse ¶ 

type VpnConnectionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VpnConnectionsGetOperationResponse ¶ 

type VpnConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnConnection
}

type VpnConnectionsListByVpnGatewayCompleteResult ¶ 

type VpnConnectionsListByVpnGatewayCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnConnection
}

type VpnConnectionsListByVpnGatewayOperationResponse ¶ 

type VpnConnectionsListByVpnGatewayOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnConnection
}

type VpnConnectionsStartPacketCaptureOperationResponse ¶ 

type VpnConnectionsStartPacketCaptureOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *string
}

type VpnConnectionsStopPacketCaptureOperationResponse ¶ 

type VpnConnectionsStopPacketCaptureOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *string
}

type VpnGateway ¶ 

type VpnGateway struct {
	Etag       *string               `json:"etag,omitempty"`
	Id         *string               `json:"id,omitempty"`
	Location   *string               `json:"location,omitempty"`
	Name       *string               `json:"name,omitempty"`
	Properties *VpnGatewayProperties `json:"properties,omitempty"`
	Tags       *map[string]string    `json:"tags,omitempty"`
	Type       *string               `json:"type,omitempty"`
}

type VpnGatewayIPConfiguration ¶ 

type VpnGatewayIPConfiguration struct {
	Id               *string `json:"id,omitempty"`
	PrivateIPAddress *string `json:"privateIpAddress,omitempty"`
	PublicIPAddress  *string `json:"publicIpAddress,omitempty"`
}

type VpnGatewayId ¶ 

type VpnGatewayId struct {
	SubscriptionId    string
	ResourceGroupName string
	VpnGatewayName    string
}

VpnGatewayId is a struct representing the Resource ID for a Vpn Gateway

func NewVpnGatewayID ¶ 

func NewVpnGatewayID(subscriptionId string, resourceGroupName string, vpnGatewayName string) VpnGatewayId

NewVpnGatewayID returns a new VpnGatewayId struct

func ParseVpnGatewayID ¶ 

func ParseVpnGatewayID(input string) (*VpnGatewayId, error)

ParseVpnGatewayID parses 'input' into a VpnGatewayId

func ParseVpnGatewayIDInsensitively ¶ 

func ParseVpnGatewayIDInsensitively(input string) (*VpnGatewayId, error)

ParseVpnGatewayIDInsensitively parses 'input' case-insensitively into a VpnGatewayId note: this method should only be used for API response data and not user input

func (*VpnGatewayId) FromParseResult ¶ 

func (id *VpnGatewayId) FromParseResult(input resourceids.ParseResult) error

func (VpnGatewayId) ID ¶ 

func (id VpnGatewayId) ID() string

ID returns the formatted Vpn Gateway ID

func (VpnGatewayId) Segments ¶ 

func (id VpnGatewayId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Vpn Gateway ID

func (VpnGatewayId) String ¶ 

func (id VpnGatewayId) String() string

String returns a human-readable description of this Vpn Gateway ID

type VpnGatewayNatRule ¶ 

type VpnGatewayNatRule struct {
	Etag       *string                      `json:"etag,omitempty"`
	Id         *string                      `json:"id,omitempty"`
	Name       *string                      `json:"name,omitempty"`
	Properties *VpnGatewayNatRuleProperties `json:"properties,omitempty"`
	Type       *string                      `json:"type,omitempty"`
}

type VpnGatewayNatRuleOperationPredicate ¶ 

type VpnGatewayNatRuleOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (VpnGatewayNatRuleOperationPredicate) Matches ¶ 

func (p VpnGatewayNatRuleOperationPredicate) Matches(input VpnGatewayNatRule) bool

type VpnGatewayNatRuleProperties ¶ 

type VpnGatewayNatRuleProperties struct {
	EgressVpnSiteLinkConnections  *[]SubResource       `json:"egressVpnSiteLinkConnections,omitempty"`
	ExternalMappings              *[]VpnNatRuleMapping `json:"externalMappings,omitempty"`
	IPConfigurationId             *string              `json:"ipConfigurationId,omitempty"`
	IngressVpnSiteLinkConnections *[]SubResource       `json:"ingressVpnSiteLinkConnections,omitempty"`
	InternalMappings              *[]VpnNatRuleMapping `json:"internalMappings,omitempty"`
	Mode                          *VpnNatRuleMode      `json:"mode,omitempty"`
	ProvisioningState             *ProvisioningState   `json:"provisioningState,omitempty"`
	Type                          *VpnNatRuleType      `json:"type,omitempty"`
}

type VpnGatewayOperationPredicate ¶ 

type VpnGatewayOperationPredicate struct {
	Etag     *string
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (VpnGatewayOperationPredicate) Matches ¶ 

func (p VpnGatewayOperationPredicate) Matches(input VpnGateway) bool

type VpnGatewayProperties ¶ 

type VpnGatewayProperties struct {
	BgpSettings                     *BgpSettings                 `json:"bgpSettings,omitempty"`
	Connections                     *[]VpnConnection             `json:"connections,omitempty"`
	EnableBgpRouteTranslationForNat *bool                        `json:"enableBgpRouteTranslationForNat,omitempty"`
	IPConfigurations                *[]VpnGatewayIPConfiguration `json:"ipConfigurations,omitempty"`
	IsRoutingPreferenceInternet     *bool                        `json:"isRoutingPreferenceInternet,omitempty"`
	NatRules                        *[]VpnGatewayNatRule         `json:"natRules,omitempty"`
	ProvisioningState               *ProvisioningState           `json:"provisioningState,omitempty"`
	VirtualHub                      *SubResource                 `json:"virtualHub,omitempty"`
	VpnGatewayScaleUnit             *int64                       `json:"vpnGatewayScaleUnit,omitempty"`
}

type VpnGatewayTunnelingProtocol ¶ 

type VpnGatewayTunnelingProtocol string
const (
	VpnGatewayTunnelingProtocolIkeVTwo VpnGatewayTunnelingProtocol = "IkeV2"
	VpnGatewayTunnelingProtocolOpenVPN VpnGatewayTunnelingProtocol = "OpenVPN"
)

func (*VpnGatewayTunnelingProtocol) UnmarshalJSON ¶ 

func (s *VpnGatewayTunnelingProtocol) UnmarshalJSON(bytes []byte) error

type VpnGatewaysCreateOrUpdateOperationResponse ¶ 

type VpnGatewaysCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnGateway
}

type VpnGatewaysDeleteOperationResponse ¶ 

type VpnGatewaysDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VpnGatewaysGetOperationResponse ¶ 

type VpnGatewaysGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnGateway
}

type VpnGatewaysListByResourceGroupCompleteResult ¶ 

type VpnGatewaysListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnGateway
}

type VpnGatewaysListByResourceGroupOperationResponse ¶ 

type VpnGatewaysListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnGateway
}

type VpnGatewaysListCompleteResult ¶ 

type VpnGatewaysListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnGateway
}

type VpnGatewaysListOperationResponse ¶ 

type VpnGatewaysListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnGateway
}

type VpnLinkBgpSettings ¶ 

type VpnLinkBgpSettings struct {
	Asn               *int64  `json:"asn,omitempty"`
	BgpPeeringAddress *string `json:"bgpPeeringAddress,omitempty"`
}

type VpnLinkConnectionId ¶ 

type VpnLinkConnectionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	VpnGatewayName        string
	VpnConnectionName     string
	VpnLinkConnectionName string
}

VpnLinkConnectionId is a struct representing the Resource ID for a Vpn Link Connection

func NewVpnLinkConnectionID ¶ 

func NewVpnLinkConnectionID(subscriptionId string, resourceGroupName string, vpnGatewayName string, vpnConnectionName string, vpnLinkConnectionName string) VpnLinkConnectionId

NewVpnLinkConnectionID returns a new VpnLinkConnectionId struct

func ParseVpnLinkConnectionID ¶ 

func ParseVpnLinkConnectionID(input string) (*VpnLinkConnectionId, error)

ParseVpnLinkConnectionID parses 'input' into a VpnLinkConnectionId

func ParseVpnLinkConnectionIDInsensitively ¶ 

func ParseVpnLinkConnectionIDInsensitively(input string) (*VpnLinkConnectionId, error)

ParseVpnLinkConnectionIDInsensitively parses 'input' case-insensitively into a VpnLinkConnectionId note: this method should only be used for API response data and not user input

func (*VpnLinkConnectionId) FromParseResult ¶ 

func (id *VpnLinkConnectionId) FromParseResult(input resourceids.ParseResult) error

func (VpnLinkConnectionId) ID ¶ 

func (id VpnLinkConnectionId) ID() string

ID returns the formatted Vpn Link Connection ID

func (VpnLinkConnectionId) Segments ¶ 

func (id VpnLinkConnectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Vpn Link Connection ID

func (VpnLinkConnectionId) String ¶ 

func (id VpnLinkConnectionId) String() string

String returns a human-readable description of this Vpn Link Connection ID

type VpnLinkConnectionMode ¶ 

type VpnLinkConnectionMode string
const (
	VpnLinkConnectionModeDefault       VpnLinkConnectionMode = "Default"
	VpnLinkConnectionModeInitiatorOnly VpnLinkConnectionMode = "InitiatorOnly"
	VpnLinkConnectionModeResponderOnly VpnLinkConnectionMode = "ResponderOnly"
)

func (*VpnLinkConnectionMode) UnmarshalJSON ¶ 

func (s *VpnLinkConnectionMode) UnmarshalJSON(bytes []byte) error

type VpnLinkConnectionsGetIkeSasOperationResponse ¶ 

type VpnLinkConnectionsGetIkeSasOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *string
}

type VpnLinkConnectionsListByVpnConnectionCompleteResult ¶ 

type VpnLinkConnectionsListByVpnConnectionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnSiteLinkConnection
}

type VpnLinkConnectionsListByVpnConnectionOperationResponse ¶ 

type VpnLinkConnectionsListByVpnConnectionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnSiteLinkConnection
}

type VpnLinkProviderProperties ¶ 

type VpnLinkProviderProperties struct {
	LinkProviderName *string `json:"linkProviderName,omitempty"`
	LinkSpeedInMbps  *int64  `json:"linkSpeedInMbps,omitempty"`
}

type VpnNatRuleMapping ¶ 

type VpnNatRuleMapping struct {
	AddressSpace *string `json:"addressSpace,omitempty"`
	PortRange    *string `json:"portRange,omitempty"`
}

type VpnNatRuleMode ¶ 

type VpnNatRuleMode string
const (
	VpnNatRuleModeEgressSnat  VpnNatRuleMode = "EgressSnat"
	VpnNatRuleModeIngressSnat VpnNatRuleMode = "IngressSnat"
)

func (*VpnNatRuleMode) UnmarshalJSON ¶ 

func (s *VpnNatRuleMode) UnmarshalJSON(bytes []byte) error

type VpnNatRuleType ¶ 

type VpnNatRuleType string
const (
	VpnNatRuleTypeDynamic VpnNatRuleType = "Dynamic"
	VpnNatRuleTypeStatic  VpnNatRuleType = "Static"
)

func (*VpnNatRuleType) UnmarshalJSON ¶ 

func (s *VpnNatRuleType) UnmarshalJSON(bytes []byte) error

type VpnPolicyMemberAttributeType ¶ 

type VpnPolicyMemberAttributeType string
const (
	VpnPolicyMemberAttributeTypeAADGroupId         VpnPolicyMemberAttributeType = "AADGroupId"
	VpnPolicyMemberAttributeTypeCertificateGroupId VpnPolicyMemberAttributeType = "CertificateGroupId"
	VpnPolicyMemberAttributeTypeRadiusAzureGroupId VpnPolicyMemberAttributeType = "RadiusAzureGroupId"
)

func (*VpnPolicyMemberAttributeType) UnmarshalJSON ¶ 

func (s *VpnPolicyMemberAttributeType) UnmarshalJSON(bytes []byte) error

type VpnProfileResponse ¶ 

type VpnProfileResponse struct {
	ProfileUrl *string `json:"profileUrl,omitempty"`
}

type VpnServerConfigRadiusClientRootCertificate ¶ 

type VpnServerConfigRadiusClientRootCertificate struct {
	Name       *string `json:"name,omitempty"`
	Thumbprint *string `json:"thumbprint,omitempty"`
}

type VpnServerConfigRadiusServerRootCertificate ¶ 

type VpnServerConfigRadiusServerRootCertificate struct {
	Name           *string `json:"name,omitempty"`
	PublicCertData *string `json:"publicCertData,omitempty"`
}

type VpnServerConfigVpnClientRevokedCertificate ¶ 

type VpnServerConfigVpnClientRevokedCertificate struct {
	Name       *string `json:"name,omitempty"`
	Thumbprint *string `json:"thumbprint,omitempty"`
}

type VpnServerConfigVpnClientRootCertificate ¶ 

type VpnServerConfigVpnClientRootCertificate struct {
	Name           *string `json:"name,omitempty"`
	PublicCertData *string `json:"publicCertData,omitempty"`
}

type VpnServerConfiguration ¶ 

type VpnServerConfiguration struct {
	Etag       *string                           `json:"etag,omitempty"`
	Id         *string                           `json:"id,omitempty"`
	Location   *string                           `json:"location,omitempty"`
	Name       *string                           `json:"name,omitempty"`
	Properties *VpnServerConfigurationProperties `json:"properties,omitempty"`
	Tags       *map[string]string                `json:"tags,omitempty"`
	Type       *string                           `json:"type,omitempty"`
}

type VpnServerConfigurationId ¶ 

type VpnServerConfigurationId struct {
	SubscriptionId             string
	ResourceGroupName          string
	VpnServerConfigurationName string
}

VpnServerConfigurationId is a struct representing the Resource ID for a Vpn Server Configuration

func NewVpnServerConfigurationID ¶ 

func NewVpnServerConfigurationID(subscriptionId string, resourceGroupName string, vpnServerConfigurationName string) VpnServerConfigurationId

NewVpnServerConfigurationID returns a new VpnServerConfigurationId struct

func ParseVpnServerConfigurationID ¶ 

func ParseVpnServerConfigurationID(input string) (*VpnServerConfigurationId, error)

ParseVpnServerConfigurationID parses 'input' into a VpnServerConfigurationId

func ParseVpnServerConfigurationIDInsensitively ¶ 

func ParseVpnServerConfigurationIDInsensitively(input string) (*VpnServerConfigurationId, error)

ParseVpnServerConfigurationIDInsensitively parses 'input' case-insensitively into a VpnServerConfigurationId note: this method should only be used for API response data and not user input

func (*VpnServerConfigurationId) FromParseResult ¶ 

func (id *VpnServerConfigurationId) FromParseResult(input resourceids.ParseResult) error

func (VpnServerConfigurationId) ID ¶ 

func (id VpnServerConfigurationId) ID() string

ID returns the formatted Vpn Server Configuration ID

func (VpnServerConfigurationId) Segments ¶ 

func (id VpnServerConfigurationId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Vpn Server Configuration ID

func (VpnServerConfigurationId) String ¶ 

func (id VpnServerConfigurationId) String() string

String returns a human-readable description of this Vpn Server Configuration ID

type VpnServerConfigurationOperationPredicate ¶ 

type VpnServerConfigurationOperationPredicate struct {
	Etag     *string
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (VpnServerConfigurationOperationPredicate) Matches ¶ 

func (p VpnServerConfigurationOperationPredicate) Matches(input VpnServerConfiguration) bool

type VpnServerConfigurationPolicyGroup ¶ 

type VpnServerConfigurationPolicyGroup struct {
	Etag       *string                                      `json:"etag,omitempty"`
	Id         *string                                      `json:"id,omitempty"`
	Name       *string                                      `json:"name,omitempty"`
	Properties *VpnServerConfigurationPolicyGroupProperties `json:"properties,omitempty"`
	Type       *string                                      `json:"type,omitempty"`
}

type VpnServerConfigurationPolicyGroupMember ¶ 

type VpnServerConfigurationPolicyGroupMember struct {
	AttributeType  *VpnPolicyMemberAttributeType `json:"attributeType,omitempty"`
	AttributeValue *string                       `json:"attributeValue,omitempty"`
	Name           *string                       `json:"name,omitempty"`
}

type VpnServerConfigurationPolicyGroupOperationPredicate ¶ 

type VpnServerConfigurationPolicyGroupOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (VpnServerConfigurationPolicyGroupOperationPredicate) Matches ¶ 

func (p VpnServerConfigurationPolicyGroupOperationPredicate) Matches(input VpnServerConfigurationPolicyGroup) bool

type VpnServerConfigurationPolicyGroupProperties ¶ 

type VpnServerConfigurationPolicyGroupProperties struct {
	IsDefault                   *bool                                      `json:"isDefault,omitempty"`
	P2SConnectionConfigurations *[]SubResource                             `json:"p2SConnectionConfigurations,omitempty"`
	PolicyMembers               *[]VpnServerConfigurationPolicyGroupMember `json:"policyMembers,omitempty"`
	Priority                    *int64                                     `json:"priority,omitempty"`
	ProvisioningState           *ProvisioningState                         `json:"provisioningState,omitempty"`
}

type VpnServerConfigurationProperties ¶ 

type VpnServerConfigurationProperties struct {
	AadAuthenticationParameters  *AadAuthenticationParameters                  `json:"aadAuthenticationParameters,omitempty"`
	ConfigurationPolicyGroups    *[]VpnServerConfigurationPolicyGroup          `json:"configurationPolicyGroups,omitempty"`
	Etag                         *string                                       `json:"etag,omitempty"`
	Name                         *string                                       `json:"name,omitempty"`
	P2sVpnGateways               *[]P2SVpnGateway                              `json:"p2SVpnGateways,omitempty"`
	ProvisioningState            *string                                       `json:"provisioningState,omitempty"`
	RadiusClientRootCertificates *[]VpnServerConfigRadiusClientRootCertificate `json:"radiusClientRootCertificates,omitempty"`
	RadiusServerAddress          *string                                       `json:"radiusServerAddress,omitempty"`
	RadiusServerRootCertificates *[]VpnServerConfigRadiusServerRootCertificate `json:"radiusServerRootCertificates,omitempty"`
	RadiusServerSecret           *string                                       `json:"radiusServerSecret,omitempty"`
	RadiusServers                *[]RadiusServer                               `json:"radiusServers,omitempty"`
	VpnAuthenticationTypes       *[]VpnAuthenticationType                      `json:"vpnAuthenticationTypes,omitempty"`
	VpnClientIPsecPolicies       *[]IPsecPolicy                                `json:"vpnClientIpsecPolicies,omitempty"`
	VpnClientRevokedCertificates *[]VpnServerConfigVpnClientRevokedCertificate `json:"vpnClientRevokedCertificates,omitempty"`
	VpnClientRootCertificates    *[]VpnServerConfigVpnClientRootCertificate    `json:"vpnClientRootCertificates,omitempty"`
	VpnProtocols                 *[]VpnGatewayTunnelingProtocol                `json:"vpnProtocols,omitempty"`
}

type VpnServerConfigurationsAssociatedWithVirtualWanListOperationResponse ¶ 

type VpnServerConfigurationsAssociatedWithVirtualWanListOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnServerConfigurationsResponse
}

type VpnServerConfigurationsCreateOrUpdateOperationResponse ¶ 

type VpnServerConfigurationsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnServerConfiguration
}

type VpnServerConfigurationsDeleteOperationResponse ¶ 

type VpnServerConfigurationsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VpnServerConfigurationsGetOperationResponse ¶ 

type VpnServerConfigurationsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnServerConfiguration
}

type VpnServerConfigurationsListByResourceGroupCompleteResult ¶ 

type VpnServerConfigurationsListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnServerConfiguration
}

type VpnServerConfigurationsListByResourceGroupOperationResponse ¶ 

type VpnServerConfigurationsListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnServerConfiguration
}

type VpnServerConfigurationsListCompleteResult ¶ 

type VpnServerConfigurationsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnServerConfiguration
}

type VpnServerConfigurationsListOperationResponse ¶ 

type VpnServerConfigurationsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnServerConfiguration
}

type VpnServerConfigurationsResponse ¶ 

type VpnServerConfigurationsResponse struct {
	VpnServerConfigurationResourceIds *[]string `json:"vpnServerConfigurationResourceIds,omitempty"`
}

type VpnSite ¶ 

type VpnSite struct {
	Etag       *string            `json:"etag,omitempty"`
	Id         *string            `json:"id,omitempty"`
	Location   *string            `json:"location,omitempty"`
	Name       *string            `json:"name,omitempty"`
	Properties *VpnSiteProperties `json:"properties,omitempty"`
	Tags       *map[string]string `json:"tags,omitempty"`
	Type       *string            `json:"type,omitempty"`
}

type VpnSiteId ¶ 

type VpnSiteId struct {
	SubscriptionId    string
	ResourceGroupName string
	VpnSiteName       string
}

VpnSiteId is a struct representing the Resource ID for a Vpn Site

func NewVpnSiteID ¶ 

func NewVpnSiteID(subscriptionId string, resourceGroupName string, vpnSiteName string) VpnSiteId

NewVpnSiteID returns a new VpnSiteId struct

func ParseVpnSiteID ¶ 

func ParseVpnSiteID(input string) (*VpnSiteId, error)

ParseVpnSiteID parses 'input' into a VpnSiteId

func ParseVpnSiteIDInsensitively ¶ 

func ParseVpnSiteIDInsensitively(input string) (*VpnSiteId, error)

ParseVpnSiteIDInsensitively parses 'input' case-insensitively into a VpnSiteId note: this method should only be used for API response data and not user input

func (*VpnSiteId) FromParseResult ¶ 

func (id *VpnSiteId) FromParseResult(input resourceids.ParseResult) error

func (VpnSiteId) ID ¶ 

func (id VpnSiteId) ID() string

ID returns the formatted Vpn Site ID

func (VpnSiteId) Segments ¶ 

func (id VpnSiteId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Vpn Site ID

func (VpnSiteId) String ¶ 

func (id VpnSiteId) String() string

String returns a human-readable description of this Vpn Site ID 

type VpnSiteLink struct {
	Etag       *string                `json:"etag,omitempty"`
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *VpnSiteLinkProperties `json:"properties,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type VpnSiteLinkConnection ¶ 

type VpnSiteLinkConnection struct {
	Etag       *string                          `json:"etag,omitempty"`
	Id         *string                          `json:"id,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties *VpnSiteLinkConnectionProperties `json:"properties,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type VpnSiteLinkConnectionOperationPredicate ¶ 

type VpnSiteLinkConnectionOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (VpnSiteLinkConnectionOperationPredicate) Matches ¶ 

func (p VpnSiteLinkConnectionOperationPredicate) Matches(input VpnSiteLinkConnection) bool

type VpnSiteLinkConnectionProperties ¶ 

type VpnSiteLinkConnectionProperties struct {
	ConnectionBandwidth            *int64                                      `json:"connectionBandwidth,omitempty"`
	ConnectionStatus               *VpnConnectionStatus                        `json:"connectionStatus,omitempty"`
	DpdTimeoutSeconds              *int64                                      `json:"dpdTimeoutSeconds,omitempty"`
	EgressBytesTransferred         *int64                                      `json:"egressBytesTransferred,omitempty"`
	EgressNatRules                 *[]SubResource                              `json:"egressNatRules,omitempty"`
	EnableBgp                      *bool                                       `json:"enableBgp,omitempty"`
	EnableRateLimiting             *bool                                       `json:"enableRateLimiting,omitempty"`
	IPsecPolicies                  *[]IPsecPolicy                              `json:"ipsecPolicies,omitempty"`
	IngressBytesTransferred        *int64                                      `json:"ingressBytesTransferred,omitempty"`
	IngressNatRules                *[]SubResource                              `json:"ingressNatRules,omitempty"`
	ProvisioningState              *ProvisioningState                          `json:"provisioningState,omitempty"`
	RoutingWeight                  *int64                                      `json:"routingWeight,omitempty"`
	SharedKey                      *string                                     `json:"sharedKey,omitempty"`
	UseLocalAzureIPAddress         *bool                                       `json:"useLocalAzureIpAddress,omitempty"`
	UsePolicyBasedTrafficSelectors *bool                                       `json:"usePolicyBasedTrafficSelectors,omitempty"`
	VpnConnectionProtocolType      *VirtualNetworkGatewayConnectionProtocol    `json:"vpnConnectionProtocolType,omitempty"`
	VpnGatewayCustomBgpAddresses   *[]GatewayCustomBgpIPAddressIPConfiguration `json:"vpnGatewayCustomBgpAddresses,omitempty"`
	VpnLinkConnectionMode          *VpnLinkConnectionMode                      `json:"vpnLinkConnectionMode,omitempty"`
	VpnSiteLink                    *SubResource                                `json:"vpnSiteLink,omitempty"`
}

type VpnSiteLinkConnectionsGetOperationResponse ¶ 

type VpnSiteLinkConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnSiteLinkConnection
}

type VpnSiteLinkId ¶ 

type VpnSiteLinkId struct {
	SubscriptionId    string
	ResourceGroupName string
	VpnSiteName       string
	VpnSiteLinkName   string
}

VpnSiteLinkId is a struct representing the Resource ID for a Vpn Site Link

func NewVpnSiteLinkID ¶ 

func NewVpnSiteLinkID(subscriptionId string, resourceGroupName string, vpnSiteName string, vpnSiteLinkName string) VpnSiteLinkId

NewVpnSiteLinkID returns a new VpnSiteLinkId struct

func ParseVpnSiteLinkID ¶ 

func ParseVpnSiteLinkID(input string) (*VpnSiteLinkId, error)

ParseVpnSiteLinkID parses 'input' into a VpnSiteLinkId

func ParseVpnSiteLinkIDInsensitively ¶ 

func ParseVpnSiteLinkIDInsensitively(input string) (*VpnSiteLinkId, error)

ParseVpnSiteLinkIDInsensitively parses 'input' case-insensitively into a VpnSiteLinkId note: this method should only be used for API response data and not user input

func (*VpnSiteLinkId) FromParseResult ¶ 

func (id *VpnSiteLinkId) FromParseResult(input resourceids.ParseResult) error

func (VpnSiteLinkId) ID ¶ 

func (id VpnSiteLinkId) ID() string

ID returns the formatted Vpn Site Link ID

func (VpnSiteLinkId) Segments ¶ 

func (id VpnSiteLinkId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Vpn Site Link ID

func (VpnSiteLinkId) String ¶ 

func (id VpnSiteLinkId) String() string

String returns a human-readable description of this Vpn Site Link ID

type VpnSiteLinkOperationPredicate ¶ 

type VpnSiteLinkOperationPredicate struct {
	Etag *string
	Id   *string
	Name *string
	Type *string
}

func (VpnSiteLinkOperationPredicate) Matches ¶ 

func (p VpnSiteLinkOperationPredicate) Matches(input VpnSiteLink) bool

type VpnSiteLinkProperties ¶ 

type VpnSiteLinkProperties struct {
	BgpProperties     *VpnLinkBgpSettings        `json:"bgpProperties,omitempty"`
	Fqdn              *string                    `json:"fqdn,omitempty"`
	IPAddress         *string                    `json:"ipAddress,omitempty"`
	LinkProperties    *VpnLinkProviderProperties `json:"linkProperties,omitempty"`
	ProvisioningState *ProvisioningState         `json:"provisioningState,omitempty"`
}

type VpnSiteLinksGetOperationResponse ¶ 

type VpnSiteLinksGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnSiteLink
}

type VpnSiteLinksListByVpnSiteCompleteResult ¶ 

type VpnSiteLinksListByVpnSiteCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnSiteLink
}

type VpnSiteLinksListByVpnSiteOperationResponse ¶ 

type VpnSiteLinksListByVpnSiteOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnSiteLink
}

type VpnSiteOperationPredicate ¶ 

type VpnSiteOperationPredicate struct {
	Etag     *string
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (VpnSiteOperationPredicate) Matches ¶ 

func (p VpnSiteOperationPredicate) Matches(input VpnSite) bool

type VpnSiteProperties ¶ 

type VpnSiteProperties struct {
	AddressSpace      *AddressSpace         `json:"addressSpace,omitempty"`
	BgpProperties     *BgpSettings          `json:"bgpProperties,omitempty"`
	DeviceProperties  *DeviceProperties     `json:"deviceProperties,omitempty"`
	IPAddress         *string               `json:"ipAddress,omitempty"`
	IsSecuritySite    *bool                 `json:"isSecuritySite,omitempty"`
	O365Policy        *O365PolicyProperties `json:"o365Policy,omitempty"`
	ProvisioningState *ProvisioningState    `json:"provisioningState,omitempty"`
	SiteKey           *string               `json:"siteKey,omitempty"`
	VirtualWAN        *SubResource          `json:"virtualWan,omitempty"`
	VpnSiteLinks      *[]VpnSiteLink        `json:"vpnSiteLinks,omitempty"`
}

type VpnSitesConfigurationDownloadOperationResponse ¶ 

type VpnSitesConfigurationDownloadOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VpnSitesCreateOrUpdateOperationResponse ¶ 

type VpnSitesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnSite
}

type VpnSitesDeleteOperationResponse ¶ 

type VpnSitesDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type VpnSitesGetOperationResponse ¶ 

type VpnSitesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VpnSite
}

type VpnSitesListByResourceGroupCompleteResult ¶ 

type VpnSitesListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnSite
}

type VpnSitesListByResourceGroupOperationResponse ¶ 

type VpnSitesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnSite
}

type VpnSitesListCompleteResult ¶ 

type VpnSitesListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VpnSite
}

type VpnSitesListOperationResponse ¶ 

type VpnSitesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VpnSite
}

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.