loadbalancers

package
v0.20230829.1225856 Latest Latest
Warning

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

 Go to latest Published: Aug 29, 2023 License: MPL-2.0 Imports: 14 Imported by: 0

README

github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-02-01/loadbalancers Documentation

The loadbalancers SDK allows for interaction with the Azure Resource Manager Service network (API Version 2023-02-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-sdk/resource-manager/network/2023-02-01/loadbalancers"

Client Initialization

client := loadbalancers.NewLoadBalancersClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: LoadBalancersClient.CreateOrUpdate

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

payload := loadbalancers.LoadBalancer{
	// ...
}


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

Example Usage: LoadBalancersClient.Delete

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

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

Example Usage: LoadBalancersClient.Get

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

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

Example Usage: LoadBalancersClient.InboundNatRulesCreateOrUpdate

ctx := context.TODO()
id := loadbalancers.NewInboundNatRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "inboundNatRuleValue")

payload := loadbalancers.InboundNatRule{
	// ...
}


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

Example Usage: LoadBalancersClient.InboundNatRulesDelete

ctx := context.TODO()
id := loadbalancers.NewInboundNatRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "inboundNatRuleValue")

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

Example Usage: LoadBalancersClient.InboundNatRulesGet

ctx := context.TODO()
id := loadbalancers.NewInboundNatRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "inboundNatRuleValue")

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

Example Usage: LoadBalancersClient.InboundNatRulesList

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

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

Example Usage: LoadBalancersClient.List

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

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

Example Usage: LoadBalancersClient.ListAll

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

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

Example Usage: LoadBalancersClient.ListInboundNatRulePortMappings

ctx := context.TODO()
id := loadbalancers.NewBackendAddressPoolID("12345678-1234-9876-4563-123456789012", "resourceGroupValue", "loadBalancerValue", "backendAddressPoolValue")

payload := loadbalancers.QueryInboundNatRulePortMappingRequest{
	// ...
}


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

Example Usage: LoadBalancersClient.LoadBalancerBackendAddressPoolsCreateOrUpdate

ctx := context.TODO()
id := loadbalancers.NewLoadBalancerBackendAddressPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "backendAddressPoolValue")

payload := loadbalancers.BackendAddressPool{
	// ...
}


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

Example Usage: LoadBalancersClient.LoadBalancerBackendAddressPoolsDelete

ctx := context.TODO()
id := loadbalancers.NewLoadBalancerBackendAddressPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "backendAddressPoolValue")

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

Example Usage: LoadBalancersClient.LoadBalancerBackendAddressPoolsGet

ctx := context.TODO()
id := loadbalancers.NewLoadBalancerBackendAddressPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "backendAddressPoolValue")

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

Example Usage: LoadBalancersClient.LoadBalancerBackendAddressPoolsList

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

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

Example Usage: LoadBalancersClient.LoadBalancerFrontendIPConfigurationsGet

ctx := context.TODO()
id := loadbalancers.NewFrontendIPConfigurationID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "frontendIPConfigurationValue")

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

Example Usage: LoadBalancersClient.LoadBalancerFrontendIPConfigurationsList

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

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

Example Usage: LoadBalancersClient.LoadBalancerLoadBalancingRulesGet

ctx := context.TODO()
id := loadbalancers.NewLoadBalancingRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "loadBalancingRuleValue")

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

Example Usage: LoadBalancersClient.LoadBalancerLoadBalancingRulesList

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

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

Example Usage: LoadBalancersClient.LoadBalancerNetworkInterfacesList

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

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

Example Usage: LoadBalancersClient.LoadBalancerOutboundRulesGet

ctx := context.TODO()
id := loadbalancers.NewOutboundRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "outboundRuleValue")

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

Example Usage: LoadBalancersClient.LoadBalancerOutboundRulesList

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

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

Example Usage: LoadBalancersClient.LoadBalancerProbesGet

ctx := context.TODO()
id := loadbalancers.NewProbeID("12345678-1234-9876-4563-123456789012", "example-resource-group", "loadBalancerValue", "probeValue")

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

Example Usage: LoadBalancersClient.LoadBalancerProbesList

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

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

Example Usage: LoadBalancersClient.SwapPublicIPAddresses

ctx := context.TODO()
id := loadbalancers.NewLocationID("12345678-1234-9876-4563-123456789012", "locationValue")

payload := loadbalancers.LoadBalancerVipSwapRequest{
	// ...
}


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

Example Usage: LoadBalancersClient.UpdateTags

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

payload := loadbalancers.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
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForDdosSettingsProtectionMode 

func PossibleValuesForDdosSettingsProtectionMode() []string

func PossibleValuesForDeleteOptions 

func PossibleValuesForDeleteOptions() []string

func PossibleValuesForFlowLogFormatType 

func PossibleValuesForFlowLogFormatType() []string

func PossibleValuesForGatewayLoadBalancerTunnelInterfaceType 

func PossibleValuesForGatewayLoadBalancerTunnelInterfaceType() []string

func PossibleValuesForGatewayLoadBalancerTunnelProtocol 

func PossibleValuesForGatewayLoadBalancerTunnelProtocol() []string

func PossibleValuesForIPAllocationMethod 

func PossibleValuesForIPAllocationMethod() []string

func PossibleValuesForIPVersion 

func PossibleValuesForIPVersion() []string

func PossibleValuesForLoadBalancerBackendAddressAdminState 

func PossibleValuesForLoadBalancerBackendAddressAdminState() []string

func PossibleValuesForLoadBalancerOutboundRuleProtocol 

func PossibleValuesForLoadBalancerOutboundRuleProtocol() []string

func PossibleValuesForLoadBalancerSkuName 

func PossibleValuesForLoadBalancerSkuName() []string

func PossibleValuesForLoadBalancerSkuTier 

func PossibleValuesForLoadBalancerSkuTier() []string

func PossibleValuesForLoadDistribution 

func PossibleValuesForLoadDistribution() []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 PossibleValuesForProbeProtocol 

func PossibleValuesForProbeProtocol() []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 PossibleValuesForRouteNextHopType 

func PossibleValuesForRouteNextHopType() []string

func PossibleValuesForSecurityRuleAccess 

func PossibleValuesForSecurityRuleAccess() []string

func PossibleValuesForSecurityRuleDirection 

func PossibleValuesForSecurityRuleDirection() []string

func PossibleValuesForSecurityRuleProtocol 

func PossibleValuesForSecurityRuleProtocol() []string

func PossibleValuesForTransportProtocol 

func PossibleValuesForTransportProtocol() []string

func PossibleValuesForVirtualNetworkPrivateEndpointNetworkPolicies 

func PossibleValuesForVirtualNetworkPrivateEndpointNetworkPolicies() []string

func PossibleValuesForVirtualNetworkPrivateLinkServiceNetworkPolicies 

func PossibleValuesForVirtualNetworkPrivateLinkServiceNetworkPolicies() []string

func ValidateBackendAddressPoolID 

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

ValidateBackendAddressPoolID checks that 'input' can be parsed as a Backend Address Pool ID

func ValidateFrontendIPConfigurationID 

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

ValidateFrontendIPConfigurationID checks that 'input' can be parsed as a Frontend I P Configuration ID

func ValidateInboundNatRuleID 

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

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

func ValidateLoadBalancerBackendAddressPoolID 

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

ValidateLoadBalancerBackendAddressPoolID checks that 'input' can be parsed as a Load Balancer Backend Address Pool ID

func ValidateLoadBalancerID 

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

ValidateLoadBalancerID checks that 'input' can be parsed as a Load Balancer ID

func ValidateLoadBalancingRuleID 

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

ValidateLoadBalancingRuleID checks that 'input' can be parsed as a Load Balancing Rule ID

func ValidateLocationID 

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

ValidateLocationID checks that 'input' can be parsed as a Location ID

func ValidateOutboundRuleID 

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

ValidateOutboundRuleID checks that 'input' can be parsed as a Outbound Rule ID

func ValidateProbeID 

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

ValidateProbeID checks that 'input' can be parsed as a Probe ID

Types

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 BackendAddressInboundNatRulePortMappings 

type BackendAddressInboundNatRulePortMappings struct {
	InboundNatRulePortMappings *[]InboundNatRulePortMapping `json:"inboundNatRulePortMappings,omitempty"`
}

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 BackendAddressPoolId 

type BackendAddressPoolId struct {
	SubscriptionId         string
	ResourceGroupName      string
	LoadBalancerName       string
	BackendAddressPoolName string
}

BackendAddressPoolId is a struct representing the Resource ID for a Backend Address Pool

func NewBackendAddressPoolID 

func NewBackendAddressPoolID(subscriptionId string, resourceGroupName string, loadBalancerName string, backendAddressPoolName string) BackendAddressPoolId

NewBackendAddressPoolID returns a new BackendAddressPoolId struct

func ParseBackendAddressPoolID 

func ParseBackendAddressPoolID(input string) (*BackendAddressPoolId, error)

ParseBackendAddressPoolID parses 'input' into a BackendAddressPoolId

func ParseBackendAddressPoolIDInsensitively 

func ParseBackendAddressPoolIDInsensitively(input string) (*BackendAddressPoolId, error)

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

func (BackendAddressPoolId) ID 

func (id BackendAddressPoolId) ID() string

ID returns the formatted Backend Address Pool ID

func (BackendAddressPoolId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Backend Address Pool ID

func (BackendAddressPoolId) String 

func (id BackendAddressPoolId) String() string

String returns a human-readable description of this Backend Address Pool ID

type BackendAddressPoolOperationPredicate 

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

func (BackendAddressPoolOperationPredicate) Matches 

func (p BackendAddressPoolOperationPredicate) Matches(input BackendAddressPool) bool

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"`
	TunnelInterfaces             *[]GatewayLoadBalancerTunnelInterface `json:"tunnelInterfaces,omitempty"`
	VirtualNetwork               *SubResource                          `json:"virtualNetwork,omitempty"`
}

type CreateOrUpdateOperationResponse 

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

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 DeleteOperationResponse 

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

type DeleteOptions 

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

func (*DeleteOptions) UnmarshalJSON 

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

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 FrontendIPConfigurationId 

type FrontendIPConfigurationId struct {
	SubscriptionId              string
	ResourceGroupName           string
	LoadBalancerName            string
	FrontendIPConfigurationName string
}

FrontendIPConfigurationId is a struct representing the Resource ID for a Frontend I P Configuration

func NewFrontendIPConfigurationID 

func NewFrontendIPConfigurationID(subscriptionId string, resourceGroupName string, loadBalancerName string, frontendIPConfigurationName string) FrontendIPConfigurationId

NewFrontendIPConfigurationID returns a new FrontendIPConfigurationId struct

func ParseFrontendIPConfigurationID 

func ParseFrontendIPConfigurationID(input string) (*FrontendIPConfigurationId, error)

ParseFrontendIPConfigurationID parses 'input' into a FrontendIPConfigurationId

func ParseFrontendIPConfigurationIDInsensitively 

func ParseFrontendIPConfigurationIDInsensitively(input string) (*FrontendIPConfigurationId, error)

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

func (FrontendIPConfigurationId) ID 

func (id FrontendIPConfigurationId) ID() string

ID returns the formatted Frontend I P Configuration ID

func (FrontendIPConfigurationId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Frontend I P Configuration ID

func (FrontendIPConfigurationId) String 

func (id FrontendIPConfigurationId) String() string

String returns a human-readable description of this Frontend I P Configuration ID

type FrontendIPConfigurationOperationPredicate 

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

func (FrontendIPConfigurationOperationPredicate) Matches 

func (p FrontendIPConfigurationOperationPredicate) Matches(input FrontendIPConfiguration) bool

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 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 GetOperationOptions 

type GetOperationOptions struct {
	Expand *string
}

func DefaultGetOperationOptions 

func DefaultGetOperationOptions() GetOperationOptions

func (GetOperationOptions) ToHeaders 

func (o GetOperationOptions) ToHeaders() *client.Headers

func (GetOperationOptions) ToOData 

func (o GetOperationOptions) ToOData() *odata.Query

func (GetOperationOptions) ToQuery 

func (o GetOperationOptions) ToQuery() *client.QueryParams

type GetOperationResponse 

type GetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *LoadBalancer
}

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 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 InboundNatPool 

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

type InboundNatPoolPropertiesFormat 

type InboundNatPoolPropertiesFormat struct {
	BackendPort             int64              `json:"backendPort"`
	EnableFloatingIP        *bool              `json:"enableFloatingIP,omitempty"`
	EnableTcpReset          *bool              `json:"enableTcpReset,omitempty"`
	FrontendIPConfiguration *SubResource       `json:"frontendIPConfiguration,omitempty"`
	FrontendPortRangeEnd    int64              `json:"frontendPortRangeEnd"`
	FrontendPortRangeStart  int64              `json:"frontendPortRangeStart"`
	IdleTimeoutInMinutes    *int64             `json:"idleTimeoutInMinutes,omitempty"`
	Protocol                TransportProtocol  `json:"protocol"`
	ProvisioningState       *ProvisioningState `json:"provisioningState,omitempty"`
}

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 InboundNatRuleId 

type InboundNatRuleId struct {
	SubscriptionId     string
	ResourceGroupName  string
	LoadBalancerName   string
	InboundNatRuleName string
}

InboundNatRuleId is a struct representing the Resource ID for a Inbound Nat Rule

func NewInboundNatRuleID 

func NewInboundNatRuleID(subscriptionId string, resourceGroupName string, loadBalancerName string, inboundNatRuleName string) InboundNatRuleId

NewInboundNatRuleID returns a new InboundNatRuleId struct

func ParseInboundNatRuleID 

func ParseInboundNatRuleID(input string) (*InboundNatRuleId, error)

ParseInboundNatRuleID parses 'input' into a InboundNatRuleId

func ParseInboundNatRuleIDInsensitively 

func ParseInboundNatRuleIDInsensitively(input string) (*InboundNatRuleId, error)

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

func (InboundNatRuleId) ID 

func (id InboundNatRuleId) ID() string

ID returns the formatted Inbound Nat Rule ID

func (InboundNatRuleId) Segments 

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

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

func (InboundNatRuleId) String 

func (id InboundNatRuleId) String() string

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

type InboundNatRuleOperationPredicate 

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

func (InboundNatRuleOperationPredicate) Matches 

func (p InboundNatRuleOperationPredicate) Matches(input InboundNatRule) bool

type InboundNatRulePortMapping 

type InboundNatRulePortMapping struct {
	BackendPort        *int64             `json:"backendPort,omitempty"`
	FrontendPort       *int64             `json:"frontendPort,omitempty"`
	InboundNatRuleName *string            `json:"inboundNatRuleName,omitempty"`
	Protocol           *TransportProtocol `json:"protocol,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 InboundNatRulesCreateOrUpdateOperationResponse 

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

type InboundNatRulesDeleteOperationResponse 

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

type InboundNatRulesGetOperationOptions 

type InboundNatRulesGetOperationOptions struct {
	Expand *string
}

func DefaultInboundNatRulesGetOperationOptions 

func DefaultInboundNatRulesGetOperationOptions() InboundNatRulesGetOperationOptions

func (InboundNatRulesGetOperationOptions) ToHeaders 

func (o InboundNatRulesGetOperationOptions) ToHeaders() *client.Headers

func (InboundNatRulesGetOperationOptions) ToOData 

func (o InboundNatRulesGetOperationOptions) ToOData() *odata.Query

func (InboundNatRulesGetOperationOptions) ToQuery 

func (o InboundNatRulesGetOperationOptions) ToQuery() *client.QueryParams

type InboundNatRulesGetOperationResponse 

type InboundNatRulesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *InboundNatRule
}

type InboundNatRulesListCompleteResult 

type InboundNatRulesListCompleteResult struct {
	Items []InboundNatRule
}

type InboundNatRulesListOperationResponse 

type InboundNatRulesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]InboundNatRule
}

type ListAllCompleteResult 

type ListAllCompleteResult struct {
	Items []LoadBalancer
}

type ListAllOperationResponse 

type ListAllOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]LoadBalancer
}

type ListCompleteResult 

type ListCompleteResult struct {
	Items []LoadBalancer
}

type ListInboundNatRulePortMappingsOperationResponse 

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

type ListOperationResponse 

type ListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]LoadBalancer
}

type LoadBalancer 

type LoadBalancer 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       *LoadBalancerPropertiesFormat `json:"properties,omitempty"`
	Sku              *LoadBalancerSku              `json:"sku,omitempty"`
	Tags             *map[string]string            `json:"tags,omitempty"`
	Type             *string                       `json:"type,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 LoadBalancerBackendAddressPoolId 

type LoadBalancerBackendAddressPoolId struct {
	SubscriptionId         string
	ResourceGroupName      string
	LoadBalancerName       string
	BackendAddressPoolName string
}

LoadBalancerBackendAddressPoolId is a struct representing the Resource ID for a Load Balancer Backend Address Pool

func NewLoadBalancerBackendAddressPoolID 

func NewLoadBalancerBackendAddressPoolID(subscriptionId string, resourceGroupName string, loadBalancerName string, backendAddressPoolName string) LoadBalancerBackendAddressPoolId

NewLoadBalancerBackendAddressPoolID returns a new LoadBalancerBackendAddressPoolId struct

func ParseLoadBalancerBackendAddressPoolID 

func ParseLoadBalancerBackendAddressPoolID(input string) (*LoadBalancerBackendAddressPoolId, error)

ParseLoadBalancerBackendAddressPoolID parses 'input' into a LoadBalancerBackendAddressPoolId

func ParseLoadBalancerBackendAddressPoolIDInsensitively 

func ParseLoadBalancerBackendAddressPoolIDInsensitively(input string) (*LoadBalancerBackendAddressPoolId, error)

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

func (LoadBalancerBackendAddressPoolId) ID 

func (id LoadBalancerBackendAddressPoolId) ID() string

ID returns the formatted Load Balancer Backend Address Pool ID

func (LoadBalancerBackendAddressPoolId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Load Balancer Backend Address Pool ID

func (LoadBalancerBackendAddressPoolId) String 

func (id LoadBalancerBackendAddressPoolId) String() string

String returns a human-readable description of this Load Balancer Backend Address Pool ID

type LoadBalancerBackendAddressPoolsCreateOrUpdateOperationResponse 

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

type LoadBalancerBackendAddressPoolsDeleteOperationResponse 

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

type LoadBalancerBackendAddressPoolsGetOperationResponse 

type LoadBalancerBackendAddressPoolsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BackendAddressPool
}

type LoadBalancerBackendAddressPoolsListCompleteResult 

type LoadBalancerBackendAddressPoolsListCompleteResult struct {
	Items []BackendAddressPool
}

type LoadBalancerBackendAddressPoolsListOperationResponse 

type LoadBalancerBackendAddressPoolsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]BackendAddressPool
}

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 LoadBalancerFrontendIPConfigurationsGetOperationResponse 

type LoadBalancerFrontendIPConfigurationsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *FrontendIPConfiguration
}

type LoadBalancerFrontendIPConfigurationsListCompleteResult 

type LoadBalancerFrontendIPConfigurationsListCompleteResult struct {
	Items []FrontendIPConfiguration
}

type LoadBalancerFrontendIPConfigurationsListOperationResponse 

type LoadBalancerFrontendIPConfigurationsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]FrontendIPConfiguration
}

type LoadBalancerId 

type LoadBalancerId struct {
	SubscriptionId    string
	ResourceGroupName string
	LoadBalancerName  string
}

LoadBalancerId is a struct representing the Resource ID for a Load Balancer

func NewLoadBalancerID 

func NewLoadBalancerID(subscriptionId string, resourceGroupName string, loadBalancerName string) LoadBalancerId

NewLoadBalancerID returns a new LoadBalancerId struct

func ParseLoadBalancerID 

func ParseLoadBalancerID(input string) (*LoadBalancerId, error)

ParseLoadBalancerID parses 'input' into a LoadBalancerId

func ParseLoadBalancerIDInsensitively 

func ParseLoadBalancerIDInsensitively(input string) (*LoadBalancerId, error)

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

func (LoadBalancerId) ID 

func (id LoadBalancerId) ID() string

ID returns the formatted Load Balancer ID

func (LoadBalancerId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Load Balancer ID

func (LoadBalancerId) String 

func (id LoadBalancerId) String() string

String returns a human-readable description of this Load Balancer ID

type LoadBalancerLoadBalancingRulesGetOperationResponse 

type LoadBalancerLoadBalancingRulesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *LoadBalancingRule
}

type LoadBalancerLoadBalancingRulesListCompleteResult 

type LoadBalancerLoadBalancingRulesListCompleteResult struct {
	Items []LoadBalancingRule
}

type LoadBalancerLoadBalancingRulesListOperationResponse 

type LoadBalancerLoadBalancingRulesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]LoadBalancingRule
}

type LoadBalancerNetworkInterfacesListCompleteResult 

type LoadBalancerNetworkInterfacesListCompleteResult struct {
	Items []NetworkInterface
}

type LoadBalancerNetworkInterfacesListOperationResponse 

type LoadBalancerNetworkInterfacesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]NetworkInterface
}

type LoadBalancerOperationPredicate 

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

func (LoadBalancerOperationPredicate) Matches 

func (p LoadBalancerOperationPredicate) Matches(input LoadBalancer) bool

type LoadBalancerOutboundRuleProtocol 

type LoadBalancerOutboundRuleProtocol string
const (
	LoadBalancerOutboundRuleProtocolAll LoadBalancerOutboundRuleProtocol = "All"
	LoadBalancerOutboundRuleProtocolTcp LoadBalancerOutboundRuleProtocol = "Tcp"
	LoadBalancerOutboundRuleProtocolUdp LoadBalancerOutboundRuleProtocol = "Udp"
)

func (*LoadBalancerOutboundRuleProtocol) UnmarshalJSON 

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

type LoadBalancerOutboundRulesGetOperationResponse 

type LoadBalancerOutboundRulesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *OutboundRule
}

type LoadBalancerOutboundRulesListCompleteResult 

type LoadBalancerOutboundRulesListCompleteResult struct {
	Items []OutboundRule
}

type LoadBalancerOutboundRulesListOperationResponse 

type LoadBalancerOutboundRulesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]OutboundRule
}

type LoadBalancerProbesGetOperationResponse 

type LoadBalancerProbesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Probe
}

type LoadBalancerProbesListCompleteResult 

type LoadBalancerProbesListCompleteResult struct {
	Items []Probe
}

type LoadBalancerProbesListOperationResponse 

type LoadBalancerProbesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Probe
}

type LoadBalancerPropertiesFormat 

type LoadBalancerPropertiesFormat struct {
	BackendAddressPools      *[]BackendAddressPool      `json:"backendAddressPools,omitempty"`
	FrontendIPConfigurations *[]FrontendIPConfiguration `json:"frontendIPConfigurations,omitempty"`
	InboundNatPools          *[]InboundNatPool          `json:"inboundNatPools,omitempty"`
	InboundNatRules          *[]InboundNatRule          `json:"inboundNatRules,omitempty"`
	LoadBalancingRules       *[]LoadBalancingRule       `json:"loadBalancingRules,omitempty"`
	OutboundRules            *[]OutboundRule            `json:"outboundRules,omitempty"`
	Probes                   *[]Probe                   `json:"probes,omitempty"`
	ProvisioningState        *ProvisioningState         `json:"provisioningState,omitempty"`
	ResourceGuid             *string                    `json:"resourceGuid,omitempty"`
}

type LoadBalancerSku 

type LoadBalancerSku struct {
	Name *LoadBalancerSkuName `json:"name,omitempty"`
	Tier *LoadBalancerSkuTier `json:"tier,omitempty"`
}

type LoadBalancerSkuName 

type LoadBalancerSkuName string
const (
	LoadBalancerSkuNameBasic    LoadBalancerSkuName = "Basic"
	LoadBalancerSkuNameGateway  LoadBalancerSkuName = "Gateway"
	LoadBalancerSkuNameStandard LoadBalancerSkuName = "Standard"
)

func (*LoadBalancerSkuName) UnmarshalJSON 

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

type LoadBalancerSkuTier 

type LoadBalancerSkuTier string
const (
	LoadBalancerSkuTierGlobal   LoadBalancerSkuTier = "Global"
	LoadBalancerSkuTierRegional LoadBalancerSkuTier = "Regional"
)

func (*LoadBalancerSkuTier) UnmarshalJSON 

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

type LoadBalancerVipSwapRequest 

type LoadBalancerVipSwapRequest struct {
	FrontendIPConfigurations *[]LoadBalancerVipSwapRequestFrontendIPConfiguration `json:"frontendIPConfigurations,omitempty"`
}

type LoadBalancerVipSwapRequestFrontendIPConfiguration 

type LoadBalancerVipSwapRequestFrontendIPConfiguration struct {
	Id         *string                                                      `json:"id,omitempty"`
	Properties *LoadBalancerVipSwapRequestFrontendIPConfigurationProperties `json:"properties,omitempty"`
}

type LoadBalancerVipSwapRequestFrontendIPConfigurationProperties 

type LoadBalancerVipSwapRequestFrontendIPConfigurationProperties struct {
	PublicIPAddress *SubResource `json:"publicIPAddress,omitempty"`
}

type LoadBalancersClient 

type LoadBalancersClient struct {
	Client *resourcemanager.Client
}

func NewLoadBalancersClientWithBaseURI 

func NewLoadBalancersClientWithBaseURI(sdkApi sdkEnv.Api) (*LoadBalancersClient, error)

func (LoadBalancersClient) CreateOrUpdate 

func (c LoadBalancersClient) CreateOrUpdate(ctx context.Context, id LoadBalancerId, input LoadBalancer) (result CreateOrUpdateOperationResponse, err error)

CreateOrUpdate ...

func (LoadBalancersClient) CreateOrUpdateThenPoll 

func (c LoadBalancersClient) CreateOrUpdateThenPoll(ctx context.Context, id LoadBalancerId, input LoadBalancer) error

CreateOrUpdateThenPoll performs CreateOrUpdate then polls until it's completed

func (LoadBalancersClient) Delete 

func (c LoadBalancersClient) Delete(ctx context.Context, id LoadBalancerId) (result DeleteOperationResponse, err error)

Delete ...

func (LoadBalancersClient) DeleteThenPoll 

func (c LoadBalancersClient) DeleteThenPoll(ctx context.Context, id LoadBalancerId) error

DeleteThenPoll performs Delete then polls until it's completed

func (LoadBalancersClient) Get 

func (c LoadBalancersClient) Get(ctx context.Context, id LoadBalancerId, options GetOperationOptions) (result GetOperationResponse, err error)

Get ...

func (LoadBalancersClient) InboundNatRulesCreateOrUpdate 

func (c LoadBalancersClient) InboundNatRulesCreateOrUpdate(ctx context.Context, id InboundNatRuleId, input InboundNatRule) (result InboundNatRulesCreateOrUpdateOperationResponse, err error)

InboundNatRulesCreateOrUpdate ...

func (LoadBalancersClient) InboundNatRulesCreateOrUpdateThenPoll 

func (c LoadBalancersClient) InboundNatRulesCreateOrUpdateThenPoll(ctx context.Context, id InboundNatRuleId, input InboundNatRule) error

InboundNatRulesCreateOrUpdateThenPoll performs InboundNatRulesCreateOrUpdate then polls until it's completed

func (LoadBalancersClient) InboundNatRulesDelete 

func (c LoadBalancersClient) InboundNatRulesDelete(ctx context.Context, id InboundNatRuleId) (result InboundNatRulesDeleteOperationResponse, err error)

InboundNatRulesDelete ...

func (LoadBalancersClient) InboundNatRulesDeleteThenPoll 

func (c LoadBalancersClient) InboundNatRulesDeleteThenPoll(ctx context.Context, id InboundNatRuleId) error

InboundNatRulesDeleteThenPoll performs InboundNatRulesDelete then polls until it's completed

func (LoadBalancersClient) InboundNatRulesGet 

func (c LoadBalancersClient) InboundNatRulesGet(ctx context.Context, id InboundNatRuleId, options InboundNatRulesGetOperationOptions) (result InboundNatRulesGetOperationResponse, err error)

InboundNatRulesGet ...

func (LoadBalancersClient) InboundNatRulesList 

func (c LoadBalancersClient) InboundNatRulesList(ctx context.Context, id LoadBalancerId) (result InboundNatRulesListOperationResponse, err error)

InboundNatRulesList ...

func (LoadBalancersClient) InboundNatRulesListComplete 

func (c LoadBalancersClient) InboundNatRulesListComplete(ctx context.Context, id LoadBalancerId) (InboundNatRulesListCompleteResult, error)

InboundNatRulesListComplete retrieves all the results into a single object

func (LoadBalancersClient) InboundNatRulesListCompleteMatchingPredicate 

func (c LoadBalancersClient) InboundNatRulesListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate InboundNatRuleOperationPredicate) (result InboundNatRulesListCompleteResult, err error)

InboundNatRulesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) List 

func (c LoadBalancersClient) List(ctx context.Context, id commonids.ResourceGroupId) (result ListOperationResponse, err error)

List ...

func (LoadBalancersClient) ListAll 

func (c LoadBalancersClient) ListAll(ctx context.Context, id commonids.SubscriptionId) (result ListAllOperationResponse, err error)

ListAll ...

func (LoadBalancersClient) ListAllComplete 

func (c LoadBalancersClient) ListAllComplete(ctx context.Context, id commonids.SubscriptionId) (ListAllCompleteResult, error)

ListAllComplete retrieves all the results into a single object

func (LoadBalancersClient) ListAllCompleteMatchingPredicate 

func (c LoadBalancersClient) ListAllCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate LoadBalancerOperationPredicate) (result ListAllCompleteResult, err error)

ListAllCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) ListComplete 

func (c LoadBalancersClient) ListComplete(ctx context.Context, id commonids.ResourceGroupId) (ListCompleteResult, error)

ListComplete retrieves all the results into a single object

func (LoadBalancersClient) ListCompleteMatchingPredicate 

func (c LoadBalancersClient) ListCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate LoadBalancerOperationPredicate) (result ListCompleteResult, err error)

ListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) ListInboundNatRulePortMappings 

func (c LoadBalancersClient) ListInboundNatRulePortMappings(ctx context.Context, id BackendAddressPoolId, input QueryInboundNatRulePortMappingRequest) (result ListInboundNatRulePortMappingsOperationResponse, err error)

ListInboundNatRulePortMappings ...

func (LoadBalancersClient) ListInboundNatRulePortMappingsThenPoll 

func (c LoadBalancersClient) ListInboundNatRulePortMappingsThenPoll(ctx context.Context, id BackendAddressPoolId, input QueryInboundNatRulePortMappingRequest) error

ListInboundNatRulePortMappingsThenPoll performs ListInboundNatRulePortMappings then polls until it's completed

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsCreateOrUpdate 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsCreateOrUpdate(ctx context.Context, id LoadBalancerBackendAddressPoolId, input BackendAddressPool) (result LoadBalancerBackendAddressPoolsCreateOrUpdateOperationResponse, err error)

LoadBalancerBackendAddressPoolsCreateOrUpdate ...

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx context.Context, id LoadBalancerBackendAddressPoolId, input BackendAddressPool) error

LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll performs LoadBalancerBackendAddressPoolsCreateOrUpdate then polls until it's completed

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsDelete 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsDelete(ctx context.Context, id LoadBalancerBackendAddressPoolId) (result LoadBalancerBackendAddressPoolsDeleteOperationResponse, err error)

LoadBalancerBackendAddressPoolsDelete ...

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsDeleteThenPoll 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsDeleteThenPoll(ctx context.Context, id LoadBalancerBackendAddressPoolId) error

LoadBalancerBackendAddressPoolsDeleteThenPoll performs LoadBalancerBackendAddressPoolsDelete then polls until it's completed

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsGet 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsGet(ctx context.Context, id LoadBalancerBackendAddressPoolId) (result LoadBalancerBackendAddressPoolsGetOperationResponse, err error)

LoadBalancerBackendAddressPoolsGet ...

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsList 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsList(ctx context.Context, id LoadBalancerId) (result LoadBalancerBackendAddressPoolsListOperationResponse, err error)

LoadBalancerBackendAddressPoolsList ...

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsListComplete 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsListComplete(ctx context.Context, id LoadBalancerId) (LoadBalancerBackendAddressPoolsListCompleteResult, error)

LoadBalancerBackendAddressPoolsListComplete retrieves all the results into a single object

func (LoadBalancersClient) LoadBalancerBackendAddressPoolsListCompleteMatchingPredicate 

func (c LoadBalancersClient) LoadBalancerBackendAddressPoolsListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate BackendAddressPoolOperationPredicate) (result LoadBalancerBackendAddressPoolsListCompleteResult, err error)

LoadBalancerBackendAddressPoolsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) LoadBalancerFrontendIPConfigurationsGet 

func (c LoadBalancersClient) LoadBalancerFrontendIPConfigurationsGet(ctx context.Context, id FrontendIPConfigurationId) (result LoadBalancerFrontendIPConfigurationsGetOperationResponse, err error)

LoadBalancerFrontendIPConfigurationsGet ...

func (LoadBalancersClient) LoadBalancerFrontendIPConfigurationsList 

func (c LoadBalancersClient) LoadBalancerFrontendIPConfigurationsList(ctx context.Context, id LoadBalancerId) (result LoadBalancerFrontendIPConfigurationsListOperationResponse, err error)

LoadBalancerFrontendIPConfigurationsList ...

func (LoadBalancersClient) LoadBalancerFrontendIPConfigurationsListComplete 

func (c LoadBalancersClient) LoadBalancerFrontendIPConfigurationsListComplete(ctx context.Context, id LoadBalancerId) (LoadBalancerFrontendIPConfigurationsListCompleteResult, error)

LoadBalancerFrontendIPConfigurationsListComplete retrieves all the results into a single object

func (LoadBalancersClient) LoadBalancerFrontendIPConfigurationsListCompleteMatchingPredicate 

func (c LoadBalancersClient) LoadBalancerFrontendIPConfigurationsListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate FrontendIPConfigurationOperationPredicate) (result LoadBalancerFrontendIPConfigurationsListCompleteResult, err error)

LoadBalancerFrontendIPConfigurationsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) LoadBalancerLoadBalancingRulesGet 

func (c LoadBalancersClient) LoadBalancerLoadBalancingRulesGet(ctx context.Context, id LoadBalancingRuleId) (result LoadBalancerLoadBalancingRulesGetOperationResponse, err error)

LoadBalancerLoadBalancingRulesGet ...

func (LoadBalancersClient) LoadBalancerLoadBalancingRulesList 

func (c LoadBalancersClient) LoadBalancerLoadBalancingRulesList(ctx context.Context, id LoadBalancerId) (result LoadBalancerLoadBalancingRulesListOperationResponse, err error)

LoadBalancerLoadBalancingRulesList ...

func (LoadBalancersClient) LoadBalancerLoadBalancingRulesListComplete 

func (c LoadBalancersClient) LoadBalancerLoadBalancingRulesListComplete(ctx context.Context, id LoadBalancerId) (LoadBalancerLoadBalancingRulesListCompleteResult, error)

LoadBalancerLoadBalancingRulesListComplete retrieves all the results into a single object

func (LoadBalancersClient) LoadBalancerLoadBalancingRulesListCompleteMatchingPredicate 

func (c LoadBalancersClient) LoadBalancerLoadBalancingRulesListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate LoadBalancingRuleOperationPredicate) (result LoadBalancerLoadBalancingRulesListCompleteResult, err error)

LoadBalancerLoadBalancingRulesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) LoadBalancerNetworkInterfacesList 

func (c LoadBalancersClient) LoadBalancerNetworkInterfacesList(ctx context.Context, id LoadBalancerId) (result LoadBalancerNetworkInterfacesListOperationResponse, err error)

LoadBalancerNetworkInterfacesList ...

func (LoadBalancersClient) LoadBalancerNetworkInterfacesListComplete 

func (c LoadBalancersClient) LoadBalancerNetworkInterfacesListComplete(ctx context.Context, id LoadBalancerId) (LoadBalancerNetworkInterfacesListCompleteResult, error)

LoadBalancerNetworkInterfacesListComplete retrieves all the results into a single object

func (LoadBalancersClient) LoadBalancerNetworkInterfacesListCompleteMatchingPredicate 

func (c LoadBalancersClient) LoadBalancerNetworkInterfacesListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate NetworkInterfaceOperationPredicate) (result LoadBalancerNetworkInterfacesListCompleteResult, err error)

LoadBalancerNetworkInterfacesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) LoadBalancerOutboundRulesGet 

func (c LoadBalancersClient) LoadBalancerOutboundRulesGet(ctx context.Context, id OutboundRuleId) (result LoadBalancerOutboundRulesGetOperationResponse, err error)

LoadBalancerOutboundRulesGet ...

func (LoadBalancersClient) LoadBalancerOutboundRulesList 

func (c LoadBalancersClient) LoadBalancerOutboundRulesList(ctx context.Context, id LoadBalancerId) (result LoadBalancerOutboundRulesListOperationResponse, err error)

LoadBalancerOutboundRulesList ...

func (LoadBalancersClient) LoadBalancerOutboundRulesListComplete 

func (c LoadBalancersClient) LoadBalancerOutboundRulesListComplete(ctx context.Context, id LoadBalancerId) (LoadBalancerOutboundRulesListCompleteResult, error)

LoadBalancerOutboundRulesListComplete retrieves all the results into a single object

func (LoadBalancersClient) LoadBalancerOutboundRulesListCompleteMatchingPredicate 

func (c LoadBalancersClient) LoadBalancerOutboundRulesListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate OutboundRuleOperationPredicate) (result LoadBalancerOutboundRulesListCompleteResult, err error)

LoadBalancerOutboundRulesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) LoadBalancerProbesGet 

func (c LoadBalancersClient) LoadBalancerProbesGet(ctx context.Context, id ProbeId) (result LoadBalancerProbesGetOperationResponse, err error)

LoadBalancerProbesGet ...

func (LoadBalancersClient) LoadBalancerProbesList 

func (c LoadBalancersClient) LoadBalancerProbesList(ctx context.Context, id LoadBalancerId) (result LoadBalancerProbesListOperationResponse, err error)

LoadBalancerProbesList ...

func (LoadBalancersClient) LoadBalancerProbesListComplete 

func (c LoadBalancersClient) LoadBalancerProbesListComplete(ctx context.Context, id LoadBalancerId) (LoadBalancerProbesListCompleteResult, error)

LoadBalancerProbesListComplete retrieves all the results into a single object

func (LoadBalancersClient) LoadBalancerProbesListCompleteMatchingPredicate 

func (c LoadBalancersClient) LoadBalancerProbesListCompleteMatchingPredicate(ctx context.Context, id LoadBalancerId, predicate ProbeOperationPredicate) (result LoadBalancerProbesListCompleteResult, err error)

LoadBalancerProbesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (LoadBalancersClient) SwapPublicIPAddresses 

func (c LoadBalancersClient) SwapPublicIPAddresses(ctx context.Context, id LocationId, input LoadBalancerVipSwapRequest) (result SwapPublicIPAddressesOperationResponse, err error)

SwapPublicIPAddresses ...

func (LoadBalancersClient) SwapPublicIPAddressesThenPoll 

func (c LoadBalancersClient) SwapPublicIPAddressesThenPoll(ctx context.Context, id LocationId, input LoadBalancerVipSwapRequest) error

SwapPublicIPAddressesThenPoll performs SwapPublicIPAddresses then polls until it's completed

func (LoadBalancersClient) UpdateTags 

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

UpdateTags ...

type LoadBalancingRule 

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

type LoadBalancingRuleId 

type LoadBalancingRuleId struct {
	SubscriptionId        string
	ResourceGroupName     string
	LoadBalancerName      string
	LoadBalancingRuleName string
}

LoadBalancingRuleId is a struct representing the Resource ID for a Load Balancing Rule

func NewLoadBalancingRuleID 

func NewLoadBalancingRuleID(subscriptionId string, resourceGroupName string, loadBalancerName string, loadBalancingRuleName string) LoadBalancingRuleId

NewLoadBalancingRuleID returns a new LoadBalancingRuleId struct

func ParseLoadBalancingRuleID 

func ParseLoadBalancingRuleID(input string) (*LoadBalancingRuleId, error)

ParseLoadBalancingRuleID parses 'input' into a LoadBalancingRuleId

func ParseLoadBalancingRuleIDInsensitively 

func ParseLoadBalancingRuleIDInsensitively(input string) (*LoadBalancingRuleId, error)

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

func (LoadBalancingRuleId) ID 

func (id LoadBalancingRuleId) ID() string

ID returns the formatted Load Balancing Rule ID

func (LoadBalancingRuleId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Load Balancing Rule ID

func (LoadBalancingRuleId) String 

func (id LoadBalancingRuleId) String() string

String returns a human-readable description of this Load Balancing Rule ID

type LoadBalancingRuleOperationPredicate 

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

func (LoadBalancingRuleOperationPredicate) Matches 

func (p LoadBalancingRuleOperationPredicate) Matches(input LoadBalancingRule) bool

type LoadBalancingRulePropertiesFormat 

type LoadBalancingRulePropertiesFormat struct {
	BackendAddressPool      *SubResource       `json:"backendAddressPool,omitempty"`
	BackendAddressPools     *[]SubResource     `json:"backendAddressPools,omitempty"`
	BackendPort             *int64             `json:"backendPort,omitempty"`
	DisableOutboundSnat     *bool              `json:"disableOutboundSnat,omitempty"`
	EnableFloatingIP        *bool              `json:"enableFloatingIP,omitempty"`
	EnableTcpReset          *bool              `json:"enableTcpReset,omitempty"`
	FrontendIPConfiguration *SubResource       `json:"frontendIPConfiguration,omitempty"`
	FrontendPort            int64              `json:"frontendPort"`
	IdleTimeoutInMinutes    *int64             `json:"idleTimeoutInMinutes,omitempty"`
	LoadDistribution        *LoadDistribution  `json:"loadDistribution,omitempty"`
	Probe                   *SubResource       `json:"probe,omitempty"`
	Protocol                TransportProtocol  `json:"protocol"`
	ProvisioningState       *ProvisioningState `json:"provisioningState,omitempty"`
}

type LoadDistribution 

type LoadDistribution string
const (
	LoadDistributionDefault          LoadDistribution = "Default"
	LoadDistributionSourceIP         LoadDistribution = "SourceIP"
	LoadDistributionSourceIPProtocol LoadDistribution = "SourceIPProtocol"
)

func (*LoadDistribution) UnmarshalJSON 

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

type LocationId 

type LocationId struct {
	SubscriptionId string
	LocationName   string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID 

func NewLocationID(subscriptionId string, locationName string) LocationId

NewLocationID returns a new LocationId struct

func ParseLocationID 

func ParseLocationID(input string) (*LocationId, error)

ParseLocationID parses 'input' into a LocationId

func ParseLocationIDInsensitively 

func ParseLocationIDInsensitively(input string) (*LocationId, error)

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

func (LocationId) ID 

func (id LocationId) ID() string

ID returns the formatted Location ID

func (LocationId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Location ID

func (LocationId) String 

func (id LocationId) String() string

String returns a human-readable description of this Location ID

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 NatRulePortMapping 

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

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"`
	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 NetworkInterfaceOperationPredicate 

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

func (NetworkInterfaceOperationPredicate) Matches 

func (p NetworkInterfaceOperationPredicate) Matches(input NetworkInterface) bool

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 OutboundRule 

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

type OutboundRuleId 

type OutboundRuleId struct {
	SubscriptionId    string
	ResourceGroupName string
	LoadBalancerName  string
	OutboundRuleName  string
}

OutboundRuleId is a struct representing the Resource ID for a Outbound Rule

func NewOutboundRuleID 

func NewOutboundRuleID(subscriptionId string, resourceGroupName string, loadBalancerName string, outboundRuleName string) OutboundRuleId

NewOutboundRuleID returns a new OutboundRuleId struct

func ParseOutboundRuleID 

func ParseOutboundRuleID(input string) (*OutboundRuleId, error)

ParseOutboundRuleID parses 'input' into a OutboundRuleId

func ParseOutboundRuleIDInsensitively 

func ParseOutboundRuleIDInsensitively(input string) (*OutboundRuleId, error)

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

func (OutboundRuleId) ID 

func (id OutboundRuleId) ID() string

ID returns the formatted Outbound Rule ID

func (OutboundRuleId) Segments 

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

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

func (OutboundRuleId) String 

func (id OutboundRuleId) String() string

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

type OutboundRuleOperationPredicate 

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

func (OutboundRuleOperationPredicate) Matches 

func (p OutboundRuleOperationPredicate) Matches(input OutboundRule) bool

type OutboundRulePropertiesFormat 

type OutboundRulePropertiesFormat struct {
	AllocatedOutboundPorts   *int64                           `json:"allocatedOutboundPorts,omitempty"`
	BackendAddressPool       SubResource                      `json:"backendAddressPool"`
	EnableTcpReset           *bool                            `json:"enableTcpReset,omitempty"`
	FrontendIPConfigurations []SubResource                    `json:"frontendIPConfigurations"`
	IdleTimeoutInMinutes     *int64                           `json:"idleTimeoutInMinutes,omitempty"`
	Protocol                 LoadBalancerOutboundRuleProtocol `json:"protocol"`
	ProvisioningState        *ProvisioningState               `json:"provisioningState,omitempty"`
}

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 Probe 

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

type ProbeId 

type ProbeId struct {
	SubscriptionId    string
	ResourceGroupName string
	LoadBalancerName  string
	ProbeName         string
}

ProbeId is a struct representing the Resource ID for a Probe

func NewProbeID 

func NewProbeID(subscriptionId string, resourceGroupName string, loadBalancerName string, probeName string) ProbeId

NewProbeID returns a new ProbeId struct

func ParseProbeID 

func ParseProbeID(input string) (*ProbeId, error)

ParseProbeID parses 'input' into a ProbeId

func ParseProbeIDInsensitively 

func ParseProbeIDInsensitively(input string) (*ProbeId, error)

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

func (ProbeId) ID 

func (id ProbeId) ID() string

ID returns the formatted Probe ID

func (ProbeId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Probe ID

func (ProbeId) String 

func (id ProbeId) String() string

String returns a human-readable description of this Probe ID

type ProbeOperationPredicate 

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

func (ProbeOperationPredicate) Matches 

func (p ProbeOperationPredicate) Matches(input Probe) bool

type ProbePropertiesFormat 

type ProbePropertiesFormat struct {
	IntervalInSeconds  *int64             `json:"intervalInSeconds,omitempty"`
	LoadBalancingRules *[]SubResource     `json:"loadBalancingRules,omitempty"`
	NumberOfProbes     *int64             `json:"numberOfProbes,omitempty"`
	Port               int64              `json:"port"`
	ProbeThreshold     *int64             `json:"probeThreshold,omitempty"`
	Protocol           ProbeProtocol      `json:"protocol"`
	ProvisioningState  *ProvisioningState `json:"provisioningState,omitempty"`
	RequestPath        *string            `json:"requestPath,omitempty"`
}

type ProbeProtocol 

type ProbeProtocol string
const (
	ProbeProtocolHTTP  ProbeProtocol = "Http"
	ProbeProtocolHTTPS ProbeProtocol = "Https"
	ProbeProtocolTcp   ProbeProtocol = "Tcp"
)

func (*ProbeProtocol) UnmarshalJSON 

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

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 QueryInboundNatRulePortMappingRequest 

type QueryInboundNatRulePortMappingRequest struct {
	IPAddress       *string      `json:"ipAddress,omitempty"`
	IPConfiguration *SubResource `json:"ipConfiguration,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 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 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 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"`
	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"`
}

type SwapPublicIPAddressesOperationResponse 

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

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 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        *LoadBalancer
}

type VirtualNetworkPrivateEndpointNetworkPolicies 

type VirtualNetworkPrivateEndpointNetworkPolicies string
const (
	VirtualNetworkPrivateEndpointNetworkPoliciesDisabled VirtualNetworkPrivateEndpointNetworkPolicies = "Disabled"
	VirtualNetworkPrivateEndpointNetworkPoliciesEnabled  VirtualNetworkPrivateEndpointNetworkPolicies = "Enabled"
)

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"`
}

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.