armnetwork

package module
v6.0.0-...-45adee8 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2024 License: MIT Imports: 15 Imported by: 0

README

Azure Network Module for Go

The armnetwork module provides operations for working with Azure Network.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Network module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v6

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Network. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Network module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armnetwork.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armnetwork.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewAdminRuleCollectionsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

More sample code

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Network label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AADAuthenticationParameters 

type AADAuthenticationParameters struct {
	// AAD Vpn authentication parameter AAD audience.
	AADAudience *string

	// AAD Vpn authentication parameter AAD issuer.
	AADIssuer *string

	// AAD Vpn authentication parameter AAD tenant.
	AADTenant *string
}

AADAuthenticationParameters - AAD Vpn authentication type related parameters.

func (AADAuthenticationParameters) MarshalJSON 

func (a AADAuthenticationParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AADAuthenticationParameters.

func (*AADAuthenticationParameters) UnmarshalJSON 

func (a *AADAuthenticationParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AADAuthenticationParameters.

type Access 

type Access string

Access - Access to be allowed or denied. 

const (
	AccessAllow Access = "Allow"
	AccessDeny  Access = "Deny"
)

func PossibleAccessValues 

func PossibleAccessValues() []Access

PossibleAccessValues returns the possible values for the Access const type.

type Action 

type Action struct {
	// List of parameters relevant to the action.For instance if type is drop then parameters has list of prefixes to be dropped.If
	// type is add, parameters would have list of ASN numbers to be added
	Parameters []*Parameter

	// Type of action to be taken. Supported types are 'Remove', 'Add', 'Replace', and 'Drop.'
	Type *RouteMapActionType
}

Action to be taken on a route matching a RouteMap criterion.

func (Action) MarshalJSON 

func (a Action) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Action.

func (*Action) UnmarshalJSON 

func (a *Action) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Action.

type ActionType 

type ActionType string

ActionType - Defines the action to take on rule match. 

const (
	ActionTypeAllow          ActionType = "Allow"
	ActionTypeAnomalyScoring ActionType = "AnomalyScoring"
	ActionTypeBlock          ActionType = "Block"
	ActionTypeJSChallenge    ActionType = "JSChallenge"
	ActionTypeLog            ActionType = "Log"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type ActiveBaseSecurityAdminRule 

type ActiveBaseSecurityAdminRule struct {
	// REQUIRED; Whether the rule is custom or default.
	Kind *EffectiveAdminRuleKind

	// Deployment time string.
	CommitTime *time.Time

	// A description of the security admin configuration.
	ConfigurationDescription *string

	// Resource ID.
	ID *string

	// Deployment region.
	Region *string

	// Groups for rule collection
	RuleCollectionAppliesToGroups []*ManagerSecurityGroupItem

	// A description of the rule collection.
	RuleCollectionDescription *string

	// Effective configuration groups.
	RuleGroups []*ConfigurationGroup
}

ActiveBaseSecurityAdminRule - Network base admin rule.

func (*ActiveBaseSecurityAdminRule) GetActiveBaseSecurityAdminRule 

func (a *ActiveBaseSecurityAdminRule) GetActiveBaseSecurityAdminRule() *ActiveBaseSecurityAdminRule

GetActiveBaseSecurityAdminRule implements the ActiveBaseSecurityAdminRuleClassification interface for type ActiveBaseSecurityAdminRule.

func (ActiveBaseSecurityAdminRule) MarshalJSON 

func (a ActiveBaseSecurityAdminRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveBaseSecurityAdminRule.

func (*ActiveBaseSecurityAdminRule) UnmarshalJSON 

func (a *ActiveBaseSecurityAdminRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveBaseSecurityAdminRule.

type ActiveBaseSecurityAdminRuleClassification 

type ActiveBaseSecurityAdminRuleClassification interface {
	// GetActiveBaseSecurityAdminRule returns the ActiveBaseSecurityAdminRule content of the underlying type.
	GetActiveBaseSecurityAdminRule() *ActiveBaseSecurityAdminRule
}

ActiveBaseSecurityAdminRuleClassification provides polymorphic access to related types. Call the interface's GetActiveBaseSecurityAdminRule() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *ActiveBaseSecurityAdminRule, *ActiveDefaultSecurityAdminRule, *ActiveSecurityAdminRule

type ActiveConfigurationParameter 

type ActiveConfigurationParameter struct {
	// List of regions.
	Regions []*string

	// When present, the value can be passed to a subsequent query call (together with the same query and scopes used in the current
	// request) to retrieve the next page of data.
	SkipToken *string
}

ActiveConfigurationParameter - Effective Virtual Networks Parameter.

func (ActiveConfigurationParameter) MarshalJSON 

func (a ActiveConfigurationParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveConfigurationParameter.

func (*ActiveConfigurationParameter) UnmarshalJSON 

func (a *ActiveConfigurationParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveConfigurationParameter.

type ActiveConnectivityConfiguration 

type ActiveConnectivityConfiguration struct {
	// Deployment time string.
	CommitTime *time.Time

	// Effective configuration groups.
	ConfigurationGroups []*ConfigurationGroup

	// Connectivity configuration ID.
	ID *string

	// Properties of a network manager connectivity configuration
	Properties *ConnectivityConfigurationProperties

	// Deployment region.
	Region *string
}

ActiveConnectivityConfiguration - Active connectivity configuration.

func (ActiveConnectivityConfiguration) MarshalJSON 

func (a ActiveConnectivityConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveConnectivityConfiguration.

func (*ActiveConnectivityConfiguration) UnmarshalJSON 

func (a *ActiveConnectivityConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveConnectivityConfiguration.

type ActiveConnectivityConfigurationsListResult 

type ActiveConnectivityConfigurationsListResult struct {
	// When present, the value can be passed to a subsequent query call (together with the same query and scopes used in the current
	// request) to retrieve the next page of data.
	SkipToken *string

	// Gets a page of active connectivity configurations.
	Value []*ActiveConnectivityConfiguration
}

ActiveConnectivityConfigurationsListResult - Result of the request to list active connectivity configurations. It contains a list of active connectivity configurations and a skiptoken to get the next set of results.

func (ActiveConnectivityConfigurationsListResult) MarshalJSON 

func (a ActiveConnectivityConfigurationsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveConnectivityConfigurationsListResult.

func (*ActiveConnectivityConfigurationsListResult) UnmarshalJSON 

func (a *ActiveConnectivityConfigurationsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveConnectivityConfigurationsListResult.

type ActiveDefaultSecurityAdminRule 

type ActiveDefaultSecurityAdminRule struct {
	// REQUIRED; Whether the rule is custom or default.
	Kind *EffectiveAdminRuleKind

	// Deployment time string.
	CommitTime *time.Time

	// A description of the security admin configuration.
	ConfigurationDescription *string

	// Resource ID.
	ID *string

	// Indicates the properties of the default security admin rule
	Properties *DefaultAdminPropertiesFormat

	// Deployment region.
	Region *string

	// Groups for rule collection
	RuleCollectionAppliesToGroups []*ManagerSecurityGroupItem

	// A description of the rule collection.
	RuleCollectionDescription *string

	// Effective configuration groups.
	RuleGroups []*ConfigurationGroup
}

ActiveDefaultSecurityAdminRule - Network default admin rule.

func (*ActiveDefaultSecurityAdminRule) GetActiveBaseSecurityAdminRule 

func (a *ActiveDefaultSecurityAdminRule) GetActiveBaseSecurityAdminRule() *ActiveBaseSecurityAdminRule

GetActiveBaseSecurityAdminRule implements the ActiveBaseSecurityAdminRuleClassification interface for type ActiveDefaultSecurityAdminRule.

func (ActiveDefaultSecurityAdminRule) MarshalJSON 

func (a ActiveDefaultSecurityAdminRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveDefaultSecurityAdminRule.

func (*ActiveDefaultSecurityAdminRule) UnmarshalJSON 

func (a *ActiveDefaultSecurityAdminRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveDefaultSecurityAdminRule.

type ActiveSecurityAdminRule 

type ActiveSecurityAdminRule struct {
	// REQUIRED; Whether the rule is custom or default.
	Kind *EffectiveAdminRuleKind

	// Deployment time string.
	CommitTime *time.Time

	// A description of the security admin configuration.
	ConfigurationDescription *string

	// Resource ID.
	ID *string

	// Indicates the properties of the security admin rule
	Properties *AdminPropertiesFormat

	// Deployment region.
	Region *string

	// Groups for rule collection
	RuleCollectionAppliesToGroups []*ManagerSecurityGroupItem

	// A description of the rule collection.
	RuleCollectionDescription *string

	// Effective configuration groups.
	RuleGroups []*ConfigurationGroup
}

ActiveSecurityAdminRule - Network admin rule.

func (*ActiveSecurityAdminRule) GetActiveBaseSecurityAdminRule 

func (a *ActiveSecurityAdminRule) GetActiveBaseSecurityAdminRule() *ActiveBaseSecurityAdminRule

GetActiveBaseSecurityAdminRule implements the ActiveBaseSecurityAdminRuleClassification interface for type ActiveSecurityAdminRule.

func (ActiveSecurityAdminRule) MarshalJSON 

func (a ActiveSecurityAdminRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveSecurityAdminRule.

func (*ActiveSecurityAdminRule) UnmarshalJSON 

func (a *ActiveSecurityAdminRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveSecurityAdminRule.

type ActiveSecurityAdminRulesListResult 

type ActiveSecurityAdminRulesListResult struct {
	// When present, the value can be passed to a subsequent query call (together with the same query and scopes used in the current
	// request) to retrieve the next page of data.
	SkipToken *string

	// Gets a page of active security admin rules.
	Value []ActiveBaseSecurityAdminRuleClassification
}

ActiveSecurityAdminRulesListResult - Result of the request to list active security admin rules. It contains a list of active security admin rules and a skiptoken to get the next set of results.

func (ActiveSecurityAdminRulesListResult) MarshalJSON 

func (a ActiveSecurityAdminRulesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveSecurityAdminRulesListResult.

func (*ActiveSecurityAdminRulesListResult) UnmarshalJSON 

func (a *ActiveSecurityAdminRulesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveSecurityAdminRulesListResult.

type AddressPrefixItem 

type AddressPrefixItem struct {
	// Address prefix.
	AddressPrefix *string

	// Address prefix type.
	AddressPrefixType *AddressPrefixType
}

AddressPrefixItem - Address prefix item.

func (AddressPrefixItem) MarshalJSON 

func (a AddressPrefixItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AddressPrefixItem.

func (*AddressPrefixItem) UnmarshalJSON 

func (a *AddressPrefixItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AddressPrefixItem.

type AddressPrefixType 

type AddressPrefixType string

AddressPrefixType - Address prefix type. 

const (
	AddressPrefixTypeIPPrefix   AddressPrefixType = "IPPrefix"
	AddressPrefixTypeServiceTag AddressPrefixType = "ServiceTag"
)

func PossibleAddressPrefixTypeValues 

func PossibleAddressPrefixTypeValues() []AddressPrefixType

PossibleAddressPrefixTypeValues returns the possible values for the AddressPrefixType const type.

type AddressSpace 

type AddressSpace struct {
	// A list of address blocks reserved for this virtual network in CIDR notation.
	AddressPrefixes []*string
}

AddressSpace contains an array of IP address ranges that can be used by subnets of the virtual network.

func (AddressSpace) MarshalJSON 

func (a AddressSpace) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AddressSpace.

func (*AddressSpace) UnmarshalJSON 

func (a *AddressSpace) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AddressSpace.

type AdminPropertiesFormat 

type AdminPropertiesFormat struct {
	// REQUIRED; Indicates the access allowed for this particular rule
	Access *SecurityConfigurationRuleAccess

	// REQUIRED; Indicates if the traffic matched against the rule in inbound or outbound.
	Direction *SecurityConfigurationRuleDirection

	// REQUIRED; The priority of the rule. The value can be between 1 and 4096. The priority number must be unique for each rule
	// in the collection. The lower the priority number, the higher the priority of the rule.
	Priority *int32

	// REQUIRED; Network protocol this rule applies to.
	Protocol *SecurityConfigurationRuleProtocol

	// A description for this rule. Restricted to 140 chars.
	Description *string

	// The destination port ranges.
	DestinationPortRanges []*string

	// The destination address prefixes. CIDR or destination IP ranges.
	Destinations []*AddressPrefixItem

	// The source port ranges.
	SourcePortRanges []*string

	// The CIDR or source IP ranges.
	Sources []*AddressPrefixItem

	// READ-ONLY; The provisioning state of the resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Unique identifier for this resource.
	ResourceGUID *string
}

AdminPropertiesFormat - Security admin rule resource.

func (AdminPropertiesFormat) MarshalJSON 

func (a AdminPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminPropertiesFormat.

func (*AdminPropertiesFormat) UnmarshalJSON 

func (a *AdminPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminPropertiesFormat.

type AdminRule 

type AdminRule struct {
	// REQUIRED; Whether the rule is custom or default.
	Kind *AdminRuleKind

	// Indicates the properties of the security admin rule
	Properties *AdminPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; The system metadata related to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

AdminRule - Network admin rule.

func (*AdminRule) GetBaseAdminRule 

func (a *AdminRule) GetBaseAdminRule() *BaseAdminRule

GetBaseAdminRule implements the BaseAdminRuleClassification interface for type AdminRule.

func (AdminRule) MarshalJSON 

func (a AdminRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminRule.

func (*AdminRule) UnmarshalJSON 

func (a *AdminRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRule.

type AdminRuleCollection 

type AdminRuleCollection struct {
	// Indicates the properties for the network manager admin rule collection.
	Properties *AdminRuleCollectionPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; The system metadata related to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

AdminRuleCollection - Defines the admin rule collection.

func (AdminRuleCollection) MarshalJSON 

func (a AdminRuleCollection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminRuleCollection.

func (*AdminRuleCollection) UnmarshalJSON 

func (a *AdminRuleCollection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRuleCollection.

type AdminRuleCollectionListResult 

type AdminRuleCollectionListResult struct {
	// Gets the URL to get the next set of results.
	NextLink *string

	// A list of network manager security admin configuration rule collections
	Value []*AdminRuleCollection
}

AdminRuleCollectionListResult - Security admin configuration rule collection list result.

func (AdminRuleCollectionListResult) MarshalJSON 

func (a AdminRuleCollectionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminRuleCollectionListResult.

func (*AdminRuleCollectionListResult) UnmarshalJSON 

func (a *AdminRuleCollectionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRuleCollectionListResult.

type AdminRuleCollectionPropertiesFormat 

type AdminRuleCollectionPropertiesFormat struct {
	// REQUIRED; Groups for configuration
	AppliesToGroups []*ManagerSecurityGroupItem

	// A description of the admin rule collection.
	Description *string

	// READ-ONLY; The provisioning state of the resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Unique identifier for this resource.
	ResourceGUID *string
}

AdminRuleCollectionPropertiesFormat - Defines the admin rule collection properties.

func (AdminRuleCollectionPropertiesFormat) MarshalJSON 

func (a AdminRuleCollectionPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminRuleCollectionPropertiesFormat.

func (*AdminRuleCollectionPropertiesFormat) UnmarshalJSON 

func (a *AdminRuleCollectionPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRuleCollectionPropertiesFormat.

type AdminRuleCollectionsClient 

type AdminRuleCollectionsClient struct {
	// contains filtered or unexported fields
}

AdminRuleCollectionsClient contains the methods for the AdminRuleCollections group. Don't use this type directly, use NewAdminRuleCollectionsClient() instead.

func NewAdminRuleCollectionsClient 

func NewAdminRuleCollectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AdminRuleCollectionsClient, error)

NewAdminRuleCollectionsClient creates a new instance of AdminRuleCollectionsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AdminRuleCollectionsClient) BeginDelete 

func (client *AdminRuleCollectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, options *AdminRuleCollectionsClientBeginDeleteOptions) (*runtime.Poller[AdminRuleCollectionsClientDeleteResponse], error)

BeginDelete - Deletes an admin rule collection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • options - AdminRuleCollectionsClientBeginDeleteOptions contains the optional parameters for the AdminRuleCollectionsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleCollectionDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAdminRuleCollectionsClient().BeginDelete(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", &armnetwork.AdminRuleCollectionsClientBeginDeleteOptions{Force: to.Ptr(false)})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*AdminRuleCollectionsClient) CreateOrUpdate 

func (client *AdminRuleCollectionsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, ruleCollection AdminRuleCollection, options *AdminRuleCollectionsClientCreateOrUpdateOptions) (AdminRuleCollectionsClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates an admin rule collection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • ruleCollection - The Rule Collection to create or update
  • options - AdminRuleCollectionsClientCreateOrUpdateOptions contains the optional parameters for the AdminRuleCollectionsClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleCollectionPut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdminRuleCollectionsClient().CreateOrUpdate(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", armnetwork.AdminRuleCollection{
	Properties: &armnetwork.AdminRuleCollectionPropertiesFormat{
		Description: to.Ptr("A sample policy"),
		AppliesToGroups: []*armnetwork.ManagerSecurityGroupItem{
			{
				NetworkGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/networkGroups/testGroup"),
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AdminRuleCollection = armnetwork.AdminRuleCollection{
// 	Name: to.Ptr("myTestSecurityConfig"),
// 	Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManager/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection"),
// 	Properties: &armnetwork.AdminRuleCollectionPropertiesFormat{
// 		Description: to.Ptr("A sample policy"),
// 		AppliesToGroups: []*armnetwork.ManagerSecurityGroupItem{
// 			{
// 				NetworkGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/networkGroups/testGroup"),
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 	},
// 	SystemData: &armnetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 		CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 		CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 		LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 		LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 	},
// }

func (*AdminRuleCollectionsClient) Get 

func (client *AdminRuleCollectionsClient) Get(ctx context.Context, resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, options *AdminRuleCollectionsClientGetOptions) (AdminRuleCollectionsClientGetResponse, error)

Get - Gets a network manager security admin configuration rule collection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • options - AdminRuleCollectionsClientGetOptions contains the optional parameters for the AdminRuleCollectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleCollectionGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdminRuleCollectionsClient().Get(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AdminRuleCollection = armnetwork.AdminRuleCollection{
// 	Name: to.Ptr("testRuleCollection"),
// 	Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection"),
// 	Properties: &armnetwork.AdminRuleCollectionPropertiesFormat{
// 		Description: to.Ptr("A sample rule collection"),
// 		AppliesToGroups: []*armnetwork.ManagerSecurityGroupItem{
// 			{
// 				NetworkGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/networkGroups/testGroup"),
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 	},
// 	SystemData: &armnetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 		CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 		CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 		LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 		LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 	},
// }

func (*AdminRuleCollectionsClient) NewListPager 

func (client *AdminRuleCollectionsClient) NewListPager(resourceGroupName string, networkManagerName string, configurationName string, options *AdminRuleCollectionsClientListOptions) *runtime.Pager[AdminRuleCollectionsClientListResponse]

NewListPager - Lists all the rule collections in a security admin configuration, in a paginated format.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • options - AdminRuleCollectionsClientListOptions contains the optional parameters for the AdminRuleCollectionsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleCollectionList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAdminRuleCollectionsClient().NewListPager("rg1", "testNetworkManager", "myTestSecurityConfig", &armnetwork.AdminRuleCollectionsClientListOptions{Top: nil,
	SkipToken: nil,
})
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AdminRuleCollectionListResult = armnetwork.AdminRuleCollectionListResult{
	// 	Value: []*armnetwork.AdminRuleCollection{
	// 		{
	// 			Name: to.Ptr("testRuleCollection"),
	// 			Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection"),
	// 			Properties: &armnetwork.AdminRuleCollectionPropertiesFormat{
	// 				Description: to.Ptr("A sample rule collection"),
	// 				AppliesToGroups: []*armnetwork.ManagerSecurityGroupItem{
	// 					{
	// 						NetworkGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/networkGroups/testGroup"),
	// 				}},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 			SystemData: &armnetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
	// 				CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
	// 				CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
	// 				LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
	// 			},
	// 	}},
	// }
}

type AdminRuleCollectionsClientBeginDeleteOptions 

type AdminRuleCollectionsClientBeginDeleteOptions struct {
	// Deletes the resource even if it is part of a deployed configuration. If the configuration has been deployed, the service
	// will do a cleanup deployment in the background, prior to the delete.
	Force *bool

	// Resumes the LRO from the provided token.
	ResumeToken string
}

AdminRuleCollectionsClientBeginDeleteOptions contains the optional parameters for the AdminRuleCollectionsClient.BeginDelete method.

type AdminRuleCollectionsClientCreateOrUpdateOptions 

type AdminRuleCollectionsClientCreateOrUpdateOptions struct {
}

AdminRuleCollectionsClientCreateOrUpdateOptions contains the optional parameters for the AdminRuleCollectionsClient.CreateOrUpdate method.

type AdminRuleCollectionsClientCreateOrUpdateResponse 

type AdminRuleCollectionsClientCreateOrUpdateResponse struct {
	// Defines the admin rule collection.
	AdminRuleCollection
}

AdminRuleCollectionsClientCreateOrUpdateResponse contains the response from method AdminRuleCollectionsClient.CreateOrUpdate.

type AdminRuleCollectionsClientDeleteResponse 

type AdminRuleCollectionsClientDeleteResponse struct {
}

AdminRuleCollectionsClientDeleteResponse contains the response from method AdminRuleCollectionsClient.BeginDelete.

type AdminRuleCollectionsClientGetOptions 

type AdminRuleCollectionsClientGetOptions struct {
}

AdminRuleCollectionsClientGetOptions contains the optional parameters for the AdminRuleCollectionsClient.Get method.

type AdminRuleCollectionsClientGetResponse 

type AdminRuleCollectionsClientGetResponse struct {
	// Defines the admin rule collection.
	AdminRuleCollection
}

AdminRuleCollectionsClientGetResponse contains the response from method AdminRuleCollectionsClient.Get.

type AdminRuleCollectionsClientListOptions 

type AdminRuleCollectionsClientListOptions struct {
	// SkipToken is only used if a previous operation returned a partial result. If a previous response contains a nextLink element,
	// the value of the nextLink element will include a skipToken parameter that
	// specifies a starting point to use for subsequent calls.
	SkipToken *string

	// An optional query parameter which specifies the maximum number of records to be returned by the server.
	Top *int32
}

AdminRuleCollectionsClientListOptions contains the optional parameters for the AdminRuleCollectionsClient.NewListPager method.

type AdminRuleCollectionsClientListResponse 

type AdminRuleCollectionsClientListResponse struct {
	// Security admin configuration rule collection list result.
	AdminRuleCollectionListResult
}

AdminRuleCollectionsClientListResponse contains the response from method AdminRuleCollectionsClient.NewListPager.

type AdminRuleKind 

type AdminRuleKind string

AdminRuleKind - Whether the rule is custom or default. 

const (
	AdminRuleKindCustom  AdminRuleKind = "Custom"
	AdminRuleKindDefault AdminRuleKind = "Default"
)

func PossibleAdminRuleKindValues 

func PossibleAdminRuleKindValues() []AdminRuleKind

PossibleAdminRuleKindValues returns the possible values for the AdminRuleKind const type.

type AdminRuleListResult 

type AdminRuleListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// A list of admin rules
	Value []BaseAdminRuleClassification
}

AdminRuleListResult - security configuration admin rule list result.

func (AdminRuleListResult) MarshalJSON 

func (a AdminRuleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminRuleListResult.

func (*AdminRuleListResult) UnmarshalJSON 

func (a *AdminRuleListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRuleListResult.

type AdminRulesClient 

type AdminRulesClient struct {
	// contains filtered or unexported fields
}

AdminRulesClient contains the methods for the AdminRules group. Don't use this type directly, use NewAdminRulesClient() instead.

func NewAdminRulesClient 

func NewAdminRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AdminRulesClient, error)

NewAdminRulesClient creates a new instance of AdminRulesClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AdminRulesClient) BeginDelete 

func (client *AdminRulesClient) BeginDelete(ctx context.Context, resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, ruleName string, options *AdminRulesClientBeginDeleteOptions) (*runtime.Poller[AdminRulesClientDeleteResponse], error)

BeginDelete - Deletes an admin rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • ruleName - The name of the rule.
  • options - AdminRulesClientBeginDeleteOptions contains the optional parameters for the AdminRulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAdminRulesClient().BeginDelete(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", "SampleAdminRule", &armnetwork.AdminRulesClientBeginDeleteOptions{Force: to.Ptr(false)})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*AdminRulesClient) CreateOrUpdate 

func (client *AdminRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, ruleName string, adminRule BaseAdminRuleClassification, options *AdminRulesClientCreateOrUpdateOptions) (AdminRulesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates an admin rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • ruleName - The name of the rule.
  • adminRule - The admin rule to create or update
  • options - AdminRulesClientCreateOrUpdateOptions contains the optional parameters for the AdminRulesClient.CreateOrUpdate method.
Example (CreateADefaultAdminRule)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerDefaultAdminRulePut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdminRulesClient().CreateOrUpdate(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", "SampleDefaultAdminRule", &armnetwork.DefaultAdminRule{
	Kind: to.Ptr(armnetwork.AdminRuleKindDefault),
	Properties: &armnetwork.DefaultAdminPropertiesFormat{
		Flag: to.Ptr("AllowVnetInbound"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armnetwork.AdminRulesClientCreateOrUpdateResponse{
// 	                            BaseAdminRuleClassification: &armnetwork.DefaultAdminRule{
// 		Name: to.Ptr("SampleDefaultAdminRule"),
// 		Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections/rules"),
// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection/rules/SampleDefaultAdminRule"),
// 		Kind: to.Ptr(armnetwork.AdminRuleKindDefault),
// 		SystemData: &armnetwork.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 		},
// 		Properties: &armnetwork.DefaultAdminPropertiesFormat{
// 			Description: to.Ptr("This is Sample Default Admin Rule"),
// 			Access: to.Ptr(armnetwork.SecurityConfigurationRuleAccessDeny),
// 			DestinationPortRanges: []*string{
// 				to.Ptr("22")},
// 				Destinations: []*armnetwork.AddressPrefixItem{
// 					{
// 						AddressPrefix: to.Ptr("*"),
// 						AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
// 				}},
// 				Direction: to.Ptr(armnetwork.SecurityConfigurationRuleDirectionInbound),
// 				Flag: to.Ptr("AllowVnetInbound"),
// 				Priority: to.Ptr[int32](1),
// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 				SourcePortRanges: []*string{
// 					to.Ptr("0-65535")},
// 					Sources: []*armnetwork.AddressPrefixItem{
// 						{
// 							AddressPrefix: to.Ptr("Internet"),
// 							AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeServiceTag),
// 					}},
// 					Protocol: to.Ptr(armnetwork.SecurityConfigurationRuleProtocolTCP),
// 				},
// 			},
// 			                        }
Example (CreateAnAdminRule)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRulePut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdminRulesClient().CreateOrUpdate(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", "SampleAdminRule", &armnetwork.AdminRule{
	Kind: to.Ptr(armnetwork.AdminRuleKindCustom),
	Properties: &armnetwork.AdminPropertiesFormat{
		Description: to.Ptr("This is Sample Admin Rule"),
		Access:      to.Ptr(armnetwork.SecurityConfigurationRuleAccessDeny),
		DestinationPortRanges: []*string{
			to.Ptr("22")},
		Destinations: []*armnetwork.AddressPrefixItem{
			{
				AddressPrefix:     to.Ptr("*"),
				AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
			}},
		Direction: to.Ptr(armnetwork.SecurityConfigurationRuleDirectionInbound),
		Priority:  to.Ptr[int32](1),
		SourcePortRanges: []*string{
			to.Ptr("0-65535")},
		Sources: []*armnetwork.AddressPrefixItem{
			{
				AddressPrefix:     to.Ptr("Internet"),
				AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeServiceTag),
			}},
		Protocol: to.Ptr(armnetwork.SecurityConfigurationRuleProtocolTCP),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armnetwork.AdminRulesClientCreateOrUpdateResponse{
// 	                            BaseAdminRuleClassification: &armnetwork.AdminRule{
// 		Name: to.Ptr("SampleAdminRule"),
// 		Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections/rules"),
// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection/rules/SampleAdminRule"),
// 		Kind: to.Ptr(armnetwork.AdminRuleKindCustom),
// 		SystemData: &armnetwork.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 		},
// 		Properties: &armnetwork.AdminPropertiesFormat{
// 			Description: to.Ptr("This is Sample Admin Rule"),
// 			Access: to.Ptr(armnetwork.SecurityConfigurationRuleAccessDeny),
// 			DestinationPortRanges: []*string{
// 				to.Ptr("22")},
// 				Destinations: []*armnetwork.AddressPrefixItem{
// 					{
// 						AddressPrefix: to.Ptr("*"),
// 						AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
// 				}},
// 				Direction: to.Ptr(armnetwork.SecurityConfigurationRuleDirectionInbound),
// 				Priority: to.Ptr[int32](1),
// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 				SourcePortRanges: []*string{
// 					to.Ptr("0-65535")},
// 					Sources: []*armnetwork.AddressPrefixItem{
// 						{
// 							AddressPrefix: to.Ptr("Internet"),
// 							AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeServiceTag),
// 					}},
// 					Protocol: to.Ptr(armnetwork.SecurityConfigurationRuleProtocolTCP),
// 				},
// 			},
// 			                        }

func (*AdminRulesClient) Get 

func (client *AdminRulesClient) Get(ctx context.Context, resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, ruleName string, options *AdminRulesClientGetOptions) (AdminRulesClientGetResponse, error)

Get - Gets a network manager security configuration admin rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • ruleName - The name of the rule.
  • options - AdminRulesClientGetOptions contains the optional parameters for the AdminRulesClient.Get method.
Example (GetsSecurityAdminRule)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdminRulesClient().Get(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", "SampleAdminRule", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armnetwork.AdminRulesClientGetResponse{
// 	                            BaseAdminRuleClassification: &armnetwork.AdminRule{
// 		Name: to.Ptr("SampleAdminRule"),
// 		Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections/rules"),
// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection/rules/SampleAdminRule"),
// 		Kind: to.Ptr(armnetwork.AdminRuleKindCustom),
// 		SystemData: &armnetwork.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 		},
// 		Properties: &armnetwork.AdminPropertiesFormat{
// 			Description: to.Ptr("This is Sample Admin Rule"),
// 			Access: to.Ptr(armnetwork.SecurityConfigurationRuleAccessDeny),
// 			DestinationPortRanges: []*string{
// 				to.Ptr("22")},
// 				Destinations: []*armnetwork.AddressPrefixItem{
// 					{
// 						AddressPrefix: to.Ptr("*"),
// 						AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
// 				}},
// 				Direction: to.Ptr(armnetwork.SecurityConfigurationRuleDirectionInbound),
// 				Priority: to.Ptr[int32](1),
// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 				SourcePortRanges: []*string{
// 					to.Ptr("0-65535")},
// 					Sources: []*armnetwork.AddressPrefixItem{
// 						{
// 							AddressPrefix: to.Ptr("*"),
// 							AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
// 					}},
// 					Protocol: to.Ptr(armnetwork.SecurityConfigurationRuleProtocolTCP),
// 				},
// 			},
// 			                        }
Example (GetsSecurityDefaultAdminRule)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerDefaultAdminRuleGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdminRulesClient().Get(ctx, "rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", "SampleDefaultAdminRule", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armnetwork.AdminRulesClientGetResponse{
// 	                            BaseAdminRuleClassification: &armnetwork.DefaultAdminRule{
// 		Name: to.Ptr("SampleDefaultAdminRule"),
// 		Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections/rules"),
// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkManagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection/rules/SampleDefaultAdminRule"),
// 		Kind: to.Ptr(armnetwork.AdminRuleKindDefault),
// 		SystemData: &armnetwork.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
// 			LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
// 			LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
// 		},
// 		Properties: &armnetwork.DefaultAdminPropertiesFormat{
// 			Description: to.Ptr("This is Sample Default Admin Rule"),
// 			Access: to.Ptr(armnetwork.SecurityConfigurationRuleAccessDeny),
// 			DestinationPortRanges: []*string{
// 				to.Ptr("22")},
// 				Destinations: []*armnetwork.AddressPrefixItem{
// 					{
// 						AddressPrefix: to.Ptr("*"),
// 						AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
// 				}},
// 				Direction: to.Ptr(armnetwork.SecurityConfigurationRuleDirectionInbound),
// 				Flag: to.Ptr("AllowVnetInbound"),
// 				Priority: to.Ptr[int32](1),
// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 				SourcePortRanges: []*string{
// 					to.Ptr("0-65535")},
// 					Sources: []*armnetwork.AddressPrefixItem{
// 						{
// 							AddressPrefix: to.Ptr("*"),
// 							AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
// 					}},
// 					Protocol: to.Ptr(armnetwork.SecurityConfigurationRuleProtocolTCP),
// 				},
// 			},
// 			                        }

func (*AdminRulesClient) NewListPager 

func (client *AdminRulesClient) NewListPager(resourceGroupName string, networkManagerName string, configurationName string, ruleCollectionName string, options *AdminRulesClientListOptions) *runtime.Pager[AdminRulesClientListResponse]

NewListPager - List all network manager security configuration admin rules.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • networkManagerName - The name of the network manager.
  • configurationName - The name of the network manager Security Configuration.
  • ruleCollectionName - The name of the network manager security Configuration rule collection.
  • options - AdminRulesClientListOptions contains the optional parameters for the AdminRulesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkManagerAdminRuleList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAdminRulesClient().NewListPager("rg1", "testNetworkManager", "myTestSecurityConfig", "testRuleCollection", &armnetwork.AdminRulesClientListOptions{Top: nil,
	SkipToken: nil,
})
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AdminRuleListResult = armnetwork.AdminRuleListResult{
	// 	Value: []armnetwork.BaseAdminRuleClassification{
	// 		&armnetwork.AdminRule{
	// 			Name: to.Ptr("SampleAdminRule"),
	// 			Type: to.Ptr("Microsoft.Network/networkManagers/securityAdminConfigurations/ruleCollections/rules"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Network/networkmanagers/testNetworkManager/securityAdminConfigurations/myTestSecurityConfig/ruleCollections/testRuleCollection/rules/SampleAdminRule"),
	// 			Kind: to.Ptr(armnetwork.AdminRuleKindCustom),
	// 			SystemData: &armnetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
	// 				CreatedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
	// 				CreatedByType: to.Ptr(armnetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-11T18:52:27.000Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("b69a9388-9488-4534-b470-7ec6d41beef5"),
	// 				LastModifiedByType: to.Ptr(armnetwork.CreatedByTypeUser),
	// 			},
	// 			Properties: &armnetwork.AdminPropertiesFormat{
	// 				Description: to.Ptr("This is Sample Admin Rule"),
	// 				Access: to.Ptr(armnetwork.SecurityConfigurationRuleAccessDeny),
	// 				DestinationPortRanges: []*string{
	// 					to.Ptr("22")},
	// 					Destinations: []*armnetwork.AddressPrefixItem{
	// 						{
	// 							AddressPrefix: to.Ptr("*"),
	// 							AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
	// 					}},
	// 					Direction: to.Ptr(armnetwork.SecurityConfigurationRuleDirectionInbound),
	// 					Priority: to.Ptr[int32](1),
	// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 					ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 					SourcePortRanges: []*string{
	// 						to.Ptr("0-65535")},
	// 						Sources: []*armnetwork.AddressPrefixItem{
	// 							{
	// 								AddressPrefix: to.Ptr("*"),
	// 								AddressPrefixType: to.Ptr(armnetwork.AddressPrefixTypeIPPrefix),
	// 						}},
	// 						Protocol: to.Ptr(armnetwork.SecurityConfigurationRuleProtocolTCP),
	// 					},
	// 			}},
	// 		}
}

type AdminRulesClientBeginDeleteOptions 

type AdminRulesClientBeginDeleteOptions struct {
	// Deletes the resource even if it is part of a deployed configuration. If the configuration has been deployed, the service
	// will do a cleanup deployment in the background, prior to the delete.
	Force *bool

	// Resumes the LRO from the provided token.
	ResumeToken string
}

AdminRulesClientBeginDeleteOptions contains the optional parameters for the AdminRulesClient.BeginDelete method.

type AdminRulesClientCreateOrUpdateOptions 

type AdminRulesClientCreateOrUpdateOptions struct {
}

AdminRulesClientCreateOrUpdateOptions contains the optional parameters for the AdminRulesClient.CreateOrUpdate method.

type AdminRulesClientCreateOrUpdateResponse 

type AdminRulesClientCreateOrUpdateResponse struct {
	// Network base admin rule.
	BaseAdminRuleClassification
}

AdminRulesClientCreateOrUpdateResponse contains the response from method AdminRulesClient.CreateOrUpdate.

func (*AdminRulesClientCreateOrUpdateResponse) UnmarshalJSON 

func (a *AdminRulesClientCreateOrUpdateResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRulesClientCreateOrUpdateResponse.

type AdminRulesClientDeleteResponse 

type AdminRulesClientDeleteResponse struct {
}

AdminRulesClientDeleteResponse contains the response from method AdminRulesClient.BeginDelete.

type AdminRulesClientGetOptions 

type AdminRulesClientGetOptions struct {
}

AdminRulesClientGetOptions contains the optional parameters for the AdminRulesClient.Get method.

type AdminRulesClientGetResponse 

type AdminRulesClientGetResponse struct {
	// Network base admin rule.
	BaseAdminRuleClassification
}

AdminRulesClientGetResponse contains the response from method AdminRulesClient.Get.

func (*AdminRulesClientGetResponse) UnmarshalJSON 

func (a *AdminRulesClientGetResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminRulesClientGetResponse.

type AdminRulesClientListOptions 

type AdminRulesClientListOptions struct {
	// SkipToken is only used if a previous operation returned a partial result. If a previous response contains a nextLink element,
	// the value of the nextLink element will include a skipToken parameter that
	// specifies a starting point to use for subsequent calls.
	SkipToken *string

	// An optional query parameter which specifies the maximum number of records to be returned by the server.
	Top *int32
}

AdminRulesClientListOptions contains the optional parameters for the AdminRulesClient.NewListPager method.

type AdminRulesClientListResponse 

type AdminRulesClientListResponse struct {
	// security configuration admin rule list result.
	AdminRuleListResult
}

AdminRulesClientListResponse contains the response from method AdminRulesClient.NewListPager.

type AdminState 

type AdminState string

AdminState - Property to indicate if the Express Route Gateway serves traffic when there are multiple Express Route Gateways in the vnet 

const (
	AdminStateDisabled AdminState = "Disabled"
	AdminStateEnabled  AdminState = "Enabled"
)

func PossibleAdminStateValues 

func PossibleAdminStateValues() []AdminState

PossibleAdminStateValues returns the possible values for the AdminState const type.

type ApplicationGateway 

type ApplicationGateway struct {
	// Resource ID.
	ID *string

	// The identity of the application gateway, if configured.
	Identity *ManagedServiceIdentity

	// Resource location.
	Location *string

	// Properties of the application gateway.
	Properties *ApplicationGatewayPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// A list of availability zones denoting where the resource needs to come from.
	Zones []*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ApplicationGateway - Application gateway resource.

func (ApplicationGateway) MarshalJSON 

func (a ApplicationGateway) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGateway.

func (*ApplicationGateway) UnmarshalJSON 

func (a *ApplicationGateway) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGateway.

type ApplicationGatewayAuthenticationCertificate 

type ApplicationGatewayAuthenticationCertificate struct {
	// Resource ID.
	ID *string

	// Name of the authentication certificate that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway authentication certificate.
	Properties *ApplicationGatewayAuthenticationCertificatePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayAuthenticationCertificate - Authentication certificates of an application gateway.

func (ApplicationGatewayAuthenticationCertificate) MarshalJSON 

func (a ApplicationGatewayAuthenticationCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAuthenticationCertificate.

func (*ApplicationGatewayAuthenticationCertificate) UnmarshalJSON 

func (a *ApplicationGatewayAuthenticationCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAuthenticationCertificate.

type ApplicationGatewayAuthenticationCertificatePropertiesFormat 

type ApplicationGatewayAuthenticationCertificatePropertiesFormat struct {
	// Certificate public data.
	Data *string

	// READ-ONLY; The provisioning state of the authentication certificate resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayAuthenticationCertificatePropertiesFormat - Authentication certificates properties of an application gateway.

func (ApplicationGatewayAuthenticationCertificatePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayAuthenticationCertificatePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAuthenticationCertificatePropertiesFormat.

func (*ApplicationGatewayAuthenticationCertificatePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayAuthenticationCertificatePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAuthenticationCertificatePropertiesFormat.

type ApplicationGatewayAutoscaleConfiguration 

type ApplicationGatewayAutoscaleConfiguration struct {
	// REQUIRED; Lower bound on number of Application Gateway capacity.
	MinCapacity *int32

	// Upper bound on number of Application Gateway capacity.
	MaxCapacity *int32
}

ApplicationGatewayAutoscaleConfiguration - Application Gateway autoscale configuration.

func (ApplicationGatewayAutoscaleConfiguration) MarshalJSON 

func (a ApplicationGatewayAutoscaleConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAutoscaleConfiguration.

func (*ApplicationGatewayAutoscaleConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayAutoscaleConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAutoscaleConfiguration.

type ApplicationGatewayAvailableSSLOptions 

type ApplicationGatewayAvailableSSLOptions struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Properties of the application gateway available SSL options.
	Properties *ApplicationGatewayAvailableSSLOptionsPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ApplicationGatewayAvailableSSLOptions - Response for ApplicationGatewayAvailableSslOptions API service call.

func (ApplicationGatewayAvailableSSLOptions) MarshalJSON 

func (a ApplicationGatewayAvailableSSLOptions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAvailableSSLOptions.

func (*ApplicationGatewayAvailableSSLOptions) UnmarshalJSON 

func (a *ApplicationGatewayAvailableSSLOptions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAvailableSSLOptions.

type ApplicationGatewayAvailableSSLOptionsPropertiesFormat 

type ApplicationGatewayAvailableSSLOptionsPropertiesFormat struct {
	// List of available Ssl cipher suites.
	AvailableCipherSuites []*ApplicationGatewaySSLCipherSuite

	// List of available Ssl protocols.
	AvailableProtocols []*ApplicationGatewaySSLProtocol

	// Name of the Ssl predefined policy applied by default to application gateway.
	DefaultPolicy *ApplicationGatewaySSLPolicyName

	// List of available Ssl predefined policy.
	PredefinedPolicies []*SubResource
}

ApplicationGatewayAvailableSSLOptionsPropertiesFormat - Properties of ApplicationGatewayAvailableSslOptions.

func (ApplicationGatewayAvailableSSLOptionsPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayAvailableSSLOptionsPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAvailableSSLOptionsPropertiesFormat.

func (*ApplicationGatewayAvailableSSLOptionsPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayAvailableSSLOptionsPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAvailableSSLOptionsPropertiesFormat.

type ApplicationGatewayAvailableSSLPredefinedPolicies 

type ApplicationGatewayAvailableSSLPredefinedPolicies struct {
	// URL to get the next set of results.
	NextLink *string

	// List of available Ssl predefined policy.
	Value []*ApplicationGatewaySSLPredefinedPolicy
}

ApplicationGatewayAvailableSSLPredefinedPolicies - Response for ApplicationGatewayAvailableSslOptions API service call.

func (ApplicationGatewayAvailableSSLPredefinedPolicies) MarshalJSON 

func (a ApplicationGatewayAvailableSSLPredefinedPolicies) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAvailableSSLPredefinedPolicies.

func (*ApplicationGatewayAvailableSSLPredefinedPolicies) UnmarshalJSON 

func (a *ApplicationGatewayAvailableSSLPredefinedPolicies) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAvailableSSLPredefinedPolicies.

type ApplicationGatewayAvailableWafRuleSetsResult 

type ApplicationGatewayAvailableWafRuleSetsResult struct {
	// The list of application gateway rule sets.
	Value []*ApplicationGatewayFirewallRuleSet
}

ApplicationGatewayAvailableWafRuleSetsResult - Response for ApplicationGatewayAvailableWafRuleSets API service call.

func (ApplicationGatewayAvailableWafRuleSetsResult) MarshalJSON 

func (a ApplicationGatewayAvailableWafRuleSetsResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayAvailableWafRuleSetsResult.

func (*ApplicationGatewayAvailableWafRuleSetsResult) UnmarshalJSON 

func (a *ApplicationGatewayAvailableWafRuleSetsResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayAvailableWafRuleSetsResult.

type ApplicationGatewayBackendAddress 

type ApplicationGatewayBackendAddress struct {
	// Fully qualified domain name (FQDN).
	Fqdn *string

	// IP address.
	IPAddress *string
}

ApplicationGatewayBackendAddress - Backend address of an application gateway.

func (ApplicationGatewayBackendAddress) MarshalJSON 

func (a ApplicationGatewayBackendAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendAddress.

func (*ApplicationGatewayBackendAddress) UnmarshalJSON 

func (a *ApplicationGatewayBackendAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendAddress.

type ApplicationGatewayBackendAddressPool 

type ApplicationGatewayBackendAddressPool struct {
	// Resource ID.
	ID *string

	// Name of the backend address pool that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway backend address pool.
	Properties *ApplicationGatewayBackendAddressPoolPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayBackendAddressPool - Backend Address Pool of an application gateway.

func (ApplicationGatewayBackendAddressPool) MarshalJSON 

func (a ApplicationGatewayBackendAddressPool) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendAddressPool.

func (*ApplicationGatewayBackendAddressPool) UnmarshalJSON 

func (a *ApplicationGatewayBackendAddressPool) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendAddressPool.

type ApplicationGatewayBackendAddressPoolPropertiesFormat 

type ApplicationGatewayBackendAddressPoolPropertiesFormat struct {
	// Backend addresses.
	BackendAddresses []*ApplicationGatewayBackendAddress

	// READ-ONLY; Collection of references to IPs defined in network interfaces.
	BackendIPConfigurations []*InterfaceIPConfiguration

	// READ-ONLY; The provisioning state of the backend address pool resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayBackendAddressPoolPropertiesFormat - Properties of Backend Address Pool of an application gateway.

func (ApplicationGatewayBackendAddressPoolPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayBackendAddressPoolPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendAddressPoolPropertiesFormat.

func (*ApplicationGatewayBackendAddressPoolPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayBackendAddressPoolPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendAddressPoolPropertiesFormat.

type ApplicationGatewayBackendHTTPSettings 

type ApplicationGatewayBackendHTTPSettings struct {
	// Resource ID.
	ID *string

	// Name of the backend http settings that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway backend HTTP settings.
	Properties *ApplicationGatewayBackendHTTPSettingsPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayBackendHTTPSettings - Backend address pool settings of an application gateway.

func (ApplicationGatewayBackendHTTPSettings) MarshalJSON 

func (a ApplicationGatewayBackendHTTPSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHTTPSettings.

func (*ApplicationGatewayBackendHTTPSettings) UnmarshalJSON 

func (a *ApplicationGatewayBackendHTTPSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHTTPSettings.

type ApplicationGatewayBackendHTTPSettingsPropertiesFormat 

type ApplicationGatewayBackendHTTPSettingsPropertiesFormat struct {
	// Cookie name to use for the affinity cookie.
	AffinityCookieName *string

	// Array of references to application gateway authentication certificates.
	AuthenticationCertificates []*SubResource

	// Connection draining of the backend http settings resource.
	ConnectionDraining *ApplicationGatewayConnectionDraining

	// Cookie based affinity.
	CookieBasedAffinity *ApplicationGatewayCookieBasedAffinity

	// Host header to be sent to the backend servers.
	HostName *string

	// Path which should be used as a prefix for all HTTP requests. Null means no path will be prefixed. Default value is null.
	Path *string

	// Whether to pick host header should be picked from the host name of the backend server. Default value is false.
	PickHostNameFromBackendAddress *bool

	// The destination port on the backend.
	Port *int32

	// Probe resource of an application gateway.
	Probe *SubResource

	// Whether the probe is enabled. Default value is false.
	ProbeEnabled *bool

	// The protocol used to communicate with the backend.
	Protocol *ApplicationGatewayProtocol

	// Request timeout in seconds. Application Gateway will fail the request if response is not received within RequestTimeout.
	// Acceptable values are from 1 second to 86400 seconds.
	RequestTimeout *int32

	// Array of references to application gateway trusted root certificates.
	TrustedRootCertificates []*SubResource

	// READ-ONLY; The provisioning state of the backend HTTP settings resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayBackendHTTPSettingsPropertiesFormat - Properties of Backend address pool settings of an application gateway.

func (ApplicationGatewayBackendHTTPSettingsPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayBackendHTTPSettingsPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHTTPSettingsPropertiesFormat.

func (*ApplicationGatewayBackendHTTPSettingsPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayBackendHTTPSettingsPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHTTPSettingsPropertiesFormat.

type ApplicationGatewayBackendHealth 

type ApplicationGatewayBackendHealth struct {
	// A list of ApplicationGatewayBackendHealthPool resources.
	BackendAddressPools []*ApplicationGatewayBackendHealthPool
}

ApplicationGatewayBackendHealth - Response for ApplicationGatewayBackendHealth API service call.

func (ApplicationGatewayBackendHealth) MarshalJSON 

func (a ApplicationGatewayBackendHealth) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHealth.

func (*ApplicationGatewayBackendHealth) UnmarshalJSON 

func (a *ApplicationGatewayBackendHealth) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHealth.

type ApplicationGatewayBackendHealthHTTPSettings 

type ApplicationGatewayBackendHealthHTTPSettings struct {
	// Reference to an ApplicationGatewayBackendHttpSettings resource.
	BackendHTTPSettings *ApplicationGatewayBackendHTTPSettings

	// List of ApplicationGatewayBackendHealthServer resources.
	Servers []*ApplicationGatewayBackendHealthServer
}

ApplicationGatewayBackendHealthHTTPSettings - Application gateway BackendHealthHttp settings.

func (ApplicationGatewayBackendHealthHTTPSettings) MarshalJSON 

func (a ApplicationGatewayBackendHealthHTTPSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHealthHTTPSettings.

func (*ApplicationGatewayBackendHealthHTTPSettings) UnmarshalJSON 

func (a *ApplicationGatewayBackendHealthHTTPSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHealthHTTPSettings.

type ApplicationGatewayBackendHealthOnDemand 

type ApplicationGatewayBackendHealthOnDemand struct {
	// Reference to an ApplicationGatewayBackendAddressPool resource.
	BackendAddressPool *ApplicationGatewayBackendAddressPool

	// Application gateway BackendHealthHttp settings.
	BackendHealthHTTPSettings *ApplicationGatewayBackendHealthHTTPSettings
}

ApplicationGatewayBackendHealthOnDemand - Result of on demand test probe.

func (ApplicationGatewayBackendHealthOnDemand) MarshalJSON 

func (a ApplicationGatewayBackendHealthOnDemand) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHealthOnDemand.

func (*ApplicationGatewayBackendHealthOnDemand) UnmarshalJSON 

func (a *ApplicationGatewayBackendHealthOnDemand) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHealthOnDemand.

type ApplicationGatewayBackendHealthPool 

type ApplicationGatewayBackendHealthPool struct {
	// Reference to an ApplicationGatewayBackendAddressPool resource.
	BackendAddressPool *ApplicationGatewayBackendAddressPool

	// List of ApplicationGatewayBackendHealthHttpSettings resources.
	BackendHTTPSettingsCollection []*ApplicationGatewayBackendHealthHTTPSettings
}

ApplicationGatewayBackendHealthPool - Application gateway BackendHealth pool.

func (ApplicationGatewayBackendHealthPool) MarshalJSON 

func (a ApplicationGatewayBackendHealthPool) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHealthPool.

func (*ApplicationGatewayBackendHealthPool) UnmarshalJSON 

func (a *ApplicationGatewayBackendHealthPool) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHealthPool.

type ApplicationGatewayBackendHealthServer 

type ApplicationGatewayBackendHealthServer struct {
	// IP address or FQDN of backend server.
	Address *string

	// Health of backend server.
	Health *ApplicationGatewayBackendHealthServerHealth

	// Health Probe Log.
	HealthProbeLog *string

	// Reference to IP configuration of backend server.
	IPConfiguration *InterfaceIPConfiguration
}

ApplicationGatewayBackendHealthServer - Application gateway backendhealth http settings.

func (ApplicationGatewayBackendHealthServer) MarshalJSON 

func (a ApplicationGatewayBackendHealthServer) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendHealthServer.

func (*ApplicationGatewayBackendHealthServer) UnmarshalJSON 

func (a *ApplicationGatewayBackendHealthServer) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendHealthServer.

type ApplicationGatewayBackendHealthServerHealth 

type ApplicationGatewayBackendHealthServerHealth string

ApplicationGatewayBackendHealthServerHealth - Health of backend server. 

const (
	ApplicationGatewayBackendHealthServerHealthDown     ApplicationGatewayBackendHealthServerHealth = "Down"
	ApplicationGatewayBackendHealthServerHealthDraining ApplicationGatewayBackendHealthServerHealth = "Draining"
	ApplicationGatewayBackendHealthServerHealthPartial  ApplicationGatewayBackendHealthServerHealth = "Partial"
	ApplicationGatewayBackendHealthServerHealthUnknown  ApplicationGatewayBackendHealthServerHealth = "Unknown"
	ApplicationGatewayBackendHealthServerHealthUp       ApplicationGatewayBackendHealthServerHealth = "Up"
)

func PossibleApplicationGatewayBackendHealthServerHealthValues 

func PossibleApplicationGatewayBackendHealthServerHealthValues() []ApplicationGatewayBackendHealthServerHealth

PossibleApplicationGatewayBackendHealthServerHealthValues returns the possible values for the ApplicationGatewayBackendHealthServerHealth const type.

type ApplicationGatewayBackendSettings 

type ApplicationGatewayBackendSettings struct {
	// Resource ID.
	ID *string

	// Name of the backend settings that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway backend settings.
	Properties *ApplicationGatewayBackendSettingsPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayBackendSettings - Backend address pool settings of an application gateway.

func (ApplicationGatewayBackendSettings) MarshalJSON 

func (a ApplicationGatewayBackendSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendSettings.

func (*ApplicationGatewayBackendSettings) UnmarshalJSON 

func (a *ApplicationGatewayBackendSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendSettings.

type ApplicationGatewayBackendSettingsPropertiesFormat 

type ApplicationGatewayBackendSettingsPropertiesFormat struct {
	// Server name indication to be sent to the backend servers for Tls protocol.
	HostName *string

	// Whether to pick server name indication from the host name of the backend server for Tls protocol. Default value is false.
	PickHostNameFromBackendAddress *bool

	// The destination port on the backend.
	Port *int32

	// Probe resource of an application gateway.
	Probe *SubResource

	// The protocol used to communicate with the backend.
	Protocol *ApplicationGatewayProtocol

	// Connection timeout in seconds. Application Gateway will fail the request if response is not received within ConnectionTimeout.
	// Acceptable values are from 1 second to 86400 seconds.
	Timeout *int32

	// Array of references to application gateway trusted root certificates.
	TrustedRootCertificates []*SubResource

	// READ-ONLY; The provisioning state of the backend HTTP settings resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayBackendSettingsPropertiesFormat - Properties of Backend address pool settings of an application gateway.

func (ApplicationGatewayBackendSettingsPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayBackendSettingsPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayBackendSettingsPropertiesFormat.

func (*ApplicationGatewayBackendSettingsPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayBackendSettingsPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayBackendSettingsPropertiesFormat.

type ApplicationGatewayClientAuthConfiguration 

type ApplicationGatewayClientAuthConfiguration struct {
	// Verify client certificate issuer name on the application gateway.
	VerifyClientCertIssuerDN *bool

	// Verify client certificate revocation status.
	VerifyClientRevocation *ApplicationGatewayClientRevocationOptions
}

ApplicationGatewayClientAuthConfiguration - Application gateway client authentication configuration.

func (ApplicationGatewayClientAuthConfiguration) MarshalJSON 

func (a ApplicationGatewayClientAuthConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayClientAuthConfiguration.

func (*ApplicationGatewayClientAuthConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayClientAuthConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayClientAuthConfiguration.

type ApplicationGatewayClientRevocationOptions 

type ApplicationGatewayClientRevocationOptions string

ApplicationGatewayClientRevocationOptions - Verify client certificate revocation status. 

const (
	ApplicationGatewayClientRevocationOptionsNone ApplicationGatewayClientRevocationOptions = "None"
	ApplicationGatewayClientRevocationOptionsOCSP ApplicationGatewayClientRevocationOptions = "OCSP"
)

func PossibleApplicationGatewayClientRevocationOptionsValues 

func PossibleApplicationGatewayClientRevocationOptionsValues() []ApplicationGatewayClientRevocationOptions

PossibleApplicationGatewayClientRevocationOptionsValues returns the possible values for the ApplicationGatewayClientRevocationOptions const type.

type ApplicationGatewayConnectionDraining 

type ApplicationGatewayConnectionDraining struct {
	// REQUIRED; The number of seconds connection draining is active. Acceptable values are from 1 second to 3600 seconds.
	DrainTimeoutInSec *int32

	// REQUIRED; Whether connection draining is enabled or not.
	Enabled *bool
}

ApplicationGatewayConnectionDraining - Connection draining allows open connections to a backend server to be active for a specified time after the backend server got removed from the configuration.

func (ApplicationGatewayConnectionDraining) MarshalJSON 

func (a ApplicationGatewayConnectionDraining) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayConnectionDraining.

func (*ApplicationGatewayConnectionDraining) UnmarshalJSON 

func (a *ApplicationGatewayConnectionDraining) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayConnectionDraining.

type ApplicationGatewayCookieBasedAffinity 

type ApplicationGatewayCookieBasedAffinity string

ApplicationGatewayCookieBasedAffinity - Cookie based affinity. 

const (
	ApplicationGatewayCookieBasedAffinityDisabled ApplicationGatewayCookieBasedAffinity = "Disabled"
	ApplicationGatewayCookieBasedAffinityEnabled  ApplicationGatewayCookieBasedAffinity = "Enabled"
)

func PossibleApplicationGatewayCookieBasedAffinityValues 

func PossibleApplicationGatewayCookieBasedAffinityValues() []ApplicationGatewayCookieBasedAffinity

PossibleApplicationGatewayCookieBasedAffinityValues returns the possible values for the ApplicationGatewayCookieBasedAffinity const type.

type ApplicationGatewayCustomError 

type ApplicationGatewayCustomError struct {
	// Error page URL of the application gateway custom error.
	CustomErrorPageURL *string

	// Status code of the application gateway custom error.
	StatusCode *ApplicationGatewayCustomErrorStatusCode
}

ApplicationGatewayCustomError - Custom error of an application gateway.

func (ApplicationGatewayCustomError) MarshalJSON 

func (a ApplicationGatewayCustomError) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayCustomError.

func (*ApplicationGatewayCustomError) UnmarshalJSON 

func (a *ApplicationGatewayCustomError) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayCustomError.

type ApplicationGatewayCustomErrorStatusCode 

type ApplicationGatewayCustomErrorStatusCode string

ApplicationGatewayCustomErrorStatusCode - Status code of the application gateway custom error. 

const (
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus400 ApplicationGatewayCustomErrorStatusCode = "HttpStatus400"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus403 ApplicationGatewayCustomErrorStatusCode = "HttpStatus403"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus404 ApplicationGatewayCustomErrorStatusCode = "HttpStatus404"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus405 ApplicationGatewayCustomErrorStatusCode = "HttpStatus405"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus408 ApplicationGatewayCustomErrorStatusCode = "HttpStatus408"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus500 ApplicationGatewayCustomErrorStatusCode = "HttpStatus500"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus502 ApplicationGatewayCustomErrorStatusCode = "HttpStatus502"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus503 ApplicationGatewayCustomErrorStatusCode = "HttpStatus503"
	ApplicationGatewayCustomErrorStatusCodeHTTPStatus504 ApplicationGatewayCustomErrorStatusCode = "HttpStatus504"
)

func PossibleApplicationGatewayCustomErrorStatusCodeValues 

func PossibleApplicationGatewayCustomErrorStatusCodeValues() []ApplicationGatewayCustomErrorStatusCode

PossibleApplicationGatewayCustomErrorStatusCodeValues returns the possible values for the ApplicationGatewayCustomErrorStatusCode const type.

type ApplicationGatewayFirewallDisabledRuleGroup 

type ApplicationGatewayFirewallDisabledRuleGroup struct {
	// REQUIRED; The name of the rule group that will be disabled.
	RuleGroupName *string

	// The list of rules that will be disabled. If null, all rules of the rule group will be disabled.
	Rules []*int32
}

ApplicationGatewayFirewallDisabledRuleGroup - Allows to disable rules within a rule group or an entire rule group.

func (ApplicationGatewayFirewallDisabledRuleGroup) MarshalJSON 

func (a ApplicationGatewayFirewallDisabledRuleGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallDisabledRuleGroup.

func (*ApplicationGatewayFirewallDisabledRuleGroup) UnmarshalJSON 

func (a *ApplicationGatewayFirewallDisabledRuleGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallDisabledRuleGroup.

type ApplicationGatewayFirewallExclusion 

type ApplicationGatewayFirewallExclusion struct {
	// REQUIRED; The variable to be excluded.
	MatchVariable *string

	// REQUIRED; When matchVariable is a collection, operator used to specify which elements in the collection this exclusion
	// applies to.
	Selector *string

	// REQUIRED; When matchVariable is a collection, operate on the selector to specify which elements in the collection this
	// exclusion applies to.
	SelectorMatchOperator *string
}

ApplicationGatewayFirewallExclusion - Allow to exclude some variable satisfy the condition for the WAF check.

func (ApplicationGatewayFirewallExclusion) MarshalJSON 

func (a ApplicationGatewayFirewallExclusion) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallExclusion.

func (*ApplicationGatewayFirewallExclusion) UnmarshalJSON 

func (a *ApplicationGatewayFirewallExclusion) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallExclusion.

type ApplicationGatewayFirewallManifestRuleSet 

type ApplicationGatewayFirewallManifestRuleSet struct {
	// REQUIRED; The rule groups of the web application firewall rule set.
	RuleGroups []*ApplicationGatewayFirewallRuleGroup

	// REQUIRED; The type of the web application firewall rule set.
	RuleSetType *string

	// REQUIRED; The version of the web application firewall rule set type.
	RuleSetVersion *string

	// The rule set status
	Status *ApplicationGatewayRuleSetStatusOptions

	// Tier of an application gateway that support the rule set.
	Tiers []*ApplicationGatewayTierTypes
}

ApplicationGatewayFirewallManifestRuleSet - Properties of the web application firewall rule set.

func (ApplicationGatewayFirewallManifestRuleSet) MarshalJSON 

func (a ApplicationGatewayFirewallManifestRuleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallManifestRuleSet.

func (*ApplicationGatewayFirewallManifestRuleSet) UnmarshalJSON 

func (a *ApplicationGatewayFirewallManifestRuleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallManifestRuleSet.

type ApplicationGatewayFirewallMode 

type ApplicationGatewayFirewallMode string

ApplicationGatewayFirewallMode - Web application firewall mode. 

const (
	ApplicationGatewayFirewallModeDetection  ApplicationGatewayFirewallMode = "Detection"
	ApplicationGatewayFirewallModePrevention ApplicationGatewayFirewallMode = "Prevention"
)

func PossibleApplicationGatewayFirewallModeValues 

func PossibleApplicationGatewayFirewallModeValues() []ApplicationGatewayFirewallMode

PossibleApplicationGatewayFirewallModeValues returns the possible values for the ApplicationGatewayFirewallMode const type.

type ApplicationGatewayFirewallRateLimitDuration 

type ApplicationGatewayFirewallRateLimitDuration string

ApplicationGatewayFirewallRateLimitDuration - Duration over which Rate Limit policy will be applied. Applies only when ruleType is RateLimitRule. 

const (
	ApplicationGatewayFirewallRateLimitDurationFiveMins ApplicationGatewayFirewallRateLimitDuration = "FiveMins"
	ApplicationGatewayFirewallRateLimitDurationOneMin   ApplicationGatewayFirewallRateLimitDuration = "OneMin"
)

func PossibleApplicationGatewayFirewallRateLimitDurationValues 

func PossibleApplicationGatewayFirewallRateLimitDurationValues() []ApplicationGatewayFirewallRateLimitDuration

PossibleApplicationGatewayFirewallRateLimitDurationValues returns the possible values for the ApplicationGatewayFirewallRateLimitDuration const type.

type ApplicationGatewayFirewallRule 

type ApplicationGatewayFirewallRule struct {
	// REQUIRED; The identifier of the web application firewall rule.
	RuleID *int32

	// The string representation of the web application firewall rule action.
	Action *ApplicationGatewayWafRuleActionTypes

	// The description of the web application firewall rule.
	Description *string

	// The string representation of the web application firewall rule identifier.
	RuleIDString *string

	// The string representation of the web application firewall rule sensitivity.
	Sensitivity *ApplicationGatewayWafRuleSensitivityTypes

	// The string representation of the web application firewall rule state.
	State *ApplicationGatewayWafRuleStateTypes
}

ApplicationGatewayFirewallRule - A web application firewall rule.

func (ApplicationGatewayFirewallRule) MarshalJSON 

func (a ApplicationGatewayFirewallRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallRule.

func (*ApplicationGatewayFirewallRule) UnmarshalJSON 

func (a *ApplicationGatewayFirewallRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallRule.

type ApplicationGatewayFirewallRuleGroup 

type ApplicationGatewayFirewallRuleGroup struct {
	// REQUIRED; The name of the web application firewall rule group.
	RuleGroupName *string

	// REQUIRED; The rules of the web application firewall rule group.
	Rules []*ApplicationGatewayFirewallRule

	// The description of the web application firewall rule group.
	Description *string
}

ApplicationGatewayFirewallRuleGroup - A web application firewall rule group.

func (ApplicationGatewayFirewallRuleGroup) MarshalJSON 

func (a ApplicationGatewayFirewallRuleGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallRuleGroup.

func (*ApplicationGatewayFirewallRuleGroup) UnmarshalJSON 

func (a *ApplicationGatewayFirewallRuleGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallRuleGroup.

type ApplicationGatewayFirewallRuleSet 

type ApplicationGatewayFirewallRuleSet struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Properties of the application gateway firewall rule set.
	Properties *ApplicationGatewayFirewallRuleSetPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ApplicationGatewayFirewallRuleSet - A web application firewall rule set.

func (ApplicationGatewayFirewallRuleSet) MarshalJSON 

func (a ApplicationGatewayFirewallRuleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallRuleSet.

func (*ApplicationGatewayFirewallRuleSet) UnmarshalJSON 

func (a *ApplicationGatewayFirewallRuleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallRuleSet.

type ApplicationGatewayFirewallRuleSetPropertiesFormat 

type ApplicationGatewayFirewallRuleSetPropertiesFormat struct {
	// REQUIRED; The rule groups of the web application firewall rule set.
	RuleGroups []*ApplicationGatewayFirewallRuleGroup

	// REQUIRED; The type of the web application firewall rule set.
	RuleSetType *string

	// REQUIRED; The version of the web application firewall rule set type.
	RuleSetVersion *string

	// Tier of an application gateway that support the rule set.
	Tiers []*ApplicationGatewayTierTypes

	// READ-ONLY; The provisioning state of the web application firewall rule set.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayFirewallRuleSetPropertiesFormat - Properties of the web application firewall rule set.

func (ApplicationGatewayFirewallRuleSetPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayFirewallRuleSetPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFirewallRuleSetPropertiesFormat.

func (*ApplicationGatewayFirewallRuleSetPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayFirewallRuleSetPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFirewallRuleSetPropertiesFormat.

type ApplicationGatewayFirewallUserSessionVariable 

type ApplicationGatewayFirewallUserSessionVariable string

ApplicationGatewayFirewallUserSessionVariable - User Session clause variable. 

const (
	ApplicationGatewayFirewallUserSessionVariableClientAddr  ApplicationGatewayFirewallUserSessionVariable = "ClientAddr"
	ApplicationGatewayFirewallUserSessionVariableGeoLocation ApplicationGatewayFirewallUserSessionVariable = "GeoLocation"
	ApplicationGatewayFirewallUserSessionVariableNone        ApplicationGatewayFirewallUserSessionVariable = "None"
)

func PossibleApplicationGatewayFirewallUserSessionVariableValues 

func PossibleApplicationGatewayFirewallUserSessionVariableValues() []ApplicationGatewayFirewallUserSessionVariable

PossibleApplicationGatewayFirewallUserSessionVariableValues returns the possible values for the ApplicationGatewayFirewallUserSessionVariable const type.

type ApplicationGatewayForContainersReferenceDefinition 

type ApplicationGatewayForContainersReferenceDefinition struct {
	// REQUIRED; Resource Id of the application gateway for containers.
	ID *string
}

ApplicationGatewayForContainersReferenceDefinition - Defines an application gateway for containers reference.

func (ApplicationGatewayForContainersReferenceDefinition) MarshalJSON 

func (a ApplicationGatewayForContainersReferenceDefinition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayForContainersReferenceDefinition.

func (*ApplicationGatewayForContainersReferenceDefinition) UnmarshalJSON 

func (a *ApplicationGatewayForContainersReferenceDefinition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayForContainersReferenceDefinition.

type ApplicationGatewayFrontendIPConfiguration 

type ApplicationGatewayFrontendIPConfiguration struct {
	// Resource ID.
	ID *string

	// Name of the frontend IP configuration that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway frontend IP configuration.
	Properties *ApplicationGatewayFrontendIPConfigurationPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayFrontendIPConfiguration - Frontend IP configuration of an application gateway.

func (ApplicationGatewayFrontendIPConfiguration) MarshalJSON 

func (a ApplicationGatewayFrontendIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFrontendIPConfiguration.

func (*ApplicationGatewayFrontendIPConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayFrontendIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFrontendIPConfiguration.

type ApplicationGatewayFrontendIPConfigurationPropertiesFormat 

type ApplicationGatewayFrontendIPConfigurationPropertiesFormat struct {
	// PrivateIPAddress of the network interface IP Configuration.
	PrivateIPAddress *string

	// The private IP address allocation method.
	PrivateIPAllocationMethod *IPAllocationMethod

	// Reference to the application gateway private link configuration.
	PrivateLinkConfiguration *SubResource

	// Reference to the PublicIP resource.
	PublicIPAddress *SubResource

	// Reference to the subnet resource.
	Subnet *SubResource

	// READ-ONLY; The provisioning state of the frontend IP configuration resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayFrontendIPConfigurationPropertiesFormat - Properties of Frontend IP configuration of an application gateway.

func (ApplicationGatewayFrontendIPConfigurationPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayFrontendIPConfigurationPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFrontendIPConfigurationPropertiesFormat.

func (*ApplicationGatewayFrontendIPConfigurationPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayFrontendIPConfigurationPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFrontendIPConfigurationPropertiesFormat.

type ApplicationGatewayFrontendPort 

type ApplicationGatewayFrontendPort struct {
	// Resource ID.
	ID *string

	// Name of the frontend port that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway frontend port.
	Properties *ApplicationGatewayFrontendPortPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayFrontendPort - Frontend port of an application gateway.

func (ApplicationGatewayFrontendPort) MarshalJSON 

func (a ApplicationGatewayFrontendPort) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFrontendPort.

func (*ApplicationGatewayFrontendPort) UnmarshalJSON 

func (a *ApplicationGatewayFrontendPort) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFrontendPort.

type ApplicationGatewayFrontendPortPropertiesFormat 

type ApplicationGatewayFrontendPortPropertiesFormat struct {
	// Frontend port.
	Port *int32

	// READ-ONLY; The provisioning state of the frontend port resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayFrontendPortPropertiesFormat - Properties of Frontend port of an application gateway.

func (ApplicationGatewayFrontendPortPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayFrontendPortPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayFrontendPortPropertiesFormat.

func (*ApplicationGatewayFrontendPortPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayFrontendPortPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayFrontendPortPropertiesFormat.

type ApplicationGatewayGlobalConfiguration 

type ApplicationGatewayGlobalConfiguration struct {
	// Enable request buffering.
	EnableRequestBuffering *bool

	// Enable response buffering.
	EnableResponseBuffering *bool
}

ApplicationGatewayGlobalConfiguration - Application Gateway global configuration.

func (ApplicationGatewayGlobalConfiguration) MarshalJSON 

func (a ApplicationGatewayGlobalConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayGlobalConfiguration.

func (*ApplicationGatewayGlobalConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayGlobalConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayGlobalConfiguration.

type ApplicationGatewayHTTPListener 

type ApplicationGatewayHTTPListener struct {
	// Resource ID.
	ID *string

	// Name of the HTTP listener that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway HTTP listener.
	Properties *ApplicationGatewayHTTPListenerPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayHTTPListener - Http listener of an application gateway.

func (ApplicationGatewayHTTPListener) MarshalJSON 

func (a ApplicationGatewayHTTPListener) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayHTTPListener.

func (*ApplicationGatewayHTTPListener) UnmarshalJSON 

func (a *ApplicationGatewayHTTPListener) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayHTTPListener.

type ApplicationGatewayHTTPListenerPropertiesFormat 

type ApplicationGatewayHTTPListenerPropertiesFormat struct {
	// Custom error configurations of the HTTP listener.
	CustomErrorConfigurations []*ApplicationGatewayCustomError

	// Reference to the FirewallPolicy resource.
	FirewallPolicy *SubResource

	// Frontend IP configuration resource of an application gateway.
	FrontendIPConfiguration *SubResource

	// Frontend port resource of an application gateway.
	FrontendPort *SubResource

	// Host name of HTTP listener.
	HostName *string

	// List of Host names for HTTP Listener that allows special wildcard characters as well.
	HostNames []*string

	// Protocol of the HTTP listener.
	Protocol *ApplicationGatewayProtocol

	// Applicable only if protocol is https. Enables SNI for multi-hosting.
	RequireServerNameIndication *bool

	// SSL certificate resource of an application gateway.
	SSLCertificate *SubResource

	// SSL profile resource of the application gateway.
	SSLProfile *SubResource

	// READ-ONLY; The provisioning state of the HTTP listener resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayHTTPListenerPropertiesFormat - Properties of HTTP listener of an application gateway.

func (ApplicationGatewayHTTPListenerPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayHTTPListenerPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayHTTPListenerPropertiesFormat.

func (*ApplicationGatewayHTTPListenerPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayHTTPListenerPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayHTTPListenerPropertiesFormat.

type ApplicationGatewayHeaderConfiguration 

type ApplicationGatewayHeaderConfiguration struct {
	// Header name of the header configuration.
	HeaderName *string

	// Header value of the header configuration.
	HeaderValue *string

	// An optional field under "Rewrite Action". It lets you capture and modify the value(s) of a specific header when multiple
	// headers with the same name exist. Currently supported for Set-Cookie Response
	// header only. For more details, visit https://aka.ms/appgwheadercrud
	HeaderValueMatcher *HeaderValueMatcher
}

ApplicationGatewayHeaderConfiguration - Header configuration of the Actions set in Application Gateway.

func (ApplicationGatewayHeaderConfiguration) MarshalJSON 

func (a ApplicationGatewayHeaderConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayHeaderConfiguration.

func (*ApplicationGatewayHeaderConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayHeaderConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayHeaderConfiguration.

type ApplicationGatewayIPConfiguration 

type ApplicationGatewayIPConfiguration struct {
	// Resource ID.
	ID *string

	// Name of the IP configuration that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway IP configuration.
	Properties *ApplicationGatewayIPConfigurationPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayIPConfiguration - IP configuration of an application gateway. Currently 1 public and 1 private IP configuration is allowed.

func (ApplicationGatewayIPConfiguration) MarshalJSON 

func (a ApplicationGatewayIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayIPConfiguration.

func (*ApplicationGatewayIPConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayIPConfiguration.

type ApplicationGatewayIPConfigurationPropertiesFormat 

type ApplicationGatewayIPConfigurationPropertiesFormat struct {
	// Reference to the subnet resource. A subnet from where application gateway gets its private address.
	Subnet *SubResource

	// READ-ONLY; The provisioning state of the application gateway IP configuration resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayIPConfigurationPropertiesFormat - Properties of IP configuration of an application gateway.

func (ApplicationGatewayIPConfigurationPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayIPConfigurationPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayIPConfigurationPropertiesFormat.

func (*ApplicationGatewayIPConfigurationPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayIPConfigurationPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayIPConfigurationPropertiesFormat.

type ApplicationGatewayListResult 

type ApplicationGatewayListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of an application gateways in a resource group.
	Value []*ApplicationGateway
}

ApplicationGatewayListResult - Response for ListApplicationGateways API service call.

func (ApplicationGatewayListResult) MarshalJSON 

func (a ApplicationGatewayListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayListResult.

func (*ApplicationGatewayListResult) UnmarshalJSON 

func (a *ApplicationGatewayListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayListResult.

type ApplicationGatewayListener 

type ApplicationGatewayListener struct {
	// Resource ID.
	ID *string

	// Name of the listener that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway listener.
	Properties *ApplicationGatewayListenerPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayListener - Listener of an application gateway.

func (ApplicationGatewayListener) MarshalJSON 

func (a ApplicationGatewayListener) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayListener.

func (*ApplicationGatewayListener) UnmarshalJSON 

func (a *ApplicationGatewayListener) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayListener.

type ApplicationGatewayListenerPropertiesFormat 

type ApplicationGatewayListenerPropertiesFormat struct {
	// Frontend IP configuration resource of an application gateway.
	FrontendIPConfiguration *SubResource

	// Frontend port resource of an application gateway.
	FrontendPort *SubResource

	// List of Server Name Indications(SNI) for TLS Multi-site Listener that allows special wildcard characters as well.
	HostNames []*string

	// Protocol of the listener.
	Protocol *ApplicationGatewayProtocol

	// SSL certificate resource of an application gateway.
	SSLCertificate *SubResource

	// SSL profile resource of the application gateway.
	SSLProfile *SubResource

	// READ-ONLY; The provisioning state of the listener resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayListenerPropertiesFormat - Properties of listener of an application gateway.

func (ApplicationGatewayListenerPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayListenerPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayListenerPropertiesFormat.

func (*ApplicationGatewayListenerPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayListenerPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayListenerPropertiesFormat.

type ApplicationGatewayLoadDistributionAlgorithm 

type ApplicationGatewayLoadDistributionAlgorithm string

ApplicationGatewayLoadDistributionAlgorithm - Load Distribution Algorithm enums. 

const (
	ApplicationGatewayLoadDistributionAlgorithmIPHash           ApplicationGatewayLoadDistributionAlgorithm = "IpHash"
	ApplicationGatewayLoadDistributionAlgorithmLeastConnections ApplicationGatewayLoadDistributionAlgorithm = "LeastConnections"
	ApplicationGatewayLoadDistributionAlgorithmRoundRobin       ApplicationGatewayLoadDistributionAlgorithm = "RoundRobin"
)

func PossibleApplicationGatewayLoadDistributionAlgorithmValues 

func PossibleApplicationGatewayLoadDistributionAlgorithmValues() []ApplicationGatewayLoadDistributionAlgorithm

PossibleApplicationGatewayLoadDistributionAlgorithmValues returns the possible values for the ApplicationGatewayLoadDistributionAlgorithm const type.

type ApplicationGatewayLoadDistributionPolicy 

type ApplicationGatewayLoadDistributionPolicy struct {
	// Resource ID.
	ID *string

	// Name of the load distribution policy that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway load distribution policy.
	Properties *ApplicationGatewayLoadDistributionPolicyPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayLoadDistributionPolicy - Load Distribution Policy of an application gateway.

func (ApplicationGatewayLoadDistributionPolicy) MarshalJSON 

func (a ApplicationGatewayLoadDistributionPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayLoadDistributionPolicy.

func (*ApplicationGatewayLoadDistributionPolicy) UnmarshalJSON 

func (a *ApplicationGatewayLoadDistributionPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayLoadDistributionPolicy.

type ApplicationGatewayLoadDistributionPolicyPropertiesFormat 

type ApplicationGatewayLoadDistributionPolicyPropertiesFormat struct {
	// Load Distribution Targets resource of an application gateway.
	LoadDistributionAlgorithm *ApplicationGatewayLoadDistributionAlgorithm

	// Load Distribution Targets resource of an application gateway.
	LoadDistributionTargets []*ApplicationGatewayLoadDistributionTarget

	// READ-ONLY; The provisioning state of the Load Distribution Policy resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayLoadDistributionPolicyPropertiesFormat - Properties of Load Distribution Policy of an application gateway.

func (ApplicationGatewayLoadDistributionPolicyPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayLoadDistributionPolicyPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayLoadDistributionPolicyPropertiesFormat.

func (*ApplicationGatewayLoadDistributionPolicyPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayLoadDistributionPolicyPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayLoadDistributionPolicyPropertiesFormat.

type ApplicationGatewayLoadDistributionTarget 

type ApplicationGatewayLoadDistributionTarget struct {
	// Resource ID.
	ID *string

	// Name of the load distribution policy that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway load distribution target.
	Properties *ApplicationGatewayLoadDistributionTargetPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayLoadDistributionTarget - Load Distribution Target of an application gateway.

func (ApplicationGatewayLoadDistributionTarget) MarshalJSON 

func (a ApplicationGatewayLoadDistributionTarget) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayLoadDistributionTarget.

func (*ApplicationGatewayLoadDistributionTarget) UnmarshalJSON 

func (a *ApplicationGatewayLoadDistributionTarget) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayLoadDistributionTarget.

type ApplicationGatewayLoadDistributionTargetPropertiesFormat 

type ApplicationGatewayLoadDistributionTargetPropertiesFormat struct {
	// Backend address pool resource of the application gateway.
	BackendAddressPool *SubResource

	// Weight per server. Range between 1 and 100.
	WeightPerServer *int32
}

func (ApplicationGatewayLoadDistributionTargetPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayLoadDistributionTargetPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayLoadDistributionTargetPropertiesFormat.

func (*ApplicationGatewayLoadDistributionTargetPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayLoadDistributionTargetPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayLoadDistributionTargetPropertiesFormat.

type ApplicationGatewayOnDemandProbe 

type ApplicationGatewayOnDemandProbe struct {
	// Reference to backend pool of application gateway to which probe request will be sent.
	BackendAddressPool *SubResource

	// Reference to backend http setting of application gateway to be used for test probe.
	BackendHTTPSettings *SubResource

	// Host name to send the probe to.
	Host *string

	// Criterion for classifying a healthy probe response.
	Match *ApplicationGatewayProbeHealthResponseMatch

	// Relative path of probe. Valid path starts from '/'. Probe is sent to ://:.
	Path *string

	// Whether the host header should be picked from the backend http settings. Default value is false.
	PickHostNameFromBackendHTTPSettings *bool

	// The protocol used for the probe.
	Protocol *ApplicationGatewayProtocol

	// The probe timeout in seconds. Probe marked as failed if valid response is not received with this timeout period. Acceptable
	// values are from 1 second to 86400 seconds.
	Timeout *int32
}

ApplicationGatewayOnDemandProbe - Details of on demand test probe request.

func (ApplicationGatewayOnDemandProbe) MarshalJSON 

func (a ApplicationGatewayOnDemandProbe) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayOnDemandProbe.

func (*ApplicationGatewayOnDemandProbe) UnmarshalJSON 

func (a *ApplicationGatewayOnDemandProbe) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayOnDemandProbe.

type ApplicationGatewayOperationalState 

type ApplicationGatewayOperationalState string

ApplicationGatewayOperationalState - Operational state of the application gateway resource. 

const (
	ApplicationGatewayOperationalStateRunning  ApplicationGatewayOperationalState = "Running"
	ApplicationGatewayOperationalStateStarting ApplicationGatewayOperationalState = "Starting"
	ApplicationGatewayOperationalStateStopped  ApplicationGatewayOperationalState = "Stopped"
	ApplicationGatewayOperationalStateStopping ApplicationGatewayOperationalState = "Stopping"
)

func PossibleApplicationGatewayOperationalStateValues 

func PossibleApplicationGatewayOperationalStateValues() []ApplicationGatewayOperationalState

PossibleApplicationGatewayOperationalStateValues returns the possible values for the ApplicationGatewayOperationalState const type.

type ApplicationGatewayPathRule 

type ApplicationGatewayPathRule struct {
	// Resource ID.
	ID *string

	// Name of the path rule that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway path rule.
	Properties *ApplicationGatewayPathRulePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayPathRule - Path rule of URL path map of an application gateway.

func (ApplicationGatewayPathRule) MarshalJSON 

func (a ApplicationGatewayPathRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPathRule.

func (*ApplicationGatewayPathRule) UnmarshalJSON 

func (a *ApplicationGatewayPathRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPathRule.

type ApplicationGatewayPathRulePropertiesFormat 

type ApplicationGatewayPathRulePropertiesFormat struct {
	// Backend address pool resource of URL path map path rule.
	BackendAddressPool *SubResource

	// Backend http settings resource of URL path map path rule.
	BackendHTTPSettings *SubResource

	// Reference to the FirewallPolicy resource.
	FirewallPolicy *SubResource

	// Load Distribution Policy resource of URL path map path rule.
	LoadDistributionPolicy *SubResource

	// Path rules of URL path map.
	Paths []*string

	// Redirect configuration resource of URL path map path rule.
	RedirectConfiguration *SubResource

	// Rewrite rule set resource of URL path map path rule.
	RewriteRuleSet *SubResource

	// READ-ONLY; The provisioning state of the path rule resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayPathRulePropertiesFormat - Properties of path rule of an application gateway.

func (ApplicationGatewayPathRulePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayPathRulePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPathRulePropertiesFormat.

func (*ApplicationGatewayPathRulePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayPathRulePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPathRulePropertiesFormat.

type ApplicationGatewayPrivateEndpointConnection 

type ApplicationGatewayPrivateEndpointConnection struct {
	// Resource ID.
	ID *string

	// Name of the private endpoint connection on an application gateway.
	Name *string

	// Properties of the application gateway private endpoint connection.
	Properties *ApplicationGatewayPrivateEndpointConnectionProperties

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayPrivateEndpointConnection - Private Endpoint connection on an application gateway.

func (ApplicationGatewayPrivateEndpointConnection) MarshalJSON 

func (a ApplicationGatewayPrivateEndpointConnection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateEndpointConnection.

func (*ApplicationGatewayPrivateEndpointConnection) UnmarshalJSON 

func (a *ApplicationGatewayPrivateEndpointConnection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateEndpointConnection.

type ApplicationGatewayPrivateEndpointConnectionListResult 

type ApplicationGatewayPrivateEndpointConnectionListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of private endpoint connections on an application gateway.
	Value []*ApplicationGatewayPrivateEndpointConnection
}

ApplicationGatewayPrivateEndpointConnectionListResult - Response for ListApplicationGatewayPrivateEndpointConnection API service call. Gets all private endpoint connections for an application gateway.

func (ApplicationGatewayPrivateEndpointConnectionListResult) MarshalJSON 

func (a ApplicationGatewayPrivateEndpointConnectionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateEndpointConnectionListResult.

func (*ApplicationGatewayPrivateEndpointConnectionListResult) UnmarshalJSON 

func (a *ApplicationGatewayPrivateEndpointConnectionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateEndpointConnectionListResult.

type ApplicationGatewayPrivateEndpointConnectionProperties 

type ApplicationGatewayPrivateEndpointConnectionProperties struct {
	// A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState

	// READ-ONLY; The consumer link id.
	LinkIdentifier *string

	// READ-ONLY; The resource of private end point.
	PrivateEndpoint *PrivateEndpoint

	// READ-ONLY; The provisioning state of the application gateway private endpoint connection resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayPrivateEndpointConnectionProperties - Properties of Private Link Resource of an application gateway.

func (ApplicationGatewayPrivateEndpointConnectionProperties) MarshalJSON 

func (a ApplicationGatewayPrivateEndpointConnectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateEndpointConnectionProperties.

func (*ApplicationGatewayPrivateEndpointConnectionProperties) UnmarshalJSON 

func (a *ApplicationGatewayPrivateEndpointConnectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateEndpointConnectionProperties.

type ApplicationGatewayPrivateEndpointConnectionsClient 

type ApplicationGatewayPrivateEndpointConnectionsClient struct {
	// contains filtered or unexported fields
}

ApplicationGatewayPrivateEndpointConnectionsClient contains the methods for the ApplicationGatewayPrivateEndpointConnections group. Don't use this type directly, use NewApplicationGatewayPrivateEndpointConnectionsClient() instead.

func NewApplicationGatewayPrivateEndpointConnectionsClient 

func NewApplicationGatewayPrivateEndpointConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ApplicationGatewayPrivateEndpointConnectionsClient, error)

NewApplicationGatewayPrivateEndpointConnectionsClient creates a new instance of ApplicationGatewayPrivateEndpointConnectionsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ApplicationGatewayPrivateEndpointConnectionsClient) BeginDelete 

func (client *ApplicationGatewayPrivateEndpointConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, applicationGatewayName string, connectionName string, options *ApplicationGatewayPrivateEndpointConnectionsClientBeginDeleteOptions) (*runtime.Poller[ApplicationGatewayPrivateEndpointConnectionsClientDeleteResponse], error)

BeginDelete - Deletes the specified private endpoint connection on application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • connectionName - The name of the application gateway private endpoint connection.
  • options - ApplicationGatewayPrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayPrivateEndpointConnectionDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewayPrivateEndpointConnectionsClient().BeginDelete(ctx, "rg1", "appgw", "connection1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ApplicationGatewayPrivateEndpointConnectionsClient) BeginUpdate 

func (client *ApplicationGatewayPrivateEndpointConnectionsClient) BeginUpdate(ctx context.Context, resourceGroupName string, applicationGatewayName string, connectionName string, parameters ApplicationGatewayPrivateEndpointConnection, options *ApplicationGatewayPrivateEndpointConnectionsClientBeginUpdateOptions) (*runtime.Poller[ApplicationGatewayPrivateEndpointConnectionsClientUpdateResponse], error)

BeginUpdate - Updates the specified private endpoint connection on application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • connectionName - The name of the application gateway private endpoint connection.
  • parameters - Parameters supplied to update application gateway private endpoint connection operation.
  • options - ApplicationGatewayPrivateEndpointConnectionsClientBeginUpdateOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayPrivateEndpointConnectionUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewayPrivateEndpointConnectionsClient().BeginUpdate(ctx, "rg1", "appgw", "connection1", armnetwork.ApplicationGatewayPrivateEndpointConnection{
	Name: to.Ptr("connection1"),
	Properties: &armnetwork.ApplicationGatewayPrivateEndpointConnectionProperties{
		PrivateEndpoint: &armnetwork.PrivateEndpoint{
			ID: to.Ptr("/subscriptions/subId2/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/testPe"),
		},
		PrivateLinkServiceConnectionState: &armnetwork.PrivateLinkServiceConnectionState{
			Description: to.Ptr("approved it for some reason."),
			Status:      to.Ptr("Approved"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayPrivateEndpointConnection = armnetwork.ApplicationGatewayPrivateEndpointConnection{
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkResources/testPlePeConnection"),
// 	Name: to.Ptr("testPlePeConnection"),
// 	Properties: &armnetwork.ApplicationGatewayPrivateEndpointConnectionProperties{
// 		LinkIdentifier: to.Ptr("linkId"),
// 		PrivateEndpoint: &armnetwork.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/subId/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/testPe"),
// 		},
// 		PrivateLinkServiceConnectionState: &armnetwork.PrivateLinkServiceConnectionState{
// 			Description: to.Ptr("approved it for some reason."),
// 			Status: to.Ptr("Approved"),
// 		},
// 	},
// }

func (*ApplicationGatewayPrivateEndpointConnectionsClient) Get 

func (client *ApplicationGatewayPrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, applicationGatewayName string, connectionName string, options *ApplicationGatewayPrivateEndpointConnectionsClientGetOptions) (ApplicationGatewayPrivateEndpointConnectionsClientGetResponse, error)

Get - Gets the specified private endpoint connection on application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • connectionName - The name of the application gateway private endpoint connection.
  • options - ApplicationGatewayPrivateEndpointConnectionsClientGetOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayPrivateEndpointConnectionGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewayPrivateEndpointConnectionsClient().Get(ctx, "rg1", "appgw", "connection1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayPrivateEndpointConnection = armnetwork.ApplicationGatewayPrivateEndpointConnection{
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkResources/connection1"),
// 	Name: to.Ptr("coonection1"),
// 	Type: to.Ptr("Microsoft.Network/applicationGateways/privateEndpointConnections"),
// 	Properties: &armnetwork.ApplicationGatewayPrivateEndpointConnectionProperties{
// 		LinkIdentifier: to.Ptr("805319460"),
// 		PrivateEndpoint: &armnetwork.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/subid2/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/pe1"),
// 		},
// 		PrivateLinkServiceConnectionState: &armnetwork.PrivateLinkServiceConnectionState{
// 			Description: to.Ptr("Approval Done"),
// 			Status: to.Ptr("Approved"),
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 	},
// }

func (*ApplicationGatewayPrivateEndpointConnectionsClient) NewListPager 

func (client *ApplicationGatewayPrivateEndpointConnectionsClient) NewListPager(resourceGroupName string, applicationGatewayName string, options *ApplicationGatewayPrivateEndpointConnectionsClientListOptions) *runtime.Pager[ApplicationGatewayPrivateEndpointConnectionsClientListResponse]

NewListPager - Lists all private endpoint connections on an application gateway.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewayPrivateEndpointConnectionsClientListOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayPrivateEndpointConnectionList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationGatewayPrivateEndpointConnectionsClient().NewListPager("rg1", "appgw", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationGatewayPrivateEndpointConnectionListResult = armnetwork.ApplicationGatewayPrivateEndpointConnectionListResult{
	// 	Value: []*armnetwork.ApplicationGatewayPrivateEndpointConnection{
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkResources/connection1"),
	// 			Name: to.Ptr("coonection1"),
	// 			Type: to.Ptr("Microsoft.Network/applicationGateways/privateEndpointConnections"),
	// 			Properties: &armnetwork.ApplicationGatewayPrivateEndpointConnectionProperties{
	// 				LinkIdentifier: to.Ptr("805319460"),
	// 				PrivateEndpoint: &armnetwork.PrivateEndpoint{
	// 					ID: to.Ptr("/subscriptions/subid2/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/pe1"),
	// 				},
	// 				PrivateLinkServiceConnectionState: &armnetwork.PrivateLinkServiceConnectionState{
	// 					Description: to.Ptr("Approval Done"),
	// 					Status: to.Ptr("Approved"),
	// 				},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

type ApplicationGatewayPrivateEndpointConnectionsClientBeginDeleteOptions 

type ApplicationGatewayPrivateEndpointConnectionsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewayPrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.BeginDelete method.

type ApplicationGatewayPrivateEndpointConnectionsClientBeginUpdateOptions 

type ApplicationGatewayPrivateEndpointConnectionsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewayPrivateEndpointConnectionsClientBeginUpdateOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.BeginUpdate method.

type ApplicationGatewayPrivateEndpointConnectionsClientDeleteResponse 

type ApplicationGatewayPrivateEndpointConnectionsClientDeleteResponse struct {
}

ApplicationGatewayPrivateEndpointConnectionsClientDeleteResponse contains the response from method ApplicationGatewayPrivateEndpointConnectionsClient.BeginDelete.

type ApplicationGatewayPrivateEndpointConnectionsClientGetOptions 

type ApplicationGatewayPrivateEndpointConnectionsClientGetOptions struct {
}

ApplicationGatewayPrivateEndpointConnectionsClientGetOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.Get method.

type ApplicationGatewayPrivateEndpointConnectionsClientGetResponse 

type ApplicationGatewayPrivateEndpointConnectionsClientGetResponse struct {
	// Private Endpoint connection on an application gateway.
	ApplicationGatewayPrivateEndpointConnection
}

ApplicationGatewayPrivateEndpointConnectionsClientGetResponse contains the response from method ApplicationGatewayPrivateEndpointConnectionsClient.Get.

type ApplicationGatewayPrivateEndpointConnectionsClientListOptions 

type ApplicationGatewayPrivateEndpointConnectionsClientListOptions struct {
}

ApplicationGatewayPrivateEndpointConnectionsClientListOptions contains the optional parameters for the ApplicationGatewayPrivateEndpointConnectionsClient.NewListPager method.

type ApplicationGatewayPrivateEndpointConnectionsClientListResponse 

type ApplicationGatewayPrivateEndpointConnectionsClientListResponse struct {
	// Response for ListApplicationGatewayPrivateEndpointConnection API service call. Gets all private endpoint connections for
	// an application gateway.
	ApplicationGatewayPrivateEndpointConnectionListResult
}

ApplicationGatewayPrivateEndpointConnectionsClientListResponse contains the response from method ApplicationGatewayPrivateEndpointConnectionsClient.NewListPager.

type ApplicationGatewayPrivateEndpointConnectionsClientUpdateResponse 

type ApplicationGatewayPrivateEndpointConnectionsClientUpdateResponse struct {
	// Private Endpoint connection on an application gateway.
	ApplicationGatewayPrivateEndpointConnection
}

ApplicationGatewayPrivateEndpointConnectionsClientUpdateResponse contains the response from method ApplicationGatewayPrivateEndpointConnectionsClient.BeginUpdate.

type ApplicationGatewayPrivateLinkConfiguration 

type ApplicationGatewayPrivateLinkConfiguration struct {
	// Resource ID.
	ID *string

	// Name of the private link configuration that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway private link configuration.
	Properties *ApplicationGatewayPrivateLinkConfigurationProperties

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayPrivateLinkConfiguration - Private Link Configuration on an application gateway.

func (ApplicationGatewayPrivateLinkConfiguration) MarshalJSON 

func (a ApplicationGatewayPrivateLinkConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkConfiguration.

func (*ApplicationGatewayPrivateLinkConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkConfiguration.

type ApplicationGatewayPrivateLinkConfigurationProperties 

type ApplicationGatewayPrivateLinkConfigurationProperties struct {
	// An array of application gateway private link ip configurations.
	IPConfigurations []*ApplicationGatewayPrivateLinkIPConfiguration

	// READ-ONLY; The provisioning state of the application gateway private link configuration.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayPrivateLinkConfigurationProperties - Properties of private link configuration on an application gateway.

func (ApplicationGatewayPrivateLinkConfigurationProperties) MarshalJSON 

func (a ApplicationGatewayPrivateLinkConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkConfigurationProperties.

func (*ApplicationGatewayPrivateLinkConfigurationProperties) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkConfigurationProperties.

type ApplicationGatewayPrivateLinkIPConfiguration 

type ApplicationGatewayPrivateLinkIPConfiguration struct {
	// Resource ID.
	ID *string

	// The name of application gateway private link ip configuration.
	Name *string

	// Properties of an application gateway private link ip configuration.
	Properties *ApplicationGatewayPrivateLinkIPConfigurationProperties

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; The resource type.
	Type *string
}

ApplicationGatewayPrivateLinkIPConfiguration - The application gateway private link ip configuration.

func (ApplicationGatewayPrivateLinkIPConfiguration) MarshalJSON 

func (a ApplicationGatewayPrivateLinkIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkIPConfiguration.

func (*ApplicationGatewayPrivateLinkIPConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkIPConfiguration.

type ApplicationGatewayPrivateLinkIPConfigurationProperties 

type ApplicationGatewayPrivateLinkIPConfigurationProperties struct {
	// Whether the ip configuration is primary or not.
	Primary *bool

	// The private IP address of the IP configuration.
	PrivateIPAddress *string

	// The private IP address allocation method.
	PrivateIPAllocationMethod *IPAllocationMethod

	// Reference to the subnet resource.
	Subnet *SubResource

	// READ-ONLY; The provisioning state of the application gateway private link IP configuration.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayPrivateLinkIPConfigurationProperties - Properties of an application gateway private link IP configuration.

func (ApplicationGatewayPrivateLinkIPConfigurationProperties) MarshalJSON 

func (a ApplicationGatewayPrivateLinkIPConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkIPConfigurationProperties.

func (*ApplicationGatewayPrivateLinkIPConfigurationProperties) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkIPConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkIPConfigurationProperties.

type ApplicationGatewayPrivateLinkResource 

type ApplicationGatewayPrivateLinkResource struct {
	// Resource ID.
	ID *string

	// Name of the private link resource that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway private link resource.
	Properties *ApplicationGatewayPrivateLinkResourceProperties

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayPrivateLinkResource - PrivateLink Resource of an application gateway.

func (ApplicationGatewayPrivateLinkResource) MarshalJSON 

func (a ApplicationGatewayPrivateLinkResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkResource.

func (*ApplicationGatewayPrivateLinkResource) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkResource.

type ApplicationGatewayPrivateLinkResourceListResult 

type ApplicationGatewayPrivateLinkResourceListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of private link resources of an application gateway.
	Value []*ApplicationGatewayPrivateLinkResource
}

ApplicationGatewayPrivateLinkResourceListResult - Response for ListApplicationGatewayPrivateLinkResources API service call. Gets all private link resources for an application gateway.

func (ApplicationGatewayPrivateLinkResourceListResult) MarshalJSON 

func (a ApplicationGatewayPrivateLinkResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkResourceListResult.

func (*ApplicationGatewayPrivateLinkResourceListResult) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkResourceListResult.

type ApplicationGatewayPrivateLinkResourceProperties 

type ApplicationGatewayPrivateLinkResourceProperties struct {
	// Required DNS zone names of the the private link resource.
	RequiredZoneNames []*string

	// READ-ONLY; Group identifier of private link resource.
	GroupID *string

	// READ-ONLY; Required member names of private link resource.
	RequiredMembers []*string
}

ApplicationGatewayPrivateLinkResourceProperties - Properties of a private link resource.

func (ApplicationGatewayPrivateLinkResourceProperties) MarshalJSON 

func (a ApplicationGatewayPrivateLinkResourceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPrivateLinkResourceProperties.

func (*ApplicationGatewayPrivateLinkResourceProperties) UnmarshalJSON 

func (a *ApplicationGatewayPrivateLinkResourceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPrivateLinkResourceProperties.

type ApplicationGatewayPrivateLinkResourcesClient 

type ApplicationGatewayPrivateLinkResourcesClient struct {
	// contains filtered or unexported fields
}

ApplicationGatewayPrivateLinkResourcesClient contains the methods for the ApplicationGatewayPrivateLinkResources group. Don't use this type directly, use NewApplicationGatewayPrivateLinkResourcesClient() instead.

func NewApplicationGatewayPrivateLinkResourcesClient 

func NewApplicationGatewayPrivateLinkResourcesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ApplicationGatewayPrivateLinkResourcesClient, error)

NewApplicationGatewayPrivateLinkResourcesClient creates a new instance of ApplicationGatewayPrivateLinkResourcesClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ApplicationGatewayPrivateLinkResourcesClient) NewListPager 

func (client *ApplicationGatewayPrivateLinkResourcesClient) NewListPager(resourceGroupName string, applicationGatewayName string, options *ApplicationGatewayPrivateLinkResourcesClientListOptions) *runtime.Pager[ApplicationGatewayPrivateLinkResourcesClientListResponse]

NewListPager - Lists all private link resources on an application gateway.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewayPrivateLinkResourcesClientListOptions contains the optional parameters for the ApplicationGatewayPrivateLinkResourcesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayPrivateLinkResourceList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationGatewayPrivateLinkResourcesClient().NewListPager("rg1", "appgw", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationGatewayPrivateLinkResourceListResult = armnetwork.ApplicationGatewayPrivateLinkResourceListResult{
	// 	Value: []*armnetwork.ApplicationGatewayPrivateLinkResource{
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkResources/privateLink1"),
	// 			Name: to.Ptr("privateLink1"),
	// 			Type: to.Ptr("Microsoft.Network/applicationGateways/privateLinkResources"),
	// 			Properties: &armnetwork.ApplicationGatewayPrivateLinkResourceProperties{
	// 				GroupID: to.Ptr("privateLink1"),
	// 				RequiredMembers: []*string{
	// 					to.Ptr("privateLink1")},
	// 					RequiredZoneNames: []*string{
	// 					},
	// 				},
	// 		}},
	// 	}
}

type ApplicationGatewayPrivateLinkResourcesClientListOptions 

type ApplicationGatewayPrivateLinkResourcesClientListOptions struct {
}

ApplicationGatewayPrivateLinkResourcesClientListOptions contains the optional parameters for the ApplicationGatewayPrivateLinkResourcesClient.NewListPager method.

type ApplicationGatewayPrivateLinkResourcesClientListResponse 

type ApplicationGatewayPrivateLinkResourcesClientListResponse struct {
	// Response for ListApplicationGatewayPrivateLinkResources API service call. Gets all private link resources for an application
	// gateway.
	ApplicationGatewayPrivateLinkResourceListResult
}

ApplicationGatewayPrivateLinkResourcesClientListResponse contains the response from method ApplicationGatewayPrivateLinkResourcesClient.NewListPager.

type ApplicationGatewayProbe 

type ApplicationGatewayProbe struct {
	// Resource ID.
	ID *string

	// Name of the probe that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway probe.
	Properties *ApplicationGatewayProbePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayProbe - Probe of the application gateway.

func (ApplicationGatewayProbe) MarshalJSON 

func (a ApplicationGatewayProbe) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayProbe.

func (*ApplicationGatewayProbe) UnmarshalJSON 

func (a *ApplicationGatewayProbe) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayProbe.

type ApplicationGatewayProbeHealthResponseMatch 

type ApplicationGatewayProbeHealthResponseMatch struct {
	// Body that must be contained in the health response. Default value is empty.
	Body *string

	// Allowed ranges of healthy status codes. Default range of healthy status codes is 200-399.
	StatusCodes []*string
}

ApplicationGatewayProbeHealthResponseMatch - Application gateway probe health response match.

func (ApplicationGatewayProbeHealthResponseMatch) MarshalJSON 

func (a ApplicationGatewayProbeHealthResponseMatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayProbeHealthResponseMatch.

func (*ApplicationGatewayProbeHealthResponseMatch) UnmarshalJSON 

func (a *ApplicationGatewayProbeHealthResponseMatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayProbeHealthResponseMatch.

type ApplicationGatewayProbePropertiesFormat 

type ApplicationGatewayProbePropertiesFormat struct {
	// Host name to send the probe to.
	Host *string

	// The probing interval in seconds. This is the time interval between two consecutive probes. Acceptable values are from 1
	// second to 86400 seconds.
	Interval *int32

	// Criterion for classifying a healthy probe response.
	Match *ApplicationGatewayProbeHealthResponseMatch

	// Minimum number of servers that are always marked healthy. Default value is 0.
	MinServers *int32

	// Relative path of probe. Valid path starts from '/'. Probe is sent to ://:.
	Path *string

	// Whether the host header should be picked from the backend http settings. Default value is false.
	PickHostNameFromBackendHTTPSettings *bool

	// Whether the server name indication should be picked from the backend settings for Tls protocol. Default value is false.
	PickHostNameFromBackendSettings *bool

	// Custom port which will be used for probing the backend servers. The valid value ranges from 1 to 65535. In case not set,
	// port from http settings will be used. This property is valid for Basic,
	// Standardv2 and WAFv2 only.
	Port *int32

	// The protocol used for the probe.
	Protocol *ApplicationGatewayProtocol

	// The probe timeout in seconds. Probe marked as failed if valid response is not received with this timeout period. Acceptable
	// values are from 1 second to 86400 seconds.
	Timeout *int32

	// The probe retry count. Backend server is marked down after consecutive probe failure count reaches UnhealthyThreshold.
	// Acceptable values are from 1 second to 20.
	UnhealthyThreshold *int32

	// READ-ONLY; The provisioning state of the probe resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayProbePropertiesFormat - Properties of probe of an application gateway.

func (ApplicationGatewayProbePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayProbePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayProbePropertiesFormat.

func (*ApplicationGatewayProbePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayProbePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayProbePropertiesFormat.

type ApplicationGatewayPropertiesFormat 

type ApplicationGatewayPropertiesFormat struct {
	// Authentication certificates of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	AuthenticationCertificates []*ApplicationGatewayAuthenticationCertificate

	// Autoscale Configuration.
	AutoscaleConfiguration *ApplicationGatewayAutoscaleConfiguration

	// Backend address pool of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	BackendAddressPools []*ApplicationGatewayBackendAddressPool

	// Backend http settings of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	BackendHTTPSettingsCollection []*ApplicationGatewayBackendHTTPSettings

	// Backend settings of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits]
	// .
	BackendSettingsCollection []*ApplicationGatewayBackendSettings

	// Custom error configurations of the application gateway resource.
	CustomErrorConfigurations []*ApplicationGatewayCustomError

	// Whether FIPS is enabled on the application gateway resource.
	EnableFips *bool

	// Whether HTTP2 is enabled on the application gateway resource.
	EnableHTTP2 *bool

	// Reference to the FirewallPolicy resource.
	FirewallPolicy *SubResource

	// If true, associates a firewall policy with an application gateway regardless whether the policy differs from the WAF Config.
	ForceFirewallPolicyAssociation *bool

	// Frontend IP addresses of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	FrontendIPConfigurations []*ApplicationGatewayFrontendIPConfiguration

	// Frontend ports of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	FrontendPorts []*ApplicationGatewayFrontendPort

	// Subnets of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	GatewayIPConfigurations []*ApplicationGatewayIPConfiguration

	// Global Configuration.
	GlobalConfiguration *ApplicationGatewayGlobalConfiguration

	// Http listeners of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	HTTPListeners []*ApplicationGatewayHTTPListener

	// Listeners of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	Listeners []*ApplicationGatewayListener

	// Load distribution policies of the application gateway resource.
	LoadDistributionPolicies []*ApplicationGatewayLoadDistributionPolicy

	// PrivateLink configurations on application gateway.
	PrivateLinkConfigurations []*ApplicationGatewayPrivateLinkConfiguration

	// Probes of the application gateway resource.
	Probes []*ApplicationGatewayProbe

	// Redirect configurations of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	RedirectConfigurations []*ApplicationGatewayRedirectConfiguration

	// Request routing rules of the application gateway resource.
	RequestRoutingRules []*ApplicationGatewayRequestRoutingRule

	// Rewrite rules for the application gateway resource.
	RewriteRuleSets []*ApplicationGatewayRewriteRuleSet

	// Routing rules of the application gateway resource.
	RoutingRules []*ApplicationGatewayRoutingRule

	// SKU of the application gateway resource.
	SKU *ApplicationGatewaySKU

	// SSL certificates of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits]
	// .
	SSLCertificates []*ApplicationGatewaySSLCertificate

	// SSL policy of the application gateway resource.
	SSLPolicy *ApplicationGatewaySSLPolicy

	// SSL profiles of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	SSLProfiles []*ApplicationGatewaySSLProfile

	// Trusted client certificates of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	TrustedClientCertificates []*ApplicationGatewayTrustedClientCertificate

	// Trusted Root certificates of the application gateway resource. For default limits, see Application Gateway limits
	// [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	TrustedRootCertificates []*ApplicationGatewayTrustedRootCertificate

	// URL path map of the application gateway resource. For default limits, see Application Gateway limits [https://docs.microsoft.com/azure/azure-subscription-service-limits#application-gateway-limits].
	URLPathMaps []*ApplicationGatewayURLPathMap

	// Web application firewall configuration.
	WebApplicationFirewallConfiguration *ApplicationGatewayWebApplicationFirewallConfiguration

	// READ-ONLY; The default predefined SSL Policy applied on the application gateway resource.
	DefaultPredefinedSSLPolicy *ApplicationGatewaySSLPolicyName

	// READ-ONLY; Operational state of the application gateway resource.
	OperationalState *ApplicationGatewayOperationalState

	// READ-ONLY; Private Endpoint connections on application gateway.
	PrivateEndpointConnections []*ApplicationGatewayPrivateEndpointConnection

	// READ-ONLY; The provisioning state of the application gateway resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The resource GUID property of the application gateway resource.
	ResourceGUID *string
}

ApplicationGatewayPropertiesFormat - Properties of the application gateway.

func (ApplicationGatewayPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayPropertiesFormat.

func (*ApplicationGatewayPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayPropertiesFormat.

type ApplicationGatewayProtocol 

type ApplicationGatewayProtocol string

ApplicationGatewayProtocol - Application Gateway protocol. 

const (
	// ApplicationGatewayProtocolHTTP - Supported for httpListeners and backendHttpSettingsCollection properties.
	ApplicationGatewayProtocolHTTP ApplicationGatewayProtocol = "Http"
	// ApplicationGatewayProtocolHTTPS - Supported for httpListeners and backendHttpSettingsCollection properties.
	ApplicationGatewayProtocolHTTPS ApplicationGatewayProtocol = "Https"
	// ApplicationGatewayProtocolTCP - Supported for listeners and backendSettingsCollection properties.
	ApplicationGatewayProtocolTCP ApplicationGatewayProtocol = "Tcp"
	// ApplicationGatewayProtocolTLS - Supported for listeners and backendSettingsCollection properties.
	ApplicationGatewayProtocolTLS ApplicationGatewayProtocol = "Tls"
)

func PossibleApplicationGatewayProtocolValues 

func PossibleApplicationGatewayProtocolValues() []ApplicationGatewayProtocol

PossibleApplicationGatewayProtocolValues returns the possible values for the ApplicationGatewayProtocol const type.

type ApplicationGatewayRedirectConfiguration 

type ApplicationGatewayRedirectConfiguration struct {
	// Resource ID.
	ID *string

	// Name of the redirect configuration that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway redirect configuration.
	Properties *ApplicationGatewayRedirectConfigurationPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayRedirectConfiguration - Redirect configuration of an application gateway.

func (ApplicationGatewayRedirectConfiguration) MarshalJSON 

func (a ApplicationGatewayRedirectConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRedirectConfiguration.

func (*ApplicationGatewayRedirectConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayRedirectConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRedirectConfiguration.

type ApplicationGatewayRedirectConfigurationPropertiesFormat 

type ApplicationGatewayRedirectConfigurationPropertiesFormat struct {
	// Include path in the redirected url.
	IncludePath *bool

	// Include query string in the redirected url.
	IncludeQueryString *bool

	// Path rules specifying redirect configuration.
	PathRules []*SubResource

	// HTTP redirection type.
	RedirectType *ApplicationGatewayRedirectType

	// Request routing specifying redirect configuration.
	RequestRoutingRules []*SubResource

	// Reference to a listener to redirect the request to.
	TargetListener *SubResource

	// Url to redirect the request to.
	TargetURL *string

	// Url path maps specifying default redirect configuration.
	URLPathMaps []*SubResource
}

ApplicationGatewayRedirectConfigurationPropertiesFormat - Properties of redirect configuration of the application gateway.

func (ApplicationGatewayRedirectConfigurationPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayRedirectConfigurationPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRedirectConfigurationPropertiesFormat.

func (*ApplicationGatewayRedirectConfigurationPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayRedirectConfigurationPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRedirectConfigurationPropertiesFormat.

type ApplicationGatewayRedirectType 

type ApplicationGatewayRedirectType string

ApplicationGatewayRedirectType - Redirect type enum. 

const (
	ApplicationGatewayRedirectTypeFound     ApplicationGatewayRedirectType = "Found"
	ApplicationGatewayRedirectTypePermanent ApplicationGatewayRedirectType = "Permanent"
	ApplicationGatewayRedirectTypeSeeOther  ApplicationGatewayRedirectType = "SeeOther"
	ApplicationGatewayRedirectTypeTemporary ApplicationGatewayRedirectType = "Temporary"
)

func PossibleApplicationGatewayRedirectTypeValues 

func PossibleApplicationGatewayRedirectTypeValues() []ApplicationGatewayRedirectType

PossibleApplicationGatewayRedirectTypeValues returns the possible values for the ApplicationGatewayRedirectType const type.

type ApplicationGatewayRequestRoutingRule 

type ApplicationGatewayRequestRoutingRule struct {
	// Resource ID.
	ID *string

	// Name of the request routing rule that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway request routing rule.
	Properties *ApplicationGatewayRequestRoutingRulePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayRequestRoutingRule - Request routing rule of an application gateway.

func (ApplicationGatewayRequestRoutingRule) MarshalJSON 

func (a ApplicationGatewayRequestRoutingRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRequestRoutingRule.

func (*ApplicationGatewayRequestRoutingRule) UnmarshalJSON 

func (a *ApplicationGatewayRequestRoutingRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRequestRoutingRule.

type ApplicationGatewayRequestRoutingRulePropertiesFormat 

type ApplicationGatewayRequestRoutingRulePropertiesFormat struct {
	// Backend address pool resource of the application gateway.
	BackendAddressPool *SubResource

	// Backend http settings resource of the application gateway.
	BackendHTTPSettings *SubResource

	// Http listener resource of the application gateway.
	HTTPListener *SubResource

	// Load Distribution Policy resource of the application gateway.
	LoadDistributionPolicy *SubResource

	// Priority of the request routing rule.
	Priority *int32

	// Redirect configuration resource of the application gateway.
	RedirectConfiguration *SubResource

	// Rewrite Rule Set resource in Basic rule of the application gateway.
	RewriteRuleSet *SubResource

	// Rule type.
	RuleType *ApplicationGatewayRequestRoutingRuleType

	// URL path map resource of the application gateway.
	URLPathMap *SubResource

	// READ-ONLY; The provisioning state of the request routing rule resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayRequestRoutingRulePropertiesFormat - Properties of request routing rule of the application gateway.

func (ApplicationGatewayRequestRoutingRulePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayRequestRoutingRulePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRequestRoutingRulePropertiesFormat.

func (*ApplicationGatewayRequestRoutingRulePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayRequestRoutingRulePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRequestRoutingRulePropertiesFormat.

type ApplicationGatewayRequestRoutingRuleType 

type ApplicationGatewayRequestRoutingRuleType string

ApplicationGatewayRequestRoutingRuleType - Rule type. 

const (
	ApplicationGatewayRequestRoutingRuleTypeBasic            ApplicationGatewayRequestRoutingRuleType = "Basic"
	ApplicationGatewayRequestRoutingRuleTypePathBasedRouting ApplicationGatewayRequestRoutingRuleType = "PathBasedRouting"
)

func PossibleApplicationGatewayRequestRoutingRuleTypeValues 

func PossibleApplicationGatewayRequestRoutingRuleTypeValues() []ApplicationGatewayRequestRoutingRuleType

PossibleApplicationGatewayRequestRoutingRuleTypeValues returns the possible values for the ApplicationGatewayRequestRoutingRuleType const type.

type ApplicationGatewayRewriteRule 

type ApplicationGatewayRewriteRule struct {
	// Set of actions to be done as part of the rewrite Rule.
	ActionSet *ApplicationGatewayRewriteRuleActionSet

	// Conditions based on which the action set execution will be evaluated.
	Conditions []*ApplicationGatewayRewriteRuleCondition

	// Name of the rewrite rule that is unique within an Application Gateway.
	Name *string

	// Rule Sequence of the rewrite rule that determines the order of execution of a particular rule in a RewriteRuleSet.
	RuleSequence *int32
}

ApplicationGatewayRewriteRule - Rewrite rule of an application gateway.

func (ApplicationGatewayRewriteRule) MarshalJSON 

func (a ApplicationGatewayRewriteRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRewriteRule.

func (*ApplicationGatewayRewriteRule) UnmarshalJSON 

func (a *ApplicationGatewayRewriteRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRewriteRule.

type ApplicationGatewayRewriteRuleActionSet 

type ApplicationGatewayRewriteRuleActionSet struct {
	// Request Header Actions in the Action Set.
	RequestHeaderConfigurations []*ApplicationGatewayHeaderConfiguration

	// Response Header Actions in the Action Set.
	ResponseHeaderConfigurations []*ApplicationGatewayHeaderConfiguration

	// Url Configuration Action in the Action Set.
	URLConfiguration *ApplicationGatewayURLConfiguration
}

ApplicationGatewayRewriteRuleActionSet - Set of actions in the Rewrite Rule in Application Gateway.

func (ApplicationGatewayRewriteRuleActionSet) MarshalJSON 

func (a ApplicationGatewayRewriteRuleActionSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRewriteRuleActionSet.

func (*ApplicationGatewayRewriteRuleActionSet) UnmarshalJSON 

func (a *ApplicationGatewayRewriteRuleActionSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRewriteRuleActionSet.

type ApplicationGatewayRewriteRuleCondition 

type ApplicationGatewayRewriteRuleCondition struct {
	// Setting this parameter to truth value with force the pattern to do a case in-sensitive comparison.
	IgnoreCase *bool

	// Setting this value as truth will force to check the negation of the condition given by the user.
	Negate *bool

	// The pattern, either fixed string or regular expression, that evaluates the truthfulness of the condition.
	Pattern *string

	// The condition parameter of the RewriteRuleCondition.
	Variable *string
}

ApplicationGatewayRewriteRuleCondition - Set of conditions in the Rewrite Rule in Application Gateway.

func (ApplicationGatewayRewriteRuleCondition) MarshalJSON 

func (a ApplicationGatewayRewriteRuleCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRewriteRuleCondition.

func (*ApplicationGatewayRewriteRuleCondition) UnmarshalJSON 

func (a *ApplicationGatewayRewriteRuleCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRewriteRuleCondition.

type ApplicationGatewayRewriteRuleSet 

type ApplicationGatewayRewriteRuleSet struct {
	// Resource ID.
	ID *string

	// Name of the rewrite rule set that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway rewrite rule set.
	Properties *ApplicationGatewayRewriteRuleSetPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string
}

ApplicationGatewayRewriteRuleSet - Rewrite rule set of an application gateway.

func (ApplicationGatewayRewriteRuleSet) MarshalJSON 

func (a ApplicationGatewayRewriteRuleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRewriteRuleSet.

func (*ApplicationGatewayRewriteRuleSet) UnmarshalJSON 

func (a *ApplicationGatewayRewriteRuleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRewriteRuleSet.

type ApplicationGatewayRewriteRuleSetPropertiesFormat 

type ApplicationGatewayRewriteRuleSetPropertiesFormat struct {
	// Rewrite rules in the rewrite rule set.
	RewriteRules []*ApplicationGatewayRewriteRule

	// READ-ONLY; The provisioning state of the rewrite rule set resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayRewriteRuleSetPropertiesFormat - Properties of rewrite rule set of the application gateway.

func (ApplicationGatewayRewriteRuleSetPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayRewriteRuleSetPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRewriteRuleSetPropertiesFormat.

func (*ApplicationGatewayRewriteRuleSetPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayRewriteRuleSetPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRewriteRuleSetPropertiesFormat.

type ApplicationGatewayRoutingRule 

type ApplicationGatewayRoutingRule struct {
	// Resource ID.
	ID *string

	// Name of the routing rule that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway routing rule.
	Properties *ApplicationGatewayRoutingRulePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayRoutingRule - Routing rule of an application gateway.

func (ApplicationGatewayRoutingRule) MarshalJSON 

func (a ApplicationGatewayRoutingRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRoutingRule.

func (*ApplicationGatewayRoutingRule) UnmarshalJSON 

func (a *ApplicationGatewayRoutingRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRoutingRule.

type ApplicationGatewayRoutingRulePropertiesFormat 

type ApplicationGatewayRoutingRulePropertiesFormat struct {
	// REQUIRED; Priority of the routing rule.
	Priority *int32

	// Backend address pool resource of the application gateway.
	BackendAddressPool *SubResource

	// Backend settings resource of the application gateway.
	BackendSettings *SubResource

	// Listener resource of the application gateway.
	Listener *SubResource

	// Rule type.
	RuleType *ApplicationGatewayRequestRoutingRuleType

	// READ-ONLY; The provisioning state of the request routing rule resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayRoutingRulePropertiesFormat - Properties of routing rule of the application gateway.

func (ApplicationGatewayRoutingRulePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayRoutingRulePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayRoutingRulePropertiesFormat.

func (*ApplicationGatewayRoutingRulePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayRoutingRulePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayRoutingRulePropertiesFormat.

type ApplicationGatewayRuleSetStatusOptions 

type ApplicationGatewayRuleSetStatusOptions string

ApplicationGatewayRuleSetStatusOptions - The rule set status 

const (
	ApplicationGatewayRuleSetStatusOptionsDeprecated ApplicationGatewayRuleSetStatusOptions = "Deprecated"
	ApplicationGatewayRuleSetStatusOptionsGA         ApplicationGatewayRuleSetStatusOptions = "GA"
	ApplicationGatewayRuleSetStatusOptionsPreview    ApplicationGatewayRuleSetStatusOptions = "Preview"
	ApplicationGatewayRuleSetStatusOptionsSupported  ApplicationGatewayRuleSetStatusOptions = "Supported"
)

func PossibleApplicationGatewayRuleSetStatusOptionsValues 

func PossibleApplicationGatewayRuleSetStatusOptionsValues() []ApplicationGatewayRuleSetStatusOptions

PossibleApplicationGatewayRuleSetStatusOptionsValues returns the possible values for the ApplicationGatewayRuleSetStatusOptions const type.

type ApplicationGatewaySKU 

type ApplicationGatewaySKU struct {
	// Capacity (instance count) of an application gateway.
	Capacity *int32

	// Family of an application gateway SKU.
	Family *ApplicationGatewaySKUFamily

	// Name of an application gateway SKU.
	Name *ApplicationGatewaySKUName

	// Tier of an application gateway.
	Tier *ApplicationGatewayTier
}

ApplicationGatewaySKU - SKU of an application gateway.

func (ApplicationGatewaySKU) MarshalJSON 

func (a ApplicationGatewaySKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySKU.

func (*ApplicationGatewaySKU) UnmarshalJSON 

func (a *ApplicationGatewaySKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySKU.

type ApplicationGatewaySKUFamily 

type ApplicationGatewaySKUFamily string

ApplicationGatewaySKUFamily - Family of an application gateway SKU. 

const (
	ApplicationGatewaySKUFamilyGeneration1 ApplicationGatewaySKUFamily = "Generation_1"
	ApplicationGatewaySKUFamilyGeneration2 ApplicationGatewaySKUFamily = "Generation_2"
)

func PossibleApplicationGatewaySKUFamilyValues 

func PossibleApplicationGatewaySKUFamilyValues() []ApplicationGatewaySKUFamily

PossibleApplicationGatewaySKUFamilyValues returns the possible values for the ApplicationGatewaySKUFamily const type.

type ApplicationGatewaySKUName 

type ApplicationGatewaySKUName string

ApplicationGatewaySKUName - Name of an application gateway SKU. 

const (
	ApplicationGatewaySKUNameBasic          ApplicationGatewaySKUName = "Basic"
	ApplicationGatewaySKUNameStandardLarge  ApplicationGatewaySKUName = "Standard_Large"
	ApplicationGatewaySKUNameStandardMedium ApplicationGatewaySKUName = "Standard_Medium"
	ApplicationGatewaySKUNameStandardSmall  ApplicationGatewaySKUName = "Standard_Small"
	ApplicationGatewaySKUNameStandardV2     ApplicationGatewaySKUName = "Standard_v2"
	ApplicationGatewaySKUNameWAFLarge       ApplicationGatewaySKUName = "WAF_Large"
	ApplicationGatewaySKUNameWAFMedium      ApplicationGatewaySKUName = "WAF_Medium"
	ApplicationGatewaySKUNameWAFV2          ApplicationGatewaySKUName = "WAF_v2"
)

func PossibleApplicationGatewaySKUNameValues 

func PossibleApplicationGatewaySKUNameValues() []ApplicationGatewaySKUName

PossibleApplicationGatewaySKUNameValues returns the possible values for the ApplicationGatewaySKUName const type.

type ApplicationGatewaySSLCertificate 

type ApplicationGatewaySSLCertificate struct {
	// Resource ID.
	ID *string

	// Name of the SSL certificate that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway SSL certificate.
	Properties *ApplicationGatewaySSLCertificatePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewaySSLCertificate - SSL certificates of an application gateway.

func (ApplicationGatewaySSLCertificate) MarshalJSON 

func (a ApplicationGatewaySSLCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLCertificate.

func (*ApplicationGatewaySSLCertificate) UnmarshalJSON 

func (a *ApplicationGatewaySSLCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLCertificate.

type ApplicationGatewaySSLCertificatePropertiesFormat 

type ApplicationGatewaySSLCertificatePropertiesFormat struct {
	// Base-64 encoded pfx certificate. Only applicable in PUT Request.
	Data *string

	// Secret Id of (base-64 encoded unencrypted pfx) 'Secret' or 'Certificate' object stored in KeyVault.
	KeyVaultSecretID *string

	// Password for the pfx file specified in data. Only applicable in PUT request.
	Password *string

	// READ-ONLY; The provisioning state of the SSL certificate resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Base-64 encoded Public cert data corresponding to pfx specified in data. Only applicable in GET request.
	PublicCertData *string
}

ApplicationGatewaySSLCertificatePropertiesFormat - Properties of SSL certificates of an application gateway.

func (ApplicationGatewaySSLCertificatePropertiesFormat) MarshalJSON 

func (a ApplicationGatewaySSLCertificatePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLCertificatePropertiesFormat.

func (*ApplicationGatewaySSLCertificatePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewaySSLCertificatePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLCertificatePropertiesFormat.

type ApplicationGatewaySSLCipherSuite 

type ApplicationGatewaySSLCipherSuite string

ApplicationGatewaySSLCipherSuite - Ssl cipher suites enums. 

const (
	ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITH3DESEDECBCSHA       ApplicationGatewaySSLCipherSuite = "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA        ApplicationGatewaySSLCipherSuite = "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA256     ApplicationGatewaySSLCipherSuite = "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA        ApplicationGatewaySSLCipherSuite = "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA256     ApplicationGatewaySSLCipherSuite = "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128CBCSHA        ApplicationGatewaySSLCipherSuite = "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128GCMSHA256     ApplicationGatewaySSLCipherSuite = "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256CBCSHA        ApplicationGatewaySSLCipherSuite = "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256GCMSHA384     ApplicationGatewaySSLCipherSuite = "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"
	ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA    ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA256 ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128GCMSHA256 ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA    ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA384 ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
	ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256GCMSHA384 ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
	ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA      ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256   ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128GCMSHA256   ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA      ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA384   ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
	ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256GCMSHA384   ApplicationGatewaySSLCipherSuite = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITH3DESEDECBCSHA          ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA           ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_AES_128_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA256        ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_AES_128_CBC_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128GCMSHA256        ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_AES_128_GCM_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA           ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_AES_256_CBC_SHA"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA256        ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_AES_256_CBC_SHA256"
	ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256GCMSHA384        ApplicationGatewaySSLCipherSuite = "TLS_RSA_WITH_AES_256_GCM_SHA384"
)

func PossibleApplicationGatewaySSLCipherSuiteValues 

func PossibleApplicationGatewaySSLCipherSuiteValues() []ApplicationGatewaySSLCipherSuite

PossibleApplicationGatewaySSLCipherSuiteValues returns the possible values for the ApplicationGatewaySSLCipherSuite const type.

type ApplicationGatewaySSLPolicy 

type ApplicationGatewaySSLPolicy struct {
	// Ssl cipher suites to be enabled in the specified order to application gateway.
	CipherSuites []*ApplicationGatewaySSLCipherSuite

	// Ssl protocols to be disabled on application gateway.
	DisabledSSLProtocols []*ApplicationGatewaySSLProtocol

	// Minimum version of Ssl protocol to be supported on application gateway.
	MinProtocolVersion *ApplicationGatewaySSLProtocol

	// Name of Ssl predefined policy.
	PolicyName *ApplicationGatewaySSLPolicyName

	// Type of Ssl Policy.
	PolicyType *ApplicationGatewaySSLPolicyType
}

ApplicationGatewaySSLPolicy - Application Gateway Ssl policy.

func (ApplicationGatewaySSLPolicy) MarshalJSON 

func (a ApplicationGatewaySSLPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLPolicy.

func (*ApplicationGatewaySSLPolicy) UnmarshalJSON 

func (a *ApplicationGatewaySSLPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLPolicy.

type ApplicationGatewaySSLPolicyName 

type ApplicationGatewaySSLPolicyName string

ApplicationGatewaySSLPolicyName - Ssl predefined policy name enums. 

const (
	ApplicationGatewaySSLPolicyNameAppGwSSLPolicy20150501  ApplicationGatewaySSLPolicyName = "AppGwSslPolicy20150501"
	ApplicationGatewaySSLPolicyNameAppGwSSLPolicy20170401  ApplicationGatewaySSLPolicyName = "AppGwSslPolicy20170401"
	ApplicationGatewaySSLPolicyNameAppGwSSLPolicy20170401S ApplicationGatewaySSLPolicyName = "AppGwSslPolicy20170401S"
	ApplicationGatewaySSLPolicyNameAppGwSSLPolicy20220101  ApplicationGatewaySSLPolicyName = "AppGwSslPolicy20220101"
	ApplicationGatewaySSLPolicyNameAppGwSSLPolicy20220101S ApplicationGatewaySSLPolicyName = "AppGwSslPolicy20220101S"
)

func PossibleApplicationGatewaySSLPolicyNameValues 

func PossibleApplicationGatewaySSLPolicyNameValues() []ApplicationGatewaySSLPolicyName

PossibleApplicationGatewaySSLPolicyNameValues returns the possible values for the ApplicationGatewaySSLPolicyName const type.

type ApplicationGatewaySSLPolicyType 

type ApplicationGatewaySSLPolicyType string

ApplicationGatewaySSLPolicyType - Type of Ssl Policy. 

const (
	ApplicationGatewaySSLPolicyTypeCustom     ApplicationGatewaySSLPolicyType = "Custom"
	ApplicationGatewaySSLPolicyTypeCustomV2   ApplicationGatewaySSLPolicyType = "CustomV2"
	ApplicationGatewaySSLPolicyTypePredefined ApplicationGatewaySSLPolicyType = "Predefined"
)

func PossibleApplicationGatewaySSLPolicyTypeValues 

func PossibleApplicationGatewaySSLPolicyTypeValues() []ApplicationGatewaySSLPolicyType

PossibleApplicationGatewaySSLPolicyTypeValues returns the possible values for the ApplicationGatewaySSLPolicyType const type.

type ApplicationGatewaySSLPredefinedPolicy 

type ApplicationGatewaySSLPredefinedPolicy struct {
	// Resource ID.
	ID *string

	// Name of the Ssl predefined policy.
	Name *string

	// Properties of the application gateway SSL predefined policy.
	Properties *ApplicationGatewaySSLPredefinedPolicyPropertiesFormat
}

ApplicationGatewaySSLPredefinedPolicy - An Ssl predefined policy.

func (ApplicationGatewaySSLPredefinedPolicy) MarshalJSON 

func (a ApplicationGatewaySSLPredefinedPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLPredefinedPolicy.

func (*ApplicationGatewaySSLPredefinedPolicy) UnmarshalJSON 

func (a *ApplicationGatewaySSLPredefinedPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLPredefinedPolicy.

type ApplicationGatewaySSLPredefinedPolicyPropertiesFormat 

type ApplicationGatewaySSLPredefinedPolicyPropertiesFormat struct {
	// Ssl cipher suites to be enabled in the specified order for application gateway.
	CipherSuites []*ApplicationGatewaySSLCipherSuite

	// Minimum version of Ssl protocol to be supported on application gateway.
	MinProtocolVersion *ApplicationGatewaySSLProtocol
}

ApplicationGatewaySSLPredefinedPolicyPropertiesFormat - Properties of ApplicationGatewaySslPredefinedPolicy.

func (ApplicationGatewaySSLPredefinedPolicyPropertiesFormat) MarshalJSON 

func (a ApplicationGatewaySSLPredefinedPolicyPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLPredefinedPolicyPropertiesFormat.

func (*ApplicationGatewaySSLPredefinedPolicyPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewaySSLPredefinedPolicyPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLPredefinedPolicyPropertiesFormat.

type ApplicationGatewaySSLProfile 

type ApplicationGatewaySSLProfile struct {
	// Resource ID.
	ID *string

	// Name of the SSL profile that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway SSL profile.
	Properties *ApplicationGatewaySSLProfilePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewaySSLProfile - SSL profile of an application gateway.

func (ApplicationGatewaySSLProfile) MarshalJSON 

func (a ApplicationGatewaySSLProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLProfile.

func (*ApplicationGatewaySSLProfile) UnmarshalJSON 

func (a *ApplicationGatewaySSLProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLProfile.

type ApplicationGatewaySSLProfilePropertiesFormat 

type ApplicationGatewaySSLProfilePropertiesFormat struct {
	// Client authentication configuration of the application gateway resource.
	ClientAuthConfiguration *ApplicationGatewayClientAuthConfiguration

	// SSL policy of the application gateway resource.
	SSLPolicy *ApplicationGatewaySSLPolicy

	// Array of references to application gateway trusted client certificates.
	TrustedClientCertificates []*SubResource

	// READ-ONLY; The provisioning state of the HTTP listener resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewaySSLProfilePropertiesFormat - Properties of SSL profile of an application gateway.

func (ApplicationGatewaySSLProfilePropertiesFormat) MarshalJSON 

func (a ApplicationGatewaySSLProfilePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewaySSLProfilePropertiesFormat.

func (*ApplicationGatewaySSLProfilePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewaySSLProfilePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewaySSLProfilePropertiesFormat.

type ApplicationGatewaySSLProtocol 

type ApplicationGatewaySSLProtocol string

ApplicationGatewaySSLProtocol - Ssl protocol enums. 

const (
	ApplicationGatewaySSLProtocolTLSv10 ApplicationGatewaySSLProtocol = "TLSv1_0"
	ApplicationGatewaySSLProtocolTLSv11 ApplicationGatewaySSLProtocol = "TLSv1_1"
	ApplicationGatewaySSLProtocolTLSv12 ApplicationGatewaySSLProtocol = "TLSv1_2"
	ApplicationGatewaySSLProtocolTLSv13 ApplicationGatewaySSLProtocol = "TLSv1_3"
)

func PossibleApplicationGatewaySSLProtocolValues 

func PossibleApplicationGatewaySSLProtocolValues() []ApplicationGatewaySSLProtocol

PossibleApplicationGatewaySSLProtocolValues returns the possible values for the ApplicationGatewaySSLProtocol const type.

type ApplicationGatewayTier 

type ApplicationGatewayTier string

ApplicationGatewayTier - Tier of an application gateway. 

const (
	ApplicationGatewayTierBasic      ApplicationGatewayTier = "Basic"
	ApplicationGatewayTierStandard   ApplicationGatewayTier = "Standard"
	ApplicationGatewayTierStandardV2 ApplicationGatewayTier = "Standard_v2"
	ApplicationGatewayTierWAF        ApplicationGatewayTier = "WAF"
	ApplicationGatewayTierWAFV2      ApplicationGatewayTier = "WAF_v2"
)

func PossibleApplicationGatewayTierValues 

func PossibleApplicationGatewayTierValues() []ApplicationGatewayTier

PossibleApplicationGatewayTierValues returns the possible values for the ApplicationGatewayTier const type.

type ApplicationGatewayTierTypes 

type ApplicationGatewayTierTypes string
const (
	ApplicationGatewayTierTypesStandard   ApplicationGatewayTierTypes = "Standard"
	ApplicationGatewayTierTypesStandardV2 ApplicationGatewayTierTypes = "Standard_v2"
	ApplicationGatewayTierTypesWAF        ApplicationGatewayTierTypes = "WAF"
	ApplicationGatewayTierTypesWAFV2      ApplicationGatewayTierTypes = "WAF_v2"
)

func PossibleApplicationGatewayTierTypesValues 

func PossibleApplicationGatewayTierTypesValues() []ApplicationGatewayTierTypes

PossibleApplicationGatewayTierTypesValues returns the possible values for the ApplicationGatewayTierTypes const type.

type ApplicationGatewayTrustedClientCertificate 

type ApplicationGatewayTrustedClientCertificate struct {
	// Resource ID.
	ID *string

	// Name of the trusted client certificate that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway trusted client certificate.
	Properties *ApplicationGatewayTrustedClientCertificatePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayTrustedClientCertificate - Trusted client certificates of an application gateway.

func (ApplicationGatewayTrustedClientCertificate) MarshalJSON 

func (a ApplicationGatewayTrustedClientCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayTrustedClientCertificate.

func (*ApplicationGatewayTrustedClientCertificate) UnmarshalJSON 

func (a *ApplicationGatewayTrustedClientCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayTrustedClientCertificate.

type ApplicationGatewayTrustedClientCertificatePropertiesFormat 

type ApplicationGatewayTrustedClientCertificatePropertiesFormat struct {
	// Certificate public data.
	Data *string

	// READ-ONLY; Distinguished name of client certificate issuer.
	ClientCertIssuerDN *string

	// READ-ONLY; The provisioning state of the trusted client certificate resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Validated certificate data.
	ValidatedCertData *string
}

ApplicationGatewayTrustedClientCertificatePropertiesFormat - Trusted client certificates properties of an application gateway.

func (ApplicationGatewayTrustedClientCertificatePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayTrustedClientCertificatePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayTrustedClientCertificatePropertiesFormat.

func (*ApplicationGatewayTrustedClientCertificatePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayTrustedClientCertificatePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayTrustedClientCertificatePropertiesFormat.

type ApplicationGatewayTrustedRootCertificate 

type ApplicationGatewayTrustedRootCertificate struct {
	// Resource ID.
	ID *string

	// Name of the trusted root certificate that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway trusted root certificate.
	Properties *ApplicationGatewayTrustedRootCertificatePropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayTrustedRootCertificate - Trusted Root certificates of an application gateway.

func (ApplicationGatewayTrustedRootCertificate) MarshalJSON 

func (a ApplicationGatewayTrustedRootCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayTrustedRootCertificate.

func (*ApplicationGatewayTrustedRootCertificate) UnmarshalJSON 

func (a *ApplicationGatewayTrustedRootCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayTrustedRootCertificate.

type ApplicationGatewayTrustedRootCertificatePropertiesFormat 

type ApplicationGatewayTrustedRootCertificatePropertiesFormat struct {
	// Certificate public data.
	Data *string

	// Secret Id of (base-64 encoded unencrypted pfx) 'Secret' or 'Certificate' object stored in KeyVault.
	KeyVaultSecretID *string

	// READ-ONLY; The provisioning state of the trusted root certificate resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayTrustedRootCertificatePropertiesFormat - Trusted Root certificates properties of an application gateway.

func (ApplicationGatewayTrustedRootCertificatePropertiesFormat) MarshalJSON 

func (a ApplicationGatewayTrustedRootCertificatePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayTrustedRootCertificatePropertiesFormat.

func (*ApplicationGatewayTrustedRootCertificatePropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayTrustedRootCertificatePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayTrustedRootCertificatePropertiesFormat.

type ApplicationGatewayURLConfiguration 

type ApplicationGatewayURLConfiguration struct {
	// Url path which user has provided for url rewrite. Null means no path will be updated. Default value is null.
	ModifiedPath *string

	// Query string which user has provided for url rewrite. Null means no query string will be updated. Default value is null.
	ModifiedQueryString *string

	// If set as true, it will re-evaluate the url path map provided in path based request routing rules using modified path.
	// Default value is false.
	Reroute *bool
}

ApplicationGatewayURLConfiguration - Url configuration of the Actions set in Application Gateway.

func (ApplicationGatewayURLConfiguration) MarshalJSON 

func (a ApplicationGatewayURLConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayURLConfiguration.

func (*ApplicationGatewayURLConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayURLConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayURLConfiguration.

type ApplicationGatewayURLPathMap 

type ApplicationGatewayURLPathMap struct {
	// Resource ID.
	ID *string

	// Name of the URL path map that is unique within an Application Gateway.
	Name *string

	// Properties of the application gateway URL path map.
	Properties *ApplicationGatewayURLPathMapPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

ApplicationGatewayURLPathMap - UrlPathMaps give a url path to the backend mapping information for PathBasedRouting.

func (ApplicationGatewayURLPathMap) MarshalJSON 

func (a ApplicationGatewayURLPathMap) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayURLPathMap.

func (*ApplicationGatewayURLPathMap) UnmarshalJSON 

func (a *ApplicationGatewayURLPathMap) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayURLPathMap.

type ApplicationGatewayURLPathMapPropertiesFormat 

type ApplicationGatewayURLPathMapPropertiesFormat struct {
	// Default backend address pool resource of URL path map.
	DefaultBackendAddressPool *SubResource

	// Default backend http settings resource of URL path map.
	DefaultBackendHTTPSettings *SubResource

	// Default Load Distribution Policy resource of URL path map.
	DefaultLoadDistributionPolicy *SubResource

	// Default redirect configuration resource of URL path map.
	DefaultRedirectConfiguration *SubResource

	// Default Rewrite rule set resource of URL path map.
	DefaultRewriteRuleSet *SubResource

	// Path rule of URL path map resource.
	PathRules []*ApplicationGatewayPathRule

	// READ-ONLY; The provisioning state of the URL path map resource.
	ProvisioningState *ProvisioningState
}

ApplicationGatewayURLPathMapPropertiesFormat - Properties of UrlPathMap of the application gateway.

func (ApplicationGatewayURLPathMapPropertiesFormat) MarshalJSON 

func (a ApplicationGatewayURLPathMapPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayURLPathMapPropertiesFormat.

func (*ApplicationGatewayURLPathMapPropertiesFormat) UnmarshalJSON 

func (a *ApplicationGatewayURLPathMapPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayURLPathMapPropertiesFormat.

type ApplicationGatewayWafDynamicManifestPropertiesResult 

type ApplicationGatewayWafDynamicManifestPropertiesResult struct {
	// The available rulesets.
	AvailableRuleSets []*ApplicationGatewayFirewallManifestRuleSet

	// The default ruleset.
	DefaultRuleSet *DefaultRuleSetPropertyFormat
}

ApplicationGatewayWafDynamicManifestPropertiesResult - Properties of ApplicationGatewayWafDynamicManifest.

func (ApplicationGatewayWafDynamicManifestPropertiesResult) MarshalJSON 

func (a ApplicationGatewayWafDynamicManifestPropertiesResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayWafDynamicManifestPropertiesResult.

func (*ApplicationGatewayWafDynamicManifestPropertiesResult) UnmarshalJSON 

func (a *ApplicationGatewayWafDynamicManifestPropertiesResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayWafDynamicManifestPropertiesResult.

type ApplicationGatewayWafDynamicManifestResult 

type ApplicationGatewayWafDynamicManifestResult struct {
	// Resource ID.
	ID *string

	// Properties of the ApplicationGatewayWafDynamicManifest .
	Properties *ApplicationGatewayWafDynamicManifestPropertiesResult

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ApplicationGatewayWafDynamicManifestResult - Response for ApplicationGatewayWafDynamicManifest API service call.

func (ApplicationGatewayWafDynamicManifestResult) MarshalJSON 

func (a ApplicationGatewayWafDynamicManifestResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayWafDynamicManifestResult.

func (*ApplicationGatewayWafDynamicManifestResult) UnmarshalJSON 

func (a *ApplicationGatewayWafDynamicManifestResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayWafDynamicManifestResult.

type ApplicationGatewayWafDynamicManifestResultList 

type ApplicationGatewayWafDynamicManifestResultList struct {
	// URL to get the next set of results.
	NextLink *string

	// The list of application gateway waf manifest.
	Value []*ApplicationGatewayWafDynamicManifestResult
}

ApplicationGatewayWafDynamicManifestResultList - Response for ApplicationGatewayWafDynamicManifests API service call.

func (ApplicationGatewayWafDynamicManifestResultList) MarshalJSON 

func (a ApplicationGatewayWafDynamicManifestResultList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayWafDynamicManifestResultList.

func (*ApplicationGatewayWafDynamicManifestResultList) UnmarshalJSON 

func (a *ApplicationGatewayWafDynamicManifestResultList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayWafDynamicManifestResultList.

type ApplicationGatewayWafDynamicManifestsClient 

type ApplicationGatewayWafDynamicManifestsClient struct {
	// contains filtered or unexported fields
}

ApplicationGatewayWafDynamicManifestsClient contains the methods for the ApplicationGatewayWafDynamicManifests group. Don't use this type directly, use NewApplicationGatewayWafDynamicManifestsClient() instead.

func NewApplicationGatewayWafDynamicManifestsClient 

func NewApplicationGatewayWafDynamicManifestsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ApplicationGatewayWafDynamicManifestsClient, error)

NewApplicationGatewayWafDynamicManifestsClient creates a new instance of ApplicationGatewayWafDynamicManifestsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ApplicationGatewayWafDynamicManifestsClient) NewGetPager 

func (client *ApplicationGatewayWafDynamicManifestsClient) NewGetPager(location string, options *ApplicationGatewayWafDynamicManifestsClientGetOptions) *runtime.Pager[ApplicationGatewayWafDynamicManifestsClientGetResponse]

NewGetPager - Gets the regional application gateway waf manifest.

Generated from API version 2024-03-01

  • location - The region where the nrp are located at.
  • options - ApplicationGatewayWafDynamicManifestsClientGetOptions contains the optional parameters for the ApplicationGatewayWafDynamicManifestsClient.NewGetPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/GetApplicationGatewayWafDynamicManifests.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationGatewayWafDynamicManifestsClient().NewGetPager("westus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationGatewayWafDynamicManifestResultList = armnetwork.ApplicationGatewayWafDynamicManifestResultList{
	// 	Value: []*armnetwork.ApplicationGatewayWafDynamicManifestResult{
	// 		{
	// 			Name: to.Ptr("default"),
	// 			Type: to.Ptr("Microsoft.Network/applicationGatewayWafDynamicManifest"),
	// 			ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/applicationGatewayWafDynamicManifests/default"),
	// 			Properties: &armnetwork.ApplicationGatewayWafDynamicManifestPropertiesResult{
	// 				AvailableRuleSets: []*armnetwork.ApplicationGatewayFirewallManifestRuleSet{
	// 					{
	// 						RuleGroups: []*armnetwork.ApplicationGatewayFirewallRuleGroup{
	// 							{
	// 								Description: to.Ptr(""),
	// 								RuleGroupName: to.Ptr("General"),
	// 								Rules: []*armnetwork.ApplicationGatewayFirewallRule{
	// 									{
	// 										Description: to.Ptr("Failed to Parse Request Body."),
	// 										Action: to.Ptr(armnetwork.ApplicationGatewayWafRuleActionTypesAnomalyScoring),
	// 										RuleID: to.Ptr[int32](200002),
	// 										RuleIDString: to.Ptr("200002"),
	// 										State: to.Ptr(armnetwork.ApplicationGatewayWafRuleStateTypesEnabled),
	// 									},
	// 									{
	// 										Description: to.Ptr("Multipart Request Body Strict Validation."),
	// 										Action: to.Ptr(armnetwork.ApplicationGatewayWafRuleActionTypesAnomalyScoring),
	// 										RuleID: to.Ptr[int32](200003),
	// 										RuleIDString: to.Ptr("200003"),
	// 										State: to.Ptr(armnetwork.ApplicationGatewayWafRuleStateTypesEnabled),
	// 									},
	// 									{
	// 										Description: to.Ptr("Possible Multipart Unmatched Boundary."),
	// 										Action: to.Ptr(armnetwork.ApplicationGatewayWafRuleActionTypesAnomalyScoring),
	// 										RuleID: to.Ptr[int32](200004),
	// 										RuleIDString: to.Ptr("200004"),
	// 										State: to.Ptr(armnetwork.ApplicationGatewayWafRuleStateTypesEnabled),
	// 								}},
	// 						}},
	// 						RuleSetType: to.Ptr("OWASP"),
	// 						RuleSetVersion: to.Ptr("3.2"),
	// 						Status: to.Ptr(armnetwork.ApplicationGatewayRuleSetStatusOptions("0")),
	// 						Tiers: []*armnetwork.ApplicationGatewayTierTypes{
	// 							to.Ptr(armnetwork.ApplicationGatewayTierTypesWAFV2)},
	// 					}},
	// 					DefaultRuleSet: &armnetwork.DefaultRuleSetPropertyFormat{
	// 						RuleSetType: to.Ptr("OWASP"),
	// 						RuleSetVersion: to.Ptr("3.2"),
	// 					},
	// 				},
	// 		}},
	// 	}
}

type ApplicationGatewayWafDynamicManifestsClientGetOptions 

type ApplicationGatewayWafDynamicManifestsClientGetOptions struct {
}

ApplicationGatewayWafDynamicManifestsClientGetOptions contains the optional parameters for the ApplicationGatewayWafDynamicManifestsClient.NewGetPager method.

type ApplicationGatewayWafDynamicManifestsClientGetResponse 

type ApplicationGatewayWafDynamicManifestsClientGetResponse struct {
	// Response for ApplicationGatewayWafDynamicManifests API service call.
	ApplicationGatewayWafDynamicManifestResultList
}

ApplicationGatewayWafDynamicManifestsClientGetResponse contains the response from method ApplicationGatewayWafDynamicManifestsClient.NewGetPager.

type ApplicationGatewayWafDynamicManifestsDefaultClient 

type ApplicationGatewayWafDynamicManifestsDefaultClient struct {
	// contains filtered or unexported fields
}

ApplicationGatewayWafDynamicManifestsDefaultClient contains the methods for the ApplicationGatewayWafDynamicManifestsDefault group. Don't use this type directly, use NewApplicationGatewayWafDynamicManifestsDefaultClient() instead.

func NewApplicationGatewayWafDynamicManifestsDefaultClient 

func NewApplicationGatewayWafDynamicManifestsDefaultClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ApplicationGatewayWafDynamicManifestsDefaultClient, error)

NewApplicationGatewayWafDynamicManifestsDefaultClient creates a new instance of ApplicationGatewayWafDynamicManifestsDefaultClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ApplicationGatewayWafDynamicManifestsDefaultClient) Get 

func (client *ApplicationGatewayWafDynamicManifestsDefaultClient) Get(ctx context.Context, location string, options *ApplicationGatewayWafDynamicManifestsDefaultClientGetOptions) (ApplicationGatewayWafDynamicManifestsDefaultClientGetResponse, error)

Get - Gets the regional application gateway waf manifest. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • location - The region where the nrp are located at.
  • options - ApplicationGatewayWafDynamicManifestsDefaultClientGetOptions contains the optional parameters for the ApplicationGatewayWafDynamicManifestsDefaultClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/GetApplicationGatewayWafDynamicManifestsDefault.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewayWafDynamicManifestsDefaultClient().Get(ctx, "westus", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayWafDynamicManifestResult = armnetwork.ApplicationGatewayWafDynamicManifestResult{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.Network/applicationGatewayWafDynamicManifest"),
// 	ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/applicationGatewayWafDynamicManifests/default"),
// 	Properties: &armnetwork.ApplicationGatewayWafDynamicManifestPropertiesResult{
// 		AvailableRuleSets: []*armnetwork.ApplicationGatewayFirewallManifestRuleSet{
// 			{
// 				RuleGroups: []*armnetwork.ApplicationGatewayFirewallRuleGroup{
// 					{
// 						Description: to.Ptr(""),
// 						RuleGroupName: to.Ptr("General"),
// 						Rules: []*armnetwork.ApplicationGatewayFirewallRule{
// 							{
// 								Description: to.Ptr("Failed to Parse Request Body."),
// 								Action: to.Ptr(armnetwork.ApplicationGatewayWafRuleActionTypesAnomalyScoring),
// 								RuleID: to.Ptr[int32](200002),
// 								RuleIDString: to.Ptr("200002"),
// 								State: to.Ptr(armnetwork.ApplicationGatewayWafRuleStateTypesEnabled),
// 							},
// 							{
// 								Description: to.Ptr("Multipart Request Body Strict Validation."),
// 								Action: to.Ptr(armnetwork.ApplicationGatewayWafRuleActionTypesAnomalyScoring),
// 								RuleID: to.Ptr[int32](200003),
// 								RuleIDString: to.Ptr("200003"),
// 								State: to.Ptr(armnetwork.ApplicationGatewayWafRuleStateTypesEnabled),
// 							},
// 							{
// 								Description: to.Ptr("Possible Multipart Unmatched Boundary."),
// 								Action: to.Ptr(armnetwork.ApplicationGatewayWafRuleActionTypesAnomalyScoring),
// 								RuleID: to.Ptr[int32](200004),
// 								RuleIDString: to.Ptr("200004"),
// 								State: to.Ptr(armnetwork.ApplicationGatewayWafRuleStateTypesEnabled),
// 						}},
// 				}},
// 				RuleSetType: to.Ptr("OWASP"),
// 				RuleSetVersion: to.Ptr("3.2"),
// 				Status: to.Ptr(armnetwork.ApplicationGatewayRuleSetStatusOptions("0")),
// 				Tiers: []*armnetwork.ApplicationGatewayTierTypes{
// 					to.Ptr(armnetwork.ApplicationGatewayTierTypesWAFV2)},
// 			}},
// 			DefaultRuleSet: &armnetwork.DefaultRuleSetPropertyFormat{
// 				RuleSetType: to.Ptr("OWASP"),
// 				RuleSetVersion: to.Ptr("3.2"),
// 			},
// 		},
// 	}

type ApplicationGatewayWafDynamicManifestsDefaultClientGetOptions 

type ApplicationGatewayWafDynamicManifestsDefaultClientGetOptions struct {
}

ApplicationGatewayWafDynamicManifestsDefaultClientGetOptions contains the optional parameters for the ApplicationGatewayWafDynamicManifestsDefaultClient.Get method.

type ApplicationGatewayWafDynamicManifestsDefaultClientGetResponse 

type ApplicationGatewayWafDynamicManifestsDefaultClientGetResponse struct {
	// Response for ApplicationGatewayWafDynamicManifest API service call.
	ApplicationGatewayWafDynamicManifestResult
}

ApplicationGatewayWafDynamicManifestsDefaultClientGetResponse contains the response from method ApplicationGatewayWafDynamicManifestsDefaultClient.Get.

type ApplicationGatewayWafRuleActionTypes 

type ApplicationGatewayWafRuleActionTypes string

ApplicationGatewayWafRuleActionTypes - The string representation of the web application firewall rule action. 

const (
	ApplicationGatewayWafRuleActionTypesAllow          ApplicationGatewayWafRuleActionTypes = "Allow"
	ApplicationGatewayWafRuleActionTypesAnomalyScoring ApplicationGatewayWafRuleActionTypes = "AnomalyScoring"
	ApplicationGatewayWafRuleActionTypesBlock          ApplicationGatewayWafRuleActionTypes = "Block"
	ApplicationGatewayWafRuleActionTypesLog            ApplicationGatewayWafRuleActionTypes = "Log"
	ApplicationGatewayWafRuleActionTypesNone           ApplicationGatewayWafRuleActionTypes = "None"
)

func PossibleApplicationGatewayWafRuleActionTypesValues 

func PossibleApplicationGatewayWafRuleActionTypesValues() []ApplicationGatewayWafRuleActionTypes

PossibleApplicationGatewayWafRuleActionTypesValues returns the possible values for the ApplicationGatewayWafRuleActionTypes const type.

type ApplicationGatewayWafRuleSensitivityTypes 

type ApplicationGatewayWafRuleSensitivityTypes string

ApplicationGatewayWafRuleSensitivityTypes - The string representation of the web application firewall rule sensitivity. 

const (
	ApplicationGatewayWafRuleSensitivityTypesHigh   ApplicationGatewayWafRuleSensitivityTypes = "High"
	ApplicationGatewayWafRuleSensitivityTypesLow    ApplicationGatewayWafRuleSensitivityTypes = "Low"
	ApplicationGatewayWafRuleSensitivityTypesMedium ApplicationGatewayWafRuleSensitivityTypes = "Medium"
	ApplicationGatewayWafRuleSensitivityTypesNone   ApplicationGatewayWafRuleSensitivityTypes = "None"
)

func PossibleApplicationGatewayWafRuleSensitivityTypesValues 

func PossibleApplicationGatewayWafRuleSensitivityTypesValues() []ApplicationGatewayWafRuleSensitivityTypes

PossibleApplicationGatewayWafRuleSensitivityTypesValues returns the possible values for the ApplicationGatewayWafRuleSensitivityTypes const type.

type ApplicationGatewayWafRuleStateTypes 

type ApplicationGatewayWafRuleStateTypes string

ApplicationGatewayWafRuleStateTypes - The string representation of the web application firewall rule state. 

const (
	ApplicationGatewayWafRuleStateTypesDisabled ApplicationGatewayWafRuleStateTypes = "Disabled"
	ApplicationGatewayWafRuleStateTypesEnabled  ApplicationGatewayWafRuleStateTypes = "Enabled"
)

func PossibleApplicationGatewayWafRuleStateTypesValues 

func PossibleApplicationGatewayWafRuleStateTypesValues() []ApplicationGatewayWafRuleStateTypes

PossibleApplicationGatewayWafRuleStateTypesValues returns the possible values for the ApplicationGatewayWafRuleStateTypes const type.

type ApplicationGatewayWebApplicationFirewallConfiguration 

type ApplicationGatewayWebApplicationFirewallConfiguration struct {
	// REQUIRED; Whether the web application firewall is enabled or not.
	Enabled *bool

	// REQUIRED; Web application firewall mode.
	FirewallMode *ApplicationGatewayFirewallMode

	// REQUIRED; The type of the web application firewall rule set. Possible values are: 'OWASP'.
	RuleSetType *string

	// REQUIRED; The version of the rule set type.
	RuleSetVersion *string

	// The disabled rule groups.
	DisabledRuleGroups []*ApplicationGatewayFirewallDisabledRuleGroup

	// The exclusion list.
	Exclusions []*ApplicationGatewayFirewallExclusion

	// Maximum file upload size in Mb for WAF.
	FileUploadLimitInMb *int32

	// Maximum request body size for WAF.
	MaxRequestBodySize *int32

	// Maximum request body size in Kb for WAF.
	MaxRequestBodySizeInKb *int32

	// Whether allow WAF to check request Body.
	RequestBodyCheck *bool
}

ApplicationGatewayWebApplicationFirewallConfiguration - Application gateway web application firewall configuration.

func (ApplicationGatewayWebApplicationFirewallConfiguration) MarshalJSON 

func (a ApplicationGatewayWebApplicationFirewallConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationGatewayWebApplicationFirewallConfiguration.

func (*ApplicationGatewayWebApplicationFirewallConfiguration) UnmarshalJSON 

func (a *ApplicationGatewayWebApplicationFirewallConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationGatewayWebApplicationFirewallConfiguration.

type ApplicationGatewaysClient 

type ApplicationGatewaysClient struct {
	// contains filtered or unexported fields
}

ApplicationGatewaysClient contains the methods for the ApplicationGateways group. Don't use this type directly, use NewApplicationGatewaysClient() instead.

func NewApplicationGatewaysClient 

func NewApplicationGatewaysClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ApplicationGatewaysClient, error)

NewApplicationGatewaysClient creates a new instance of ApplicationGatewaysClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ApplicationGatewaysClient) BeginBackendHealth 

func (client *ApplicationGatewaysClient) BeginBackendHealth(ctx context.Context, resourceGroupName string, applicationGatewayName string, options *ApplicationGatewaysClientBeginBackendHealthOptions) (*runtime.Poller[ApplicationGatewaysClientBackendHealthResponse], error)

BeginBackendHealth - Gets the backend health of the specified application gateway in a resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewaysClientBeginBackendHealthOptions contains the optional parameters for the ApplicationGatewaysClient.BeginBackendHealth method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayBackendHealthGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewaysClient().BeginBackendHealth(ctx, "appgw", "appgw", &armnetwork.ApplicationGatewaysClientBeginBackendHealthOptions{Expand: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayBackendHealth = armnetwork.ApplicationGatewayBackendHealth{
// 	BackendAddressPools: []*armnetwork.ApplicationGatewayBackendHealthPool{
// 		{
// 			BackendAddressPool: &armnetwork.ApplicationGatewayBackendAddressPool{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendaddressPools/MFAnalyticsPool"),
// 			},
// 			BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHealthHTTPSettings{
// 				{
// 					BackendHTTPSettings: &armnetwork.ApplicationGatewayBackendHTTPSettings{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/MFPoolSettings"),
// 					},
// 					Servers: []*armnetwork.ApplicationGatewayBackendHealthServer{
// 						{
// 							Address: to.Ptr("10.220.1.8"),
// 							Health: to.Ptr(armnetwork.ApplicationGatewayBackendHealthServerHealthUp),
// 					}},
// 			}},
// 		},
// 		{
// 			BackendAddressPool: &armnetwork.ApplicationGatewayBackendAddressPool{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendaddressPools/MFPool"),
// 			},
// 			BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHealthHTTPSettings{
// 				{
// 					BackendHTTPSettings: &armnetwork.ApplicationGatewayBackendHTTPSettings{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/MFPoolSettings"),
// 					},
// 					Servers: []*armnetwork.ApplicationGatewayBackendHealthServer{
// 						{
// 							Address: to.Ptr("10.220.1.4"),
// 							Health: to.Ptr(armnetwork.ApplicationGatewayBackendHealthServerHealthUp),
// 						},
// 						{
// 							Address: to.Ptr("10.220.1.5"),
// 							Health: to.Ptr(armnetwork.ApplicationGatewayBackendHealthServerHealthUp),
// 					}},
// 			}},
// 	}},
// }

func (*ApplicationGatewaysClient) BeginBackendHealthOnDemand 

func (client *ApplicationGatewaysClient) BeginBackendHealthOnDemand(ctx context.Context, resourceGroupName string, applicationGatewayName string, probeRequest ApplicationGatewayOnDemandProbe, options *ApplicationGatewaysClientBeginBackendHealthOnDemandOptions) (*runtime.Poller[ApplicationGatewaysClientBackendHealthOnDemandResponse], error)

BeginBackendHealthOnDemand - Gets the backend health for given combination of backend pool and http setting of the specified application gateway in a resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • probeRequest - Request body for on-demand test probe operation.
  • options - ApplicationGatewaysClientBeginBackendHealthOnDemandOptions contains the optional parameters for the ApplicationGatewaysClient.BeginBackendHealthOnDemand method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayBackendHealthTest.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewaysClient().BeginBackendHealthOnDemand(ctx, "rg1", "appgw", armnetwork.ApplicationGatewayOnDemandProbe{
	Path: to.Ptr("/"),
	BackendAddressPool: &armnetwork.SubResource{
		ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendaddressPools/MFAnalyticsPool"),
	},
	BackendHTTPSettings: &armnetwork.SubResource{
		ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/MFPoolSettings"),
	},
	PickHostNameFromBackendHTTPSettings: to.Ptr(true),
	Timeout:                             to.Ptr[int32](30),
	Protocol:                            to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
}, &armnetwork.ApplicationGatewaysClientBeginBackendHealthOnDemandOptions{Expand: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayBackendHealthOnDemand = armnetwork.ApplicationGatewayBackendHealthOnDemand{
// 	BackendAddressPool: &armnetwork.ApplicationGatewayBackendAddressPool{
// 		ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendaddressPools/MFAnalyticsPool"),
// 	},
// 	BackendHealthHTTPSettings: &armnetwork.ApplicationGatewayBackendHealthHTTPSettings{
// 		BackendHTTPSettings: &armnetwork.ApplicationGatewayBackendHTTPSettings{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/MFPoolSettings"),
// 		},
// 		Servers: []*armnetwork.ApplicationGatewayBackendHealthServer{
// 			{
// 				Address: to.Ptr("10.220.1.4"),
// 				Health: to.Ptr(armnetwork.ApplicationGatewayBackendHealthServerHealthUp),
// 			},
// 			{
// 				Address: to.Ptr("10.220.1.5"),
// 				Health: to.Ptr(armnetwork.ApplicationGatewayBackendHealthServerHealthUp),
// 		}},
// 	},
// }

func (*ApplicationGatewaysClient) BeginCreateOrUpdate 

func (client *ApplicationGatewaysClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, applicationGatewayName string, parameters ApplicationGateway, options *ApplicationGatewaysClientBeginCreateOrUpdateOptions) (*runtime.Poller[ApplicationGatewaysClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the specified application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • parameters - Parameters supplied to the create or update application gateway operation.
  • options - ApplicationGatewaysClientBeginCreateOrUpdateOptions contains the optional parameters for the ApplicationGatewaysClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewaysClient().BeginCreateOrUpdate(ctx, "rg1", "appgw", armnetwork.ApplicationGateway{
	Location: to.Ptr("eastus"),
	Identity: &armnetwork.ManagedServiceIdentity{
		Type: to.Ptr(armnetwork.ResourceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armnetwork.Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties{
			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
		},
	},
	Properties: &armnetwork.ApplicationGatewayPropertiesFormat{
		BackendAddressPools: []*armnetwork.ApplicationGatewayBackendAddressPool{
			{
				Name: to.Ptr("appgwpool"),
				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
						{
							IPAddress: to.Ptr("10.0.1.1"),
						},
						{
							IPAddress: to.Ptr("10.0.1.2"),
						}},
				},
			},
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
				Name: to.Ptr("appgwpool1"),
				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
						{
							IPAddress: to.Ptr("10.0.0.1"),
						},
						{
							IPAddress: to.Ptr("10.0.0.2"),
						}},
				},
			}},
		BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHTTPSettings{
			{
				Name: to.Ptr("appgwbhs"),
				Properties: &armnetwork.ApplicationGatewayBackendHTTPSettingsPropertiesFormat{
					CookieBasedAffinity: to.Ptr(armnetwork.ApplicationGatewayCookieBasedAffinityDisabled),
					Port:                to.Ptr[int32](80),
					RequestTimeout:      to.Ptr[int32](30),
					Protocol:            to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
				},
			}},
		FrontendIPConfigurations: []*armnetwork.ApplicationGatewayFrontendIPConfiguration{
			{
				Name: to.Ptr("appgwfip"),
				Properties: &armnetwork.ApplicationGatewayFrontendIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/appgwpip"),
					},
				},
			}},
		FrontendPorts: []*armnetwork.ApplicationGatewayFrontendPort{
			{
				Name: to.Ptr("appgwfp"),
				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
					Port: to.Ptr[int32](443),
				},
			},
			{
				Name: to.Ptr("appgwfp80"),
				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
					Port: to.Ptr[int32](80),
				},
			}},
		GatewayIPConfigurations: []*armnetwork.ApplicationGatewayIPConfiguration{
			{
				Name: to.Ptr("appgwipc"),
				Properties: &armnetwork.ApplicationGatewayIPConfigurationPropertiesFormat{
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet/subnets/appgwsubnet"),
					},
				},
			}},
		GlobalConfiguration: &armnetwork.ApplicationGatewayGlobalConfiguration{
			EnableRequestBuffering:  to.Ptr(true),
			EnableResponseBuffering: to.Ptr(true),
		},
		HTTPListeners: []*armnetwork.ApplicationGatewayHTTPListener{
			{
				Name: to.Ptr("appgwhl"),
				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
					FrontendIPConfiguration: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
					},
					FrontendPort: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
					},
					RequireServerNameIndication: to.Ptr(false),
					SSLCertificate: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
					},
					SSLProfile: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
					},
					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTPS),
				},
			},
			{
				Name: to.Ptr("appgwhttplistener"),
				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
					FrontendIPConfiguration: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
					},
					FrontendPort: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
					},
					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
				},
			}},
		RequestRoutingRules: []*armnetwork.ApplicationGatewayRequestRoutingRule{
			{
				Name: to.Ptr("appgwrule"),
				Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
					BackendAddressPool: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
					},
					BackendHTTPSettings: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
					},
					HTTPListener: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
					},
					Priority: to.Ptr[int32](10),
					RewriteRuleSet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
					},
					RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypeBasic),
				},
			}},
		RewriteRuleSets: []*armnetwork.ApplicationGatewayRewriteRuleSet{
			{
				Name: to.Ptr("rewriteRuleSet1"),
				Properties: &armnetwork.ApplicationGatewayRewriteRuleSetPropertiesFormat{
					RewriteRules: []*armnetwork.ApplicationGatewayRewriteRule{
						{
							Name: to.Ptr("Set X-Forwarded-For"),
							ActionSet: &armnetwork.ApplicationGatewayRewriteRuleActionSet{
								RequestHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
									{
										HeaderName:  to.Ptr("X-Forwarded-For"),
										HeaderValue: to.Ptr("{var_add_x_forwarded_for_proxy}"),
									}},
								ResponseHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
									{
										HeaderName:  to.Ptr("Strict-Transport-Security"),
										HeaderValue: to.Ptr("max-age=31536000"),
									}},
								URLConfiguration: &armnetwork.ApplicationGatewayURLConfiguration{
									ModifiedPath: to.Ptr("/abc"),
								},
							},
							Conditions: []*armnetwork.ApplicationGatewayRewriteRuleCondition{
								{
									IgnoreCase: to.Ptr(true),
									Negate:     to.Ptr(false),
									Pattern:    to.Ptr("^Bearer"),
									Variable:   to.Ptr("http_req_Authorization"),
								}},
							RuleSequence: to.Ptr[int32](102),
						}},
				},
			}},
		SKU: &armnetwork.ApplicationGatewaySKU{
			Name:     to.Ptr(armnetwork.ApplicationGatewaySKUNameStandardV2),
			Capacity: to.Ptr[int32](3),
			Tier:     to.Ptr(armnetwork.ApplicationGatewayTierStandardV2),
		},
		SSLCertificates: []*armnetwork.ApplicationGatewaySSLCertificate{
			{
				Name: to.Ptr("sslcert"),
				Properties: &armnetwork.ApplicationGatewaySSLCertificatePropertiesFormat{
					Data:     to.Ptr("****"),
					Password: to.Ptr("****"),
				},
			},
			{
				Name: to.Ptr("sslcert2"),
				Properties: &armnetwork.ApplicationGatewaySSLCertificatePropertiesFormat{
					KeyVaultSecretID: to.Ptr("https://kv/secret"),
				},
			}},
		SSLProfiles: []*armnetwork.ApplicationGatewaySSLProfile{
			{
				Name: to.Ptr("sslProfile1"),
				Properties: &armnetwork.ApplicationGatewaySSLProfilePropertiesFormat{
					ClientAuthConfiguration: &armnetwork.ApplicationGatewayClientAuthConfiguration{
						VerifyClientCertIssuerDN: to.Ptr(true),
					},
					SSLPolicy: &armnetwork.ApplicationGatewaySSLPolicy{
						CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256)},
						MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
						PolicyType:         to.Ptr(armnetwork.ApplicationGatewaySSLPolicyTypeCustom),
					},
					TrustedClientCertificates: []*armnetwork.SubResource{
						{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
						}},
				},
			}},
		TrustedClientCertificates: []*armnetwork.ApplicationGatewayTrustedClientCertificate{
			{
				Name: to.Ptr("clientcert"),
				Properties: &armnetwork.ApplicationGatewayTrustedClientCertificatePropertiesFormat{
					Data: to.Ptr("****"),
				},
			}},
		TrustedRootCertificates: []*armnetwork.ApplicationGatewayTrustedRootCertificate{
			{
				Name: to.Ptr("rootcert"),
				Properties: &armnetwork.ApplicationGatewayTrustedRootCertificatePropertiesFormat{
					Data: to.Ptr("****"),
				},
			},
			{
				Name: to.Ptr("rootcert1"),
				Properties: &armnetwork.ApplicationGatewayTrustedRootCertificatePropertiesFormat{
					KeyVaultSecretID: to.Ptr("https://kv/secret"),
				},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGateway = armnetwork.ApplicationGateway{
// 	Name: to.Ptr("appgw"),
// 	Type: to.Ptr("Microsoft.Network/applicationGateways"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw"),
// 	Location: to.Ptr("southcentralus"),
// 	Properties: &armnetwork.ApplicationGatewayPropertiesFormat{
// 		AuthenticationCertificates: []*armnetwork.ApplicationGatewayAuthenticationCertificate{
// 		},
// 		BackendAddressPools: []*armnetwork.ApplicationGatewayBackendAddressPool{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 				Name: to.Ptr("appgwpool"),
// 				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
// 					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
// 						{
// 							IPAddress: to.Ptr("10.0.1.1"),
// 						},
// 						{
// 							IPAddress: to.Ptr("10.0.1.2"),
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
// 				Name: to.Ptr("appgwpool1"),
// 				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
// 					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
// 						{
// 							IPAddress: to.Ptr("10.0.0.1"),
// 						},
// 						{
// 							IPAddress: to.Ptr("10.0.0.2"),
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHTTPSettings{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
// 				Name: to.Ptr("appgwbhs"),
// 				Properties: &armnetwork.ApplicationGatewayBackendHTTPSettingsPropertiesFormat{
// 					CookieBasedAffinity: to.Ptr(armnetwork.ApplicationGatewayCookieBasedAffinityDisabled),
// 					Port: to.Ptr[int32](80),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RequestTimeout: to.Ptr[int32](30),
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
// 				},
// 		}},
// 		FrontendIPConfigurations: []*armnetwork.ApplicationGatewayFrontendIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
// 				Name: to.Ptr("appgwfip"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/appgwpip"),
// 					},
// 				},
// 		}},
// 		FrontendPorts: []*armnetwork.ApplicationGatewayFrontendPort{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
// 				Name: to.Ptr("appgwfp"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
// 					Port: to.Ptr[int32](443),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
// 				Name: to.Ptr("appgwfp80"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
// 					Port: to.Ptr[int32](80),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		GatewayIPConfigurations: []*armnetwork.ApplicationGatewayIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/gatewayIPConfigurations/appgwipc"),
// 				Name: to.Ptr("appgwipc"),
// 				Properties: &armnetwork.ApplicationGatewayIPConfigurationPropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
// 					},
// 				},
// 		}},
// 		GlobalConfiguration: &armnetwork.ApplicationGatewayGlobalConfiguration{
// 			EnableRequestBuffering: to.Ptr(true),
// 			EnableResponseBuffering: to.Ptr(true),
// 		},
// 		HTTPListeners: []*armnetwork.ApplicationGatewayHTTPListener{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
// 				Name: to.Ptr("appgwhl"),
// 				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
// 					FrontendIPConfiguration: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
// 					},
// 					FrontendPort: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RequireServerNameIndication: to.Ptr(false),
// 					SSLCertificate: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
// 					},
// 					SSLProfile: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
// 					},
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTPS),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
// 				Name: to.Ptr("appgwhttplistener"),
// 				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
// 					FrontendIPConfiguration: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
// 					},
// 					FrontendPort: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
// 				},
// 		}},
// 		Listeners: []*armnetwork.ApplicationGatewayListener{
// 		},
// 		LoadDistributionPolicies: []*armnetwork.ApplicationGatewayLoadDistributionPolicy{
// 		},
// 		OperationalState: to.Ptr(armnetwork.ApplicationGatewayOperationalStateRunning),
// 		PrivateEndpointConnections: []*armnetwork.ApplicationGatewayPrivateEndpointConnection{
// 		},
// 		Probes: []*armnetwork.ApplicationGatewayProbe{
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		RedirectConfigurations: []*armnetwork.ApplicationGatewayRedirectConfiguration{
// 		},
// 		RequestRoutingRules: []*armnetwork.ApplicationGatewayRequestRoutingRule{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwrule"),
// 				Name: to.Ptr("appgwrule"),
// 				Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
// 					BackendAddressPool: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 					},
// 					BackendHTTPSettings: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
// 					},
// 					HTTPListener: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RewriteRuleSet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
// 					},
// 					RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypeBasic),
// 				},
// 		}},
// 		RewriteRuleSets: []*armnetwork.ApplicationGatewayRewriteRuleSet{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
// 				Name: to.Ptr("rewriteRuleSet1"),
// 				Properties: &armnetwork.ApplicationGatewayRewriteRuleSetPropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RewriteRules: []*armnetwork.ApplicationGatewayRewriteRule{
// 						{
// 							Name: to.Ptr("Set X-Forwarded-For"),
// 							ActionSet: &armnetwork.ApplicationGatewayRewriteRuleActionSet{
// 								RequestHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
// 									{
// 										HeaderName: to.Ptr("X-Forwarded-For"),
// 										HeaderValue: to.Ptr("{var_remote-addr}"),
// 								}},
// 								ResponseHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
// 									{
// 										HeaderName: to.Ptr("Strict-Transport-Security"),
// 										HeaderValue: to.Ptr("max-age=31536000"),
// 								}},
// 								URLConfiguration: &armnetwork.ApplicationGatewayURLConfiguration{
// 									ModifiedPath: to.Ptr("/abc"),
// 									ModifiedQueryString: to.Ptr("x=y&a=b"),
// 								},
// 							},
// 							Conditions: []*armnetwork.ApplicationGatewayRewriteRuleCondition{
// 								{
// 									IgnoreCase: to.Ptr(true),
// 									Negate: to.Ptr(false),
// 									Pattern: to.Ptr("^Bearer"),
// 									Variable: to.Ptr("http_req_Authorization"),
// 							}},
// 							RuleSequence: to.Ptr[int32](102),
// 					}},
// 				},
// 		}},
// 		RoutingRules: []*armnetwork.ApplicationGatewayRoutingRule{
// 		},
// 		SKU: &armnetwork.ApplicationGatewaySKU{
// 			Name: to.Ptr(armnetwork.ApplicationGatewaySKUNameStandardMedium),
// 			Capacity: to.Ptr[int32](3),
// 			Tier: to.Ptr(armnetwork.ApplicationGatewayTierStandard),
// 		},
// 		SSLCertificates: []*armnetwork.ApplicationGatewaySSLCertificate{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
// 				Name: to.Ptr("sslcert"),
// 				Properties: &armnetwork.ApplicationGatewaySSLCertificatePropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicCertData: to.Ptr("*****"),
// 				},
// 		}},
// 		SSLProfiles: []*armnetwork.ApplicationGatewaySSLProfile{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
// 				Name: to.Ptr("sslProfile1"),
// 				Properties: &armnetwork.ApplicationGatewaySSLProfilePropertiesFormat{
// 					ClientAuthConfiguration: &armnetwork.ApplicationGatewayClientAuthConfiguration{
// 						VerifyClientCertIssuerDN: to.Ptr(true),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					SSLPolicy: &armnetwork.ApplicationGatewaySSLPolicy{
// 						CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256)},
// 							MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
// 							PolicyType: to.Ptr(armnetwork.ApplicationGatewaySSLPolicyTypeCustom),
// 						},
// 						TrustedClientCertificates: []*armnetwork.SubResource{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
// 						}},
// 					},
// 			}},
// 			TrustedClientCertificates: []*armnetwork.ApplicationGatewayTrustedClientCertificate{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
// 					Name: to.Ptr("clientcert"),
// 					Properties: &armnetwork.ApplicationGatewayTrustedClientCertificatePropertiesFormat{
// 						Data: to.Ptr("****"),
// 						ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					},
// 			}},
// 			URLPathMaps: []*armnetwork.ApplicationGatewayURLPathMap{
// 			},
// 		},
// 	}

func (*ApplicationGatewaysClient) BeginDelete 

func (client *ApplicationGatewaysClient) BeginDelete(ctx context.Context, resourceGroupName string, applicationGatewayName string, options *ApplicationGatewaysClientBeginDeleteOptions) (*runtime.Poller[ApplicationGatewaysClientDeleteResponse], error)

BeginDelete - Deletes the specified application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewaysClientBeginDeleteOptions contains the optional parameters for the ApplicationGatewaysClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewaysClient().BeginDelete(ctx, "rg1", "appgw", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ApplicationGatewaysClient) BeginStart 

func (client *ApplicationGatewaysClient) BeginStart(ctx context.Context, resourceGroupName string, applicationGatewayName string, options *ApplicationGatewaysClientBeginStartOptions) (*runtime.Poller[ApplicationGatewaysClientStartResponse], error)

BeginStart - Starts the specified application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewaysClientBeginStartOptions contains the optional parameters for the ApplicationGatewaysClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayStart.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewaysClient().BeginStart(ctx, "rg1", "appgw", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ApplicationGatewaysClient) BeginStop 

func (client *ApplicationGatewaysClient) BeginStop(ctx context.Context, resourceGroupName string, applicationGatewayName string, options *ApplicationGatewaysClientBeginStopOptions) (*runtime.Poller[ApplicationGatewaysClientStopResponse], error)

BeginStop - Stops the specified application gateway in a resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewaysClientBeginStopOptions contains the optional parameters for the ApplicationGatewaysClient.BeginStop method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayStop.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationGatewaysClient().BeginStop(ctx, "rg1", "appgw", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ApplicationGatewaysClient) Get 

func (client *ApplicationGatewaysClient) Get(ctx context.Context, resourceGroupName string, applicationGatewayName string, options *ApplicationGatewaysClientGetOptions) (ApplicationGatewaysClientGetResponse, error)

Get - Gets the specified application gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • options - ApplicationGatewaysClientGetOptions contains the optional parameters for the ApplicationGatewaysClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().Get(ctx, "rg1", "appgw", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGateway = armnetwork.ApplicationGateway{
// 	Name: to.Ptr("appgw"),
// 	Type: to.Ptr("Microsoft.Network/applicationGateways"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw"),
// 	Location: to.Ptr("southcentralus"),
// 	Properties: &armnetwork.ApplicationGatewayPropertiesFormat{
// 		AuthenticationCertificates: []*armnetwork.ApplicationGatewayAuthenticationCertificate{
// 		},
// 		BackendAddressPools: []*armnetwork.ApplicationGatewayBackendAddressPool{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 				Name: to.Ptr("appgwpool"),
// 				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
// 					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
// 				Name: to.Ptr("appgwpool1"),
// 				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
// 					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
// 						{
// 						},
// 						{
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHTTPSettings{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
// 				Name: to.Ptr("appgwbhs"),
// 				Properties: &armnetwork.ApplicationGatewayBackendHTTPSettingsPropertiesFormat{
// 					CookieBasedAffinity: to.Ptr(armnetwork.ApplicationGatewayCookieBasedAffinityDisabled),
// 					Port: to.Ptr[int32](80),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RequestTimeout: to.Ptr[int32](30),
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
// 				},
// 		}},
// 		FrontendIPConfigurations: []*armnetwork.ApplicationGatewayFrontendIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
// 				Name: to.Ptr("appgwfip"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/appgwpip"),
// 					},
// 				},
// 		}},
// 		FrontendPorts: []*armnetwork.ApplicationGatewayFrontendPort{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
// 				Name: to.Ptr("appgwfp"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
// 					Port: to.Ptr[int32](443),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
// 				Name: to.Ptr("appgwfp80"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
// 					Port: to.Ptr[int32](80),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		GatewayIPConfigurations: []*armnetwork.ApplicationGatewayIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/gatewayIPConfigurations/appgwipc"),
// 				Name: to.Ptr("appgwipc"),
// 				Properties: &armnetwork.ApplicationGatewayIPConfigurationPropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
// 					},
// 				},
// 		}},
// 		GlobalConfiguration: &armnetwork.ApplicationGatewayGlobalConfiguration{
// 			EnableRequestBuffering: to.Ptr(true),
// 			EnableResponseBuffering: to.Ptr(true),
// 		},
// 		HTTPListeners: []*armnetwork.ApplicationGatewayHTTPListener{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
// 				Name: to.Ptr("appgwhl"),
// 				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
// 					FrontendIPConfiguration: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
// 					},
// 					FrontendPort: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RequireServerNameIndication: to.Ptr(false),
// 					SSLCertificate: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
// 					},
// 					SSLProfile: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
// 					},
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTPS),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
// 				Name: to.Ptr("appgwhttplistener"),
// 				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
// 					FrontendIPConfiguration: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
// 					},
// 					FrontendPort: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
// 				},
// 		}},
// 		LoadDistributionPolicies: []*armnetwork.ApplicationGatewayLoadDistributionPolicy{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
// 				Name: to.Ptr("ldp1"),
// 				Properties: &armnetwork.ApplicationGatewayLoadDistributionPolicyPropertiesFormat{
// 					LoadDistributionAlgorithm: to.Ptr(armnetwork.ApplicationGatewayLoadDistributionAlgorithmRoundRobin),
// 					LoadDistributionTargets: []*armnetwork.ApplicationGatewayLoadDistributionTarget{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1/loadDistributionTargets/ldt1"),
// 							Name: to.Ptr("ld11"),
// 							Properties: &armnetwork.ApplicationGatewayLoadDistributionTargetPropertiesFormat{
// 								BackendAddressPool: &armnetwork.SubResource{
// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 								},
// 								WeightPerServer: to.Ptr[int32](40),
// 							},
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1/loadDistributionTargets/ldt1"),
// 							Name: to.Ptr("ld11"),
// 							Properties: &armnetwork.ApplicationGatewayLoadDistributionTargetPropertiesFormat{
// 								BackendAddressPool: &armnetwork.SubResource{
// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
// 								},
// 								WeightPerServer: to.Ptr[int32](60),
// 							},
// 					}},
// 				},
// 		}},
// 		OperationalState: to.Ptr(armnetwork.ApplicationGatewayOperationalStateRunning),
// 		PrivateEndpointConnections: []*armnetwork.ApplicationGatewayPrivateEndpointConnection{
// 		},
// 		PrivateLinkConfigurations: []*armnetwork.ApplicationGatewayPrivateLinkConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1"),
// 				Name: to.Ptr("privateLink1"),
// 				Properties: &armnetwork.ApplicationGatewayPrivateLinkConfigurationProperties{
// 					IPConfigurations: []*armnetwork.ApplicationGatewayPrivateLinkIPConfiguration{
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1/privateLinkConfigurations/privateLink1/ipConfigurations/natNicIpconfig1"),
// 							Name: to.Ptr("natNicIpconfig1"),
// 							Properties: &armnetwork.ApplicationGatewayPrivateLinkIPConfigurationProperties{
// 								Primary: to.Ptr(true),
// 								PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 								ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 								Subnet: &armnetwork.SubResource{
// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
// 								},
// 							},
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1/privateLinkConfigurations/privateLink1/ipConfigurations/natNicIpconfig2"),
// 							Name: to.Ptr("natNicIpconfig2"),
// 							Properties: &armnetwork.ApplicationGatewayPrivateLinkIPConfigurationProperties{
// 								PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 								ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 								Subnet: &armnetwork.SubResource{
// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
// 								},
// 							},
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		Probes: []*armnetwork.ApplicationGatewayProbe{
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		RequestRoutingRules: []*armnetwork.ApplicationGatewayRequestRoutingRule{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwrule"),
// 				Name: to.Ptr("appgwrule"),
// 				Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
// 					BackendAddressPool: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 					},
// 					BackendHTTPSettings: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
// 					},
// 					HTTPListener: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
// 					},
// 					LoadDistributionPolicy: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
// 					},
// 					Priority: to.Ptr[int32](10),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RewriteRuleSet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
// 					},
// 					RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypeBasic),
// 				},
// 			},
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwPathBasedRule"),
// 				Name: to.Ptr("appgwPathBasedRule"),
// 				Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
// 					HTTPListener: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
// 					},
// 					Priority: to.Ptr[int32](20),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypePathBasedRouting),
// 					URLPathMap: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1"),
// 					},
// 				},
// 		}},
// 		RewriteRuleSets: []*armnetwork.ApplicationGatewayRewriteRuleSet{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
// 				Name: to.Ptr("rewriteRuleSet1"),
// 				Properties: &armnetwork.ApplicationGatewayRewriteRuleSetPropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RewriteRules: []*armnetwork.ApplicationGatewayRewriteRule{
// 						{
// 							Name: to.Ptr("Set X-Forwarded-For"),
// 							ActionSet: &armnetwork.ApplicationGatewayRewriteRuleActionSet{
// 								RequestHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
// 									{
// 										HeaderName: to.Ptr("X-Forwarded-For"),
// 										HeaderValue: to.Ptr("{var_remote-addr}"),
// 								}},
// 								ResponseHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
// 									{
// 										HeaderName: to.Ptr("Strict-Transport-Security"),
// 										HeaderValue: to.Ptr("max-age=31536000"),
// 								}},
// 								URLConfiguration: &armnetwork.ApplicationGatewayURLConfiguration{
// 									ModifiedPath: to.Ptr("/abc"),
// 									ModifiedQueryString: to.Ptr("x=y&a=b"),
// 									Reroute: to.Ptr(false),
// 								},
// 							},
// 							Conditions: []*armnetwork.ApplicationGatewayRewriteRuleCondition{
// 								{
// 									IgnoreCase: to.Ptr(true),
// 									Negate: to.Ptr(false),
// 									Pattern: to.Ptr("^Bearer"),
// 									Variable: to.Ptr("http_req_Authorization"),
// 							}},
// 							RuleSequence: to.Ptr[int32](102),
// 					}},
// 				},
// 		}},
// 		SKU: &armnetwork.ApplicationGatewaySKU{
// 			Name: to.Ptr(armnetwork.ApplicationGatewaySKUNameStandardMedium),
// 			Capacity: to.Ptr[int32](3),
// 			Tier: to.Ptr(armnetwork.ApplicationGatewayTierStandard),
// 		},
// 		SSLCertificates: []*armnetwork.ApplicationGatewaySSLCertificate{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
// 				Name: to.Ptr("sslcert"),
// 				Properties: &armnetwork.ApplicationGatewaySSLCertificatePropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicCertData: to.Ptr("*****"),
// 				},
// 		}},
// 		SSLProfiles: []*armnetwork.ApplicationGatewaySSLProfile{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
// 				Name: to.Ptr("sslProfile1"),
// 				Properties: &armnetwork.ApplicationGatewaySSLProfilePropertiesFormat{
// 					ClientAuthConfiguration: &armnetwork.ApplicationGatewayClientAuthConfiguration{
// 						VerifyClientCertIssuerDN: to.Ptr(true),
// 						VerifyClientRevocation: to.Ptr(armnetwork.ApplicationGatewayClientRevocationOptionsOCSP),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					SSLPolicy: &armnetwork.ApplicationGatewaySSLPolicy{
// 						CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256)},
// 							MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
// 							PolicyType: to.Ptr(armnetwork.ApplicationGatewaySSLPolicyTypeCustom),
// 						},
// 						TrustedClientCertificates: []*armnetwork.SubResource{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
// 						}},
// 					},
// 			}},
// 			TrustedClientCertificates: []*armnetwork.ApplicationGatewayTrustedClientCertificate{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
// 					Name: to.Ptr("clientcert"),
// 					Properties: &armnetwork.ApplicationGatewayTrustedClientCertificatePropertiesFormat{
// 						ClientCertIssuerDN: to.Ptr("CN=User1, OU=Eng, O=Company Ltd, L=D4, S=Arizona, C=US"),
// 						Data: to.Ptr("****"),
// 						ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 						ValidatedCertData: to.Ptr("****"),
// 					},
// 			}},
// 			URLPathMaps: []*armnetwork.ApplicationGatewayURLPathMap{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1"),
// 					Name: to.Ptr("pathMap1"),
// 					Properties: &armnetwork.ApplicationGatewayURLPathMapPropertiesFormat{
// 						DefaultBackendAddressPool: &armnetwork.SubResource{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 						},
// 						DefaultBackendHTTPSettings: &armnetwork.SubResource{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
// 						},
// 						DefaultLoadDistributionPolicy: &armnetwork.SubResource{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
// 						},
// 						DefaultRewriteRuleSet: &armnetwork.SubResource{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
// 						},
// 						PathRules: []*armnetwork.ApplicationGatewayPathRule{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1/pathRules/apiPaths"),
// 								Name: to.Ptr("apiPaths"),
// 								Properties: &armnetwork.ApplicationGatewayPathRulePropertiesFormat{
// 									BackendAddressPool: &armnetwork.SubResource{
// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
// 									},
// 									BackendHTTPSettings: &armnetwork.SubResource{
// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
// 									},
// 									LoadDistributionPolicy: &armnetwork.SubResource{
// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
// 									},
// 									Paths: []*string{
// 										to.Ptr("/api"),
// 										to.Ptr("/v1/api")},
// 										ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 										RewriteRuleSet: &armnetwork.SubResource{
// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
// 										},
// 									},
// 							}},
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 						},
// 				}},
// 			},
// 		}

func (*ApplicationGatewaysClient) GetSSLPredefinedPolicy 

func (client *ApplicationGatewaysClient) GetSSLPredefinedPolicy(ctx context.Context, predefinedPolicyName string, options *ApplicationGatewaysClientGetSSLPredefinedPolicyOptions) (ApplicationGatewaysClientGetSSLPredefinedPolicyResponse, error)

GetSSLPredefinedPolicy - Gets Ssl predefined policy with the specified policy name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • predefinedPolicyName - Name of Ssl predefined policy.
  • options - ApplicationGatewaysClientGetSSLPredefinedPolicyOptions contains the optional parameters for the ApplicationGatewaysClient.GetSSLPredefinedPolicy method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableSslOptionsPredefinedPolicyGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().GetSSLPredefinedPolicy(ctx, "AppGwSslPolicy20150501", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewaySSLPredefinedPolicy = armnetwork.ApplicationGatewaySSLPredefinedPolicy{
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20150501"),
// 	Name: to.Ptr("AppGwSslPolicy20150501"),
// 	Properties: &armnetwork.ApplicationGatewaySSLPredefinedPolicyPropertiesFormat{
// 		CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITH3DESEDECBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITH3DESEDECBCSHA)},
// 			MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv10),
// 		},
// 	}

func (*ApplicationGatewaysClient) ListAvailableRequestHeaders 

func (client *ApplicationGatewaysClient) ListAvailableRequestHeaders(ctx context.Context, options *ApplicationGatewaysClientListAvailableRequestHeadersOptions) (ApplicationGatewaysClientListAvailableRequestHeadersResponse, error)

ListAvailableRequestHeaders - Lists all available request headers. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAvailableRequestHeadersOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableRequestHeaders method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableRequestHeadersGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().ListAvailableRequestHeaders(ctx, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.StringArray = []*string{
// 	to.Ptr("Accept-Charset")}

func (*ApplicationGatewaysClient) ListAvailableResponseHeaders 

func (client *ApplicationGatewaysClient) ListAvailableResponseHeaders(ctx context.Context, options *ApplicationGatewaysClientListAvailableResponseHeadersOptions) (ApplicationGatewaysClientListAvailableResponseHeadersResponse, error)

ListAvailableResponseHeaders - Lists all available response headers. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAvailableResponseHeadersOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableResponseHeaders method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableResponseHeadersGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().ListAvailableResponseHeaders(ctx, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.StringArray = []*string{
// 	to.Ptr("Access-Control-Allow-Origin")}

func (*ApplicationGatewaysClient) ListAvailableSSLOptions 

func (client *ApplicationGatewaysClient) ListAvailableSSLOptions(ctx context.Context, options *ApplicationGatewaysClientListAvailableSSLOptionsOptions) (ApplicationGatewaysClientListAvailableSSLOptionsResponse, error)

ListAvailableSSLOptions - Lists available Ssl options for configuring Ssl policy. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAvailableSSLOptionsOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableSSLOptions method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableSslOptionsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().ListAvailableSSLOptions(ctx, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayAvailableSSLOptions = armnetwork.ApplicationGatewayAvailableSSLOptions{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.Network/ApplicationGatewayAvailableSslOptions"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default"),
// 	Properties: &armnetwork.ApplicationGatewayAvailableSSLOptionsPropertiesFormat{
// 		AvailableCipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256GCMSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128GCMSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA384),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA256),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITH3DESEDECBCSHA),
// 			to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITH3DESEDECBCSHA)},
// 			AvailableProtocols: []*armnetwork.ApplicationGatewaySSLProtocol{
// 				to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv10),
// 				to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
// 				to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv12)},
// 				DefaultPolicy: to.Ptr(armnetwork.ApplicationGatewaySSLPolicyNameAppGwSSLPolicy20150501),
// 				PredefinedPolicies: []*armnetwork.SubResource{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20150501"),
// 					},
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20170401"),
// 					},
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20170401S"),
// 				}},
// 			},
// 		}

func (*ApplicationGatewaysClient) ListAvailableServerVariables 

func (client *ApplicationGatewaysClient) ListAvailableServerVariables(ctx context.Context, options *ApplicationGatewaysClientListAvailableServerVariablesOptions) (ApplicationGatewaysClientListAvailableServerVariablesResponse, error)

ListAvailableServerVariables - Lists all available server variables. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAvailableServerVariablesOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableServerVariables method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableServerVariablesGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().ListAvailableServerVariables(ctx, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.StringArray = []*string{
// 	to.Ptr("request_query")}

func (*ApplicationGatewaysClient) ListAvailableWafRuleSets 

func (client *ApplicationGatewaysClient) ListAvailableWafRuleSets(ctx context.Context, options *ApplicationGatewaysClientListAvailableWafRuleSetsOptions) (ApplicationGatewaysClientListAvailableWafRuleSetsResponse, error)

ListAvailableWafRuleSets - Lists all available web application firewall rule sets. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAvailableWafRuleSetsOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableWafRuleSets method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableWafRuleSetsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().ListAvailableWafRuleSets(ctx, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGatewayAvailableWafRuleSetsResult = armnetwork.ApplicationGatewayAvailableWafRuleSetsResult{
// 	Value: []*armnetwork.ApplicationGatewayFirewallRuleSet{
// 		{
// 			Name: to.Ptr("OWASP_3.0"),
// 			Type: to.Ptr("Microsoft.Network/applicationGatewayAvailableWafRuleSets"),
// 			ID: to.Ptr("/subscriptions//resourceGroups//providers/Microsoft.Network/applicationGatewayAvailableWafRuleSets/"),
// 			Properties: &armnetwork.ApplicationGatewayFirewallRuleSetPropertiesFormat{
// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				RuleGroups: []*armnetwork.ApplicationGatewayFirewallRuleGroup{
// 					{
// 						Description: to.Ptr(""),
// 						RuleGroupName: to.Ptr("General"),
// 						Rules: []*armnetwork.ApplicationGatewayFirewallRule{
// 							{
// 								Description: to.Ptr("Possible Multipart Unmatched Boundary."),
// 								RuleID: to.Ptr[int32](200004),
// 								RuleIDString: to.Ptr("200004"),
// 						}},
// 				}},
// 				RuleSetType: to.Ptr("OWASP"),
// 				RuleSetVersion: to.Ptr("3.0"),
// 			},
// 	}},
// }

func (*ApplicationGatewaysClient) NewListAllPager 

func (client *ApplicationGatewaysClient) NewListAllPager(options *ApplicationGatewaysClientListAllOptions) *runtime.Pager[ApplicationGatewaysClientListAllResponse]

NewListAllPager - Gets all the application gateways in a subscription.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAllOptions contains the optional parameters for the ApplicationGatewaysClient.NewListAllPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayListAll.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationGatewaysClient().NewListAllPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationGatewayListResult = armnetwork.ApplicationGatewayListResult{
	// 	Value: []*armnetwork.ApplicationGateway{
	// 		{
	// 			Name: to.Ptr("appgw"),
	// 			Type: to.Ptr("Microsoft.Network/applicationGateways"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw"),
	// 			Location: to.Ptr("southcentralus"),
	// 			Properties: &armnetwork.ApplicationGatewayPropertiesFormat{
	// 				AuthenticationCertificates: []*armnetwork.ApplicationGatewayAuthenticationCertificate{
	// 				},
	// 				BackendAddressPools: []*armnetwork.ApplicationGatewayBackendAddressPool{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 						Name: to.Ptr("appgwpool"),
	// 						Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
	// 							BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
	// 						Name: to.Ptr("appgwpool1"),
	// 						Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
	// 							BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
	// 								{
	// 								},
	// 								{
	// 							}},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 				}},
	// 				BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHTTPSettings{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 						Name: to.Ptr("appgwbhs"),
	// 						Properties: &armnetwork.ApplicationGatewayBackendHTTPSettingsPropertiesFormat{
	// 							CookieBasedAffinity: to.Ptr(armnetwork.ApplicationGatewayCookieBasedAffinityDisabled),
	// 							Port: to.Ptr[int32](80),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RequestTimeout: to.Ptr[int32](30),
	// 							Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
	// 						},
	// 				}},
	// 				FrontendIPConfigurations: []*armnetwork.ApplicationGatewayFrontendIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
	// 						Name: to.Ptr("appgwfip"),
	// 						Properties: &armnetwork.ApplicationGatewayFrontendIPConfigurationPropertiesFormat{
	// 							PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicIPAddress: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/appgwpip"),
	// 							},
	// 						},
	// 				}},
	// 				FrontendPorts: []*armnetwork.ApplicationGatewayFrontendPort{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
	// 						Name: to.Ptr("appgwfp"),
	// 						Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
	// 							Port: to.Ptr[int32](443),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
	// 						Name: to.Ptr("appgwfp80"),
	// 						Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
	// 							Port: to.Ptr[int32](80),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 				}},
	// 				GatewayIPConfigurations: []*armnetwork.ApplicationGatewayIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/gatewayIPConfigurations/appgwipc"),
	// 						Name: to.Ptr("appgwipc"),
	// 						Properties: &armnetwork.ApplicationGatewayIPConfigurationPropertiesFormat{
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							Subnet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
	// 							},
	// 						},
	// 				}},
	// 				GlobalConfiguration: &armnetwork.ApplicationGatewayGlobalConfiguration{
	// 					EnableRequestBuffering: to.Ptr(true),
	// 					EnableResponseBuffering: to.Ptr(true),
	// 				},
	// 				HTTPListeners: []*armnetwork.ApplicationGatewayHTTPListener{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
	// 						Name: to.Ptr("appgwhl"),
	// 						Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
	// 							FrontendIPConfiguration: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
	// 							},
	// 							FrontendPort: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RequireServerNameIndication: to.Ptr(false),
	// 							SSLCertificate: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
	// 							},
	// 							SSLProfile: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
	// 							},
	// 							Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTPS),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
	// 						Name: to.Ptr("appgwhttplistener"),
	// 						Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
	// 							FrontendIPConfiguration: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
	// 							},
	// 							FrontendPort: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
	// 						},
	// 				}},
	// 				LoadDistributionPolicies: []*armnetwork.ApplicationGatewayLoadDistributionPolicy{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 						Name: to.Ptr("ldp1"),
	// 						Properties: &armnetwork.ApplicationGatewayLoadDistributionPolicyPropertiesFormat{
	// 							LoadDistributionAlgorithm: to.Ptr(armnetwork.ApplicationGatewayLoadDistributionAlgorithmRoundRobin),
	// 							LoadDistributionTargets: []*armnetwork.ApplicationGatewayLoadDistributionTarget{
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1/loadDistributionTargets/ldt1"),
	// 									Name: to.Ptr("ld11"),
	// 									Properties: &armnetwork.ApplicationGatewayLoadDistributionTargetPropertiesFormat{
	// 										BackendAddressPool: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 										},
	// 										WeightPerServer: to.Ptr[int32](40),
	// 									},
	// 								},
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1/loadDistributionTargets/ldt1"),
	// 									Name: to.Ptr("ld11"),
	// 									Properties: &armnetwork.ApplicationGatewayLoadDistributionTargetPropertiesFormat{
	// 										BackendAddressPool: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
	// 										},
	// 										WeightPerServer: to.Ptr[int32](60),
	// 									},
	// 							}},
	// 						},
	// 				}},
	// 				OperationalState: to.Ptr(armnetwork.ApplicationGatewayOperationalStateRunning),
	// 				PrivateEndpointConnections: []*armnetwork.ApplicationGatewayPrivateEndpointConnection{
	// 				},
	// 				PrivateLinkConfigurations: []*armnetwork.ApplicationGatewayPrivateLinkConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1"),
	// 						Name: to.Ptr("privateLink1"),
	// 						Properties: &armnetwork.ApplicationGatewayPrivateLinkConfigurationProperties{
	// 							IPConfigurations: []*armnetwork.ApplicationGatewayPrivateLinkIPConfiguration{
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1/privateLinkConfigurations/privateLink1/ipConfigurations/natNicIpconfig1"),
	// 									Name: to.Ptr("natNicIpconfig1"),
	// 									Properties: &armnetwork.ApplicationGatewayPrivateLinkIPConfigurationProperties{
	// 										Primary: to.Ptr(true),
	// 										PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 										ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 										Subnet: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
	// 										},
	// 									},
	// 								},
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1/privateLinkConfigurations/privateLink1/ipConfigurations/natNicIpconfig2"),
	// 									Name: to.Ptr("natNicIpconfig2"),
	// 									Properties: &armnetwork.ApplicationGatewayPrivateLinkIPConfigurationProperties{
	// 										PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 										ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 										Subnet: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
	// 										},
	// 									},
	// 							}},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 				}},
	// 				Probes: []*armnetwork.ApplicationGatewayProbe{
	// 				},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				RequestRoutingRules: []*armnetwork.ApplicationGatewayRequestRoutingRule{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwrule"),
	// 						Name: to.Ptr("appgwrule"),
	// 						Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
	// 							BackendAddressPool: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 							},
	// 							BackendHTTPSettings: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 							},
	// 							HTTPListener: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
	// 							},
	// 							LoadDistributionPolicy: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 							},
	// 							Priority: to.Ptr[int32](10),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RewriteRuleSet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 							},
	// 							RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypeBasic),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwPathBasedRule"),
	// 						Name: to.Ptr("appgwPathBasedRule"),
	// 						Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
	// 							HTTPListener: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
	// 							},
	// 							Priority: to.Ptr[int32](20),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypePathBasedRouting),
	// 							URLPathMap: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1"),
	// 							},
	// 						},
	// 				}},
	// 				RewriteRuleSets: []*armnetwork.ApplicationGatewayRewriteRuleSet{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 						Name: to.Ptr("rewriteRuleSet1"),
	// 						Properties: &armnetwork.ApplicationGatewayRewriteRuleSetPropertiesFormat{
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RewriteRules: []*armnetwork.ApplicationGatewayRewriteRule{
	// 								{
	// 									Name: to.Ptr("Set X-Forwarded-For"),
	// 									ActionSet: &armnetwork.ApplicationGatewayRewriteRuleActionSet{
	// 										RequestHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
	// 											{
	// 												HeaderName: to.Ptr("X-Forwarded-For"),
	// 												HeaderValue: to.Ptr("{var_remote-addr}"),
	// 										}},
	// 										ResponseHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
	// 											{
	// 												HeaderName: to.Ptr("Strict-Transport-Security"),
	// 												HeaderValue: to.Ptr("max-age=31536000"),
	// 										}},
	// 										URLConfiguration: &armnetwork.ApplicationGatewayURLConfiguration{
	// 											ModifiedPath: to.Ptr("/abc"),
	// 											ModifiedQueryString: to.Ptr("x=y&a=b"),
	// 											Reroute: to.Ptr(false),
	// 										},
	// 									},
	// 									Conditions: []*armnetwork.ApplicationGatewayRewriteRuleCondition{
	// 										{
	// 											IgnoreCase: to.Ptr(true),
	// 											Negate: to.Ptr(false),
	// 											Pattern: to.Ptr("^Bearer"),
	// 											Variable: to.Ptr("http_req_Authorization"),
	// 									}},
	// 									RuleSequence: to.Ptr[int32](102),
	// 							}},
	// 						},
	// 				}},
	// 				SKU: &armnetwork.ApplicationGatewaySKU{
	// 					Name: to.Ptr(armnetwork.ApplicationGatewaySKUNameStandardMedium),
	// 					Capacity: to.Ptr[int32](3),
	// 					Tier: to.Ptr(armnetwork.ApplicationGatewayTierStandard),
	// 				},
	// 				SSLCertificates: []*armnetwork.ApplicationGatewaySSLCertificate{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
	// 						Name: to.Ptr("sslcert"),
	// 						Properties: &armnetwork.ApplicationGatewaySSLCertificatePropertiesFormat{
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicCertData: to.Ptr("*****"),
	// 						},
	// 				}},
	// 				SSLProfiles: []*armnetwork.ApplicationGatewaySSLProfile{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
	// 						Name: to.Ptr("sslProfile1"),
	// 						Properties: &armnetwork.ApplicationGatewaySSLProfilePropertiesFormat{
	// 							ClientAuthConfiguration: &armnetwork.ApplicationGatewayClientAuthConfiguration{
	// 								VerifyClientCertIssuerDN: to.Ptr(true),
	// 								VerifyClientRevocation: to.Ptr(armnetwork.ApplicationGatewayClientRevocationOptionsOCSP),
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							SSLPolicy: &armnetwork.ApplicationGatewaySSLPolicy{
	// 								CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
	// 									to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256)},
	// 									MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
	// 									PolicyType: to.Ptr(armnetwork.ApplicationGatewaySSLPolicyTypeCustom),
	// 								},
	// 								TrustedClientCertificates: []*armnetwork.SubResource{
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
	// 								}},
	// 							},
	// 					}},
	// 					TrustedClientCertificates: []*armnetwork.ApplicationGatewayTrustedClientCertificate{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
	// 							Name: to.Ptr("clientcert"),
	// 							Properties: &armnetwork.ApplicationGatewayTrustedClientCertificatePropertiesFormat{
	// 								ClientCertIssuerDN: to.Ptr("CN=User1, OU=Eng, O=Company Ltd, L=D4, S=Arizona, C=US"),
	// 								Data: to.Ptr("****"),
	// 								ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 								ValidatedCertData: to.Ptr("****"),
	// 							},
	// 					}},
	// 					URLPathMaps: []*armnetwork.ApplicationGatewayURLPathMap{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1"),
	// 							Name: to.Ptr("pathMap1"),
	// 							Properties: &armnetwork.ApplicationGatewayURLPathMapPropertiesFormat{
	// 								DefaultBackendAddressPool: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 								},
	// 								DefaultBackendHTTPSettings: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 								},
	// 								DefaultLoadDistributionPolicy: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 								},
	// 								DefaultRewriteRuleSet: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 								},
	// 								PathRules: []*armnetwork.ApplicationGatewayPathRule{
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1/pathRules/apiPaths"),
	// 										Name: to.Ptr("apiPaths"),
	// 										Properties: &armnetwork.ApplicationGatewayPathRulePropertiesFormat{
	// 											BackendAddressPool: &armnetwork.SubResource{
	// 												ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 											},
	// 											BackendHTTPSettings: &armnetwork.SubResource{
	// 												ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 											},
	// 											LoadDistributionPolicy: &armnetwork.SubResource{
	// 												ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 											},
	// 											Paths: []*string{
	// 												to.Ptr("/api"),
	// 												to.Ptr("/v1/api")},
	// 												ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 												RewriteRuleSet: &armnetwork.SubResource{
	// 													ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 												},
	// 											},
	// 									}},
	// 									ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 								},
	// 						}},
	// 					},
	// 			}},
	// 		}
}

func (*ApplicationGatewaysClient) NewListAvailableSSLPredefinedPoliciesPager 

func (client *ApplicationGatewaysClient) NewListAvailableSSLPredefinedPoliciesPager(options *ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesOptions) *runtime.Pager[ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesResponse]

NewListAvailableSSLPredefinedPoliciesPager - Lists all SSL predefined policies for configuring Ssl policy.

Generated from API version 2024-03-01

  • options - ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesOptions contains the optional parameters for the ApplicationGatewaysClient.NewListAvailableSSLPredefinedPoliciesPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayAvailableSslOptionsPredefinedPoliciesGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationGatewaysClient().NewListAvailableSSLPredefinedPoliciesPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationGatewayAvailableSSLPredefinedPolicies = armnetwork.ApplicationGatewayAvailableSSLPredefinedPolicies{
	// 	Value: []*armnetwork.ApplicationGatewaySSLPredefinedPolicy{
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20150501"),
	// 			Name: to.Ptr("AppGwSslPolicy20150501"),
	// 			Properties: &armnetwork.ApplicationGatewaySSLPredefinedPolicyPropertiesFormat{
	// 				CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256GCMSHA384),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128GCMSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA384),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256GCMSHA384),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128GCMSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES256CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHERSAWITHAES128CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256GCMSHA384),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128GCMSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256GCMSHA384),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128GCMSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA384),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA256),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES256CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITHAES128CBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITH3DESEDECBCSHA),
	// 					to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSDHEDSSWITH3DESEDECBCSHA)},
	// 					MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv10),
	// 				},
	// 			},
	// 			{
	// 				ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20170401"),
	// 				Name: to.Ptr("AppGwSslPolicy20170401"),
	// 				Properties: &armnetwork.ApplicationGatewaySSLPredefinedPolicyPropertiesFormat{
	// 					CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128GCMSHA256),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256GCMSHA384),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA256),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA384),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256GCMSHA384),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128GCMSHA256),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256GCMSHA384),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128GCMSHA256),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA256),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA256),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA),
	// 						to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA)},
	// 						MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
	// 					},
	// 				},
	// 				{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups//providers/Microsoft.Network/ApplicationGatewayAvailableSslOptions/default/ApplicationGatewaySslPredefinedPolicy/AppGwSslPolicy20170401S"),
	// 					Name: to.Ptr("AppGwSslPolicy20170401S"),
	// 					Properties: &armnetwork.ApplicationGatewaySSLPredefinedPolicyPropertiesFormat{
	// 						CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128GCMSHA256),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256GCMSHA384),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES128CBCSHA256),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHEECDSAWITHAES256CBCSHA384),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256GCMSHA384),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128GCMSHA256),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES256CBCSHA),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256GCMSHA384),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128GCMSHA256),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA256),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA256),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES256CBCSHA),
	// 							to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSRSAWITHAES128CBCSHA)},
	// 							MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv12),
	// 						},
	// 				}},
	// 			}
}

func (*ApplicationGatewaysClient) NewListPager 

func (client *ApplicationGatewaysClient) NewListPager(resourceGroupName string, options *ApplicationGatewaysClientListOptions) *runtime.Pager[ApplicationGatewaysClientListResponse]

NewListPager - Lists all application gateways in a resource group.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • options - ApplicationGatewaysClientListOptions contains the optional parameters for the ApplicationGatewaysClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationGatewaysClient().NewListPager("rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationGatewayListResult = armnetwork.ApplicationGatewayListResult{
	// 	Value: []*armnetwork.ApplicationGateway{
	// 		{
	// 			Name: to.Ptr("appgw"),
	// 			Type: to.Ptr("Microsoft.Network/applicationGateways"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw"),
	// 			Location: to.Ptr("southcentralus"),
	// 			Properties: &armnetwork.ApplicationGatewayPropertiesFormat{
	// 				AuthenticationCertificates: []*armnetwork.ApplicationGatewayAuthenticationCertificate{
	// 				},
	// 				BackendAddressPools: []*armnetwork.ApplicationGatewayBackendAddressPool{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 						Name: to.Ptr("appgwpool"),
	// 						Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
	// 							BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
	// 						Name: to.Ptr("appgwpool1"),
	// 						Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
	// 							BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
	// 								{
	// 								},
	// 								{
	// 							}},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 				}},
	// 				BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHTTPSettings{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 						Name: to.Ptr("appgwbhs"),
	// 						Properties: &armnetwork.ApplicationGatewayBackendHTTPSettingsPropertiesFormat{
	// 							CookieBasedAffinity: to.Ptr(armnetwork.ApplicationGatewayCookieBasedAffinityDisabled),
	// 							Port: to.Ptr[int32](80),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RequestTimeout: to.Ptr[int32](30),
	// 							Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
	// 						},
	// 				}},
	// 				FrontendIPConfigurations: []*armnetwork.ApplicationGatewayFrontendIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
	// 						Name: to.Ptr("appgwfip"),
	// 						Properties: &armnetwork.ApplicationGatewayFrontendIPConfigurationPropertiesFormat{
	// 							PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicIPAddress: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/appgwpip"),
	// 							},
	// 						},
	// 				}},
	// 				FrontendPorts: []*armnetwork.ApplicationGatewayFrontendPort{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
	// 						Name: to.Ptr("appgwfp"),
	// 						Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
	// 							Port: to.Ptr[int32](443),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
	// 						Name: to.Ptr("appgwfp80"),
	// 						Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
	// 							Port: to.Ptr[int32](80),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 				}},
	// 				GatewayIPConfigurations: []*armnetwork.ApplicationGatewayIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/gatewayIPConfigurations/appgwipc"),
	// 						Name: to.Ptr("appgwipc"),
	// 						Properties: &armnetwork.ApplicationGatewayIPConfigurationPropertiesFormat{
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							Subnet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
	// 							},
	// 						},
	// 				}},
	// 				GlobalConfiguration: &armnetwork.ApplicationGatewayGlobalConfiguration{
	// 					EnableRequestBuffering: to.Ptr(true),
	// 					EnableResponseBuffering: to.Ptr(true),
	// 				},
	// 				HTTPListeners: []*armnetwork.ApplicationGatewayHTTPListener{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
	// 						Name: to.Ptr("appgwhl"),
	// 						Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
	// 							FrontendIPConfiguration: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
	// 							},
	// 							FrontendPort: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp"),
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RequireServerNameIndication: to.Ptr(false),
	// 							SSLCertificate: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
	// 							},
	// 							SSLProfile: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
	// 							},
	// 							Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTPS),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
	// 						Name: to.Ptr("appgwhttplistener"),
	// 						Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
	// 							FrontendIPConfiguration: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendIPConfigurations/appgwfip"),
	// 							},
	// 							FrontendPort: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/frontendPorts/appgwfp80"),
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
	// 						},
	// 				}},
	// 				LoadDistributionPolicies: []*armnetwork.ApplicationGatewayLoadDistributionPolicy{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 						Name: to.Ptr("ldp1"),
	// 						Properties: &armnetwork.ApplicationGatewayLoadDistributionPolicyPropertiesFormat{
	// 							LoadDistributionAlgorithm: to.Ptr(armnetwork.ApplicationGatewayLoadDistributionAlgorithmRoundRobin),
	// 							LoadDistributionTargets: []*armnetwork.ApplicationGatewayLoadDistributionTarget{
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1/loadDistributionTargets/ldt1"),
	// 									Name: to.Ptr("ld11"),
	// 									Properties: &armnetwork.ApplicationGatewayLoadDistributionTargetPropertiesFormat{
	// 										BackendAddressPool: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 										},
	// 										WeightPerServer: to.Ptr[int32](40),
	// 									},
	// 								},
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1/loadDistributionTargets/ldt1"),
	// 									Name: to.Ptr("ld11"),
	// 									Properties: &armnetwork.ApplicationGatewayLoadDistributionTargetPropertiesFormat{
	// 										BackendAddressPool: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool1"),
	// 										},
	// 										WeightPerServer: to.Ptr[int32](60),
	// 									},
	// 							}},
	// 						},
	// 				}},
	// 				OperationalState: to.Ptr(armnetwork.ApplicationGatewayOperationalStateRunning),
	// 				PrivateEndpointConnections: []*armnetwork.ApplicationGatewayPrivateEndpointConnection{
	// 				},
	// 				PrivateLinkConfigurations: []*armnetwork.ApplicationGatewayPrivateLinkConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1"),
	// 						Name: to.Ptr("privateLink1"),
	// 						Properties: &armnetwork.ApplicationGatewayPrivateLinkConfigurationProperties{
	// 							IPConfigurations: []*armnetwork.ApplicationGatewayPrivateLinkIPConfiguration{
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1/privateLinkConfigurations/privateLink1/ipConfigurations/natNicIpconfig1"),
	// 									Name: to.Ptr("natNicIpconfig1"),
	// 									Properties: &armnetwork.ApplicationGatewayPrivateLinkIPConfigurationProperties{
	// 										Primary: to.Ptr(true),
	// 										PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 										ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 										Subnet: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
	// 										},
	// 									},
	// 								},
	// 								{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/privateLinkConfigurations/privateLink1/privateLinkConfigurations/privateLink1/ipConfigurations/natNicIpconfig2"),
	// 									Name: to.Ptr("natNicIpconfig2"),
	// 									Properties: &armnetwork.ApplicationGatewayPrivateLinkIPConfigurationProperties{
	// 										PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 										ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 										Subnet: &armnetwork.SubResource{
	// 											ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/virtualNetwork1/subnets/appgwsubnet"),
	// 										},
	// 									},
	// 							}},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 						},
	// 				}},
	// 				Probes: []*armnetwork.ApplicationGatewayProbe{
	// 				},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				RequestRoutingRules: []*armnetwork.ApplicationGatewayRequestRoutingRule{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwrule"),
	// 						Name: to.Ptr("appgwrule"),
	// 						Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
	// 							BackendAddressPool: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 							},
	// 							BackendHTTPSettings: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 							},
	// 							HTTPListener: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhl"),
	// 							},
	// 							LoadDistributionPolicy: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 							},
	// 							Priority: to.Ptr[int32](10),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RewriteRuleSet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 							},
	// 							RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypeBasic),
	// 						},
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/requestRoutingRules/appgwPathBasedRule"),
	// 						Name: to.Ptr("appgwPathBasedRule"),
	// 						Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
	// 							HTTPListener: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/httpListeners/appgwhttplistener"),
	// 							},
	// 							Priority: to.Ptr[int32](20),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypePathBasedRouting),
	// 							URLPathMap: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1"),
	// 							},
	// 						},
	// 				}},
	// 				RewriteRuleSets: []*armnetwork.ApplicationGatewayRewriteRuleSet{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 						Name: to.Ptr("rewriteRuleSet1"),
	// 						Properties: &armnetwork.ApplicationGatewayRewriteRuleSetPropertiesFormat{
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							RewriteRules: []*armnetwork.ApplicationGatewayRewriteRule{
	// 								{
	// 									Name: to.Ptr("Set X-Forwarded-For"),
	// 									ActionSet: &armnetwork.ApplicationGatewayRewriteRuleActionSet{
	// 										RequestHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
	// 											{
	// 												HeaderName: to.Ptr("X-Forwarded-For"),
	// 												HeaderValue: to.Ptr("{var_remote-addr}"),
	// 										}},
	// 										ResponseHeaderConfigurations: []*armnetwork.ApplicationGatewayHeaderConfiguration{
	// 											{
	// 												HeaderName: to.Ptr("Strict-Transport-Security"),
	// 												HeaderValue: to.Ptr("max-age=31536000"),
	// 										}},
	// 										URLConfiguration: &armnetwork.ApplicationGatewayURLConfiguration{
	// 											ModifiedPath: to.Ptr("/abc"),
	// 											ModifiedQueryString: to.Ptr("x=y&a=b"),
	// 											Reroute: to.Ptr(false),
	// 										},
	// 									},
	// 									Conditions: []*armnetwork.ApplicationGatewayRewriteRuleCondition{
	// 										{
	// 											IgnoreCase: to.Ptr(true),
	// 											Negate: to.Ptr(false),
	// 											Pattern: to.Ptr("^Bearer"),
	// 											Variable: to.Ptr("http_req_Authorization"),
	// 									}},
	// 									RuleSequence: to.Ptr[int32](102),
	// 							}},
	// 						},
	// 				}},
	// 				SKU: &armnetwork.ApplicationGatewaySKU{
	// 					Name: to.Ptr(armnetwork.ApplicationGatewaySKUNameStandardMedium),
	// 					Capacity: to.Ptr[int32](3),
	// 					Tier: to.Ptr(armnetwork.ApplicationGatewayTierStandard),
	// 				},
	// 				SSLCertificates: []*armnetwork.ApplicationGatewaySSLCertificate{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslCertificates/sslcert"),
	// 						Name: to.Ptr("sslcert"),
	// 						Properties: &armnetwork.ApplicationGatewaySSLCertificatePropertiesFormat{
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicCertData: to.Ptr("*****"),
	// 						},
	// 				}},
	// 				SSLProfiles: []*armnetwork.ApplicationGatewaySSLProfile{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/sslProfiles/sslProfile1"),
	// 						Name: to.Ptr("sslProfile1"),
	// 						Properties: &armnetwork.ApplicationGatewaySSLProfilePropertiesFormat{
	// 							ClientAuthConfiguration: &armnetwork.ApplicationGatewayClientAuthConfiguration{
	// 								VerifyClientCertIssuerDN: to.Ptr(true),
	// 								VerifyClientRevocation: to.Ptr(armnetwork.ApplicationGatewayClientRevocationOptionsOCSP),
	// 							},
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							SSLPolicy: &armnetwork.ApplicationGatewaySSLPolicy{
	// 								CipherSuites: []*armnetwork.ApplicationGatewaySSLCipherSuite{
	// 									to.Ptr(armnetwork.ApplicationGatewaySSLCipherSuiteTLSECDHERSAWITHAES128CBCSHA256)},
	// 									MinProtocolVersion: to.Ptr(armnetwork.ApplicationGatewaySSLProtocolTLSv11),
	// 									PolicyType: to.Ptr(armnetwork.ApplicationGatewaySSLPolicyTypeCustom),
	// 								},
	// 								TrustedClientCertificates: []*armnetwork.SubResource{
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
	// 								}},
	// 							},
	// 					}},
	// 					TrustedClientCertificates: []*armnetwork.ApplicationGatewayTrustedClientCertificate{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/trustedClientCertificates/clientcert"),
	// 							Name: to.Ptr("clientcert"),
	// 							Properties: &armnetwork.ApplicationGatewayTrustedClientCertificatePropertiesFormat{
	// 								ClientCertIssuerDN: to.Ptr("CN=User1, OU=Eng, O=Company Ltd, L=D4, S=Arizona, C=US"),
	// 								Data: to.Ptr("****"),
	// 								ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 								ValidatedCertData: to.Ptr("****"),
	// 							},
	// 					}},
	// 					URLPathMaps: []*armnetwork.ApplicationGatewayURLPathMap{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1"),
	// 							Name: to.Ptr("pathMap1"),
	// 							Properties: &armnetwork.ApplicationGatewayURLPathMapPropertiesFormat{
	// 								DefaultBackendAddressPool: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 								},
	// 								DefaultBackendHTTPSettings: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 								},
	// 								DefaultLoadDistributionPolicy: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 								},
	// 								DefaultRewriteRuleSet: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 								},
	// 								PathRules: []*armnetwork.ApplicationGatewayPathRule{
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/urlPathMaps/pathMap1/pathRules/apiPaths"),
	// 										Name: to.Ptr("apiPaths"),
	// 										Properties: &armnetwork.ApplicationGatewayPathRulePropertiesFormat{
	// 											BackendAddressPool: &armnetwork.SubResource{
	// 												ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendAddressPools/appgwpool"),
	// 											},
	// 											BackendHTTPSettings: &armnetwork.SubResource{
	// 												ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/backendHttpSettingsCollection/appgwbhs"),
	// 											},
	// 											LoadDistributionPolicy: &armnetwork.SubResource{
	// 												ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/loadDistributionPolicies/ldp1"),
	// 											},
	// 											Paths: []*string{
	// 												to.Ptr("/api"),
	// 												to.Ptr("/v1/api")},
	// 												ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 												RewriteRuleSet: &armnetwork.SubResource{
	// 													ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/appgw/rewriteRuleSets/rewriteRuleSet1"),
	// 												},
	// 											},
	// 									}},
	// 									ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 								},
	// 						}},
	// 					},
	// 			}},
	// 		}
}

func (*ApplicationGatewaysClient) UpdateTags 

func (client *ApplicationGatewaysClient) UpdateTags(ctx context.Context, resourceGroupName string, applicationGatewayName string, parameters TagsObject, options *ApplicationGatewaysClientUpdateTagsOptions) (ApplicationGatewaysClientUpdateTagsResponse, error)

UpdateTags - Updates the specified application gateway tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationGatewayName - The name of the application gateway.
  • parameters - Parameters supplied to update application gateway tags.
  • options - ApplicationGatewaysClientUpdateTagsOptions contains the optional parameters for the ApplicationGatewaysClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationGatewayUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationGatewaysClient().UpdateTags(ctx, "rg1", "AppGw", armnetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationGateway = armnetwork.ApplicationGateway{
// 	Name: to.Ptr("AppGw"),
// 	Type: to.Ptr("Microsoft.Network/applicationGateways"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armnetwork.ApplicationGatewayPropertiesFormat{
// 		AuthenticationCertificates: []*armnetwork.ApplicationGatewayAuthenticationCertificate{
// 		},
// 		BackendAddressPools: []*armnetwork.ApplicationGatewayBackendAddressPool{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/backendAddressPools/Pool01"),
// 				Name: to.Ptr("Pool01"),
// 				Properties: &armnetwork.ApplicationGatewayBackendAddressPoolPropertiesFormat{
// 					BackendAddresses: []*armnetwork.ApplicationGatewayBackendAddress{
// 						{
// 							IPAddress: to.Ptr("10.10.10.1"),
// 						},
// 						{
// 							IPAddress: to.Ptr("10.10.10.2"),
// 						},
// 						{
// 							IPAddress: to.Ptr("10.10.10.3"),
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		BackendHTTPSettingsCollection: []*armnetwork.ApplicationGatewayBackendHTTPSettings{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/backendHttpSettingsCollection/PoolSetting01"),
// 				Name: to.Ptr("PoolSetting01"),
// 				Properties: &armnetwork.ApplicationGatewayBackendHTTPSettingsPropertiesFormat{
// 					CookieBasedAffinity: to.Ptr(armnetwork.ApplicationGatewayCookieBasedAffinityDisabled),
// 					PickHostNameFromBackendAddress: to.Ptr(false),
// 					Port: to.Ptr[int32](80),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RequestTimeout: to.Ptr[int32](30),
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
// 				},
// 		}},
// 		FrontendIPConfigurations: []*armnetwork.ApplicationGatewayFrontendIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/frontendIPConfigurations/FrontEndConfig01"),
// 				Name: to.Ptr("FrontEndConfig01"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/publicIp1"),
// 					},
// 				},
// 		}},
// 		FrontendPorts: []*armnetwork.ApplicationGatewayFrontendPort{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/frontendPorts/FrontEndPort01"),
// 				Name: to.Ptr("FrontEndPort01"),
// 				Properties: &armnetwork.ApplicationGatewayFrontendPortPropertiesFormat{
// 					Port: to.Ptr[int32](80),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 		}},
// 		GatewayIPConfigurations: []*armnetwork.ApplicationGatewayIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/gatewayIPConfigurations/GatewayIp01"),
// 				Name: to.Ptr("GatewayIp01"),
// 				Properties: &armnetwork.ApplicationGatewayIPConfigurationPropertiesFormat{
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet/subnets/subnet1"),
// 					},
// 				},
// 		}},
// 		HTTPListeners: []*armnetwork.ApplicationGatewayHTTPListener{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/httpListeners/listener1"),
// 				Name: to.Ptr("listener1"),
// 				Properties: &armnetwork.ApplicationGatewayHTTPListenerPropertiesFormat{
// 					FrontendIPConfiguration: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/frontendIPConfigurations/FrontEndConfig01"),
// 					},
// 					FrontendPort: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/frontendPorts/FrontEndPort01"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RequireServerNameIndication: to.Ptr(false),
// 					Protocol: to.Ptr(armnetwork.ApplicationGatewayProtocolHTTP),
// 				},
// 		}},
// 		OperationalState: to.Ptr(armnetwork.ApplicationGatewayOperationalStateRunning),
// 		Probes: []*armnetwork.ApplicationGatewayProbe{
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		RedirectConfigurations: []*armnetwork.ApplicationGatewayRedirectConfiguration{
// 		},
// 		RequestRoutingRules: []*armnetwork.ApplicationGatewayRequestRoutingRule{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/requestRoutingRules/Rule01"),
// 				Name: to.Ptr("Rule01"),
// 				Properties: &armnetwork.ApplicationGatewayRequestRoutingRulePropertiesFormat{
// 					BackendAddressPool: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/backendAddressPools/Pool01"),
// 					},
// 					BackendHTTPSettings: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/backendHttpSettingsCollection/PoolSetting01"),
// 					},
// 					HTTPListener: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationGateways/AppGw/httpListeners/listener1"),
// 					},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					RuleType: to.Ptr(armnetwork.ApplicationGatewayRequestRoutingRuleTypeBasic),
// 				},
// 		}},
// 		ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 		SKU: &armnetwork.ApplicationGatewaySKU{
// 			Name: to.Ptr(armnetwork.ApplicationGatewaySKUNameStandardSmall),
// 			Capacity: to.Ptr[int32](2),
// 			Tier: to.Ptr(armnetwork.ApplicationGatewayTierStandard),
// 		},
// 		SSLCertificates: []*armnetwork.ApplicationGatewaySSLCertificate{
// 		},
// 		URLPathMaps: []*armnetwork.ApplicationGatewayURLPathMap{
// 		},
// 	},
// }

type ApplicationGatewaysClientBackendHealthOnDemandResponse 

type ApplicationGatewaysClientBackendHealthOnDemandResponse struct {
	// Result of on demand test probe.
	ApplicationGatewayBackendHealthOnDemand
}

ApplicationGatewaysClientBackendHealthOnDemandResponse contains the response from method ApplicationGatewaysClient.BeginBackendHealthOnDemand.

type ApplicationGatewaysClientBackendHealthResponse 

type ApplicationGatewaysClientBackendHealthResponse struct {
	// Response for ApplicationGatewayBackendHealth API service call.
	ApplicationGatewayBackendHealth
}

ApplicationGatewaysClientBackendHealthResponse contains the response from method ApplicationGatewaysClient.BeginBackendHealth.

type ApplicationGatewaysClientBeginBackendHealthOnDemandOptions 

type ApplicationGatewaysClientBeginBackendHealthOnDemandOptions struct {
	// Expands BackendAddressPool and BackendHttpSettings referenced in backend health.
	Expand *string

	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewaysClientBeginBackendHealthOnDemandOptions contains the optional parameters for the ApplicationGatewaysClient.BeginBackendHealthOnDemand method.

type ApplicationGatewaysClientBeginBackendHealthOptions 

type ApplicationGatewaysClientBeginBackendHealthOptions struct {
	// Expands BackendAddressPool and BackendHttpSettings referenced in backend health.
	Expand *string

	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewaysClientBeginBackendHealthOptions contains the optional parameters for the ApplicationGatewaysClient.BeginBackendHealth method.

type ApplicationGatewaysClientBeginCreateOrUpdateOptions 

type ApplicationGatewaysClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewaysClientBeginCreateOrUpdateOptions contains the optional parameters for the ApplicationGatewaysClient.BeginCreateOrUpdate method.

type ApplicationGatewaysClientBeginDeleteOptions 

type ApplicationGatewaysClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewaysClientBeginDeleteOptions contains the optional parameters for the ApplicationGatewaysClient.BeginDelete method.

type ApplicationGatewaysClientBeginStartOptions 

type ApplicationGatewaysClientBeginStartOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewaysClientBeginStartOptions contains the optional parameters for the ApplicationGatewaysClient.BeginStart method.

type ApplicationGatewaysClientBeginStopOptions 

type ApplicationGatewaysClientBeginStopOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationGatewaysClientBeginStopOptions contains the optional parameters for the ApplicationGatewaysClient.BeginStop method.

type ApplicationGatewaysClientCreateOrUpdateResponse 

type ApplicationGatewaysClientCreateOrUpdateResponse struct {
	// Application gateway resource.
	ApplicationGateway
}

ApplicationGatewaysClientCreateOrUpdateResponse contains the response from method ApplicationGatewaysClient.BeginCreateOrUpdate.

type ApplicationGatewaysClientDeleteResponse 

type ApplicationGatewaysClientDeleteResponse struct {
}

ApplicationGatewaysClientDeleteResponse contains the response from method ApplicationGatewaysClient.BeginDelete.

type ApplicationGatewaysClientGetOptions 

type ApplicationGatewaysClientGetOptions struct {
}

ApplicationGatewaysClientGetOptions contains the optional parameters for the ApplicationGatewaysClient.Get method.

type ApplicationGatewaysClientGetResponse 

type ApplicationGatewaysClientGetResponse struct {
	// Application gateway resource.
	ApplicationGateway
}

ApplicationGatewaysClientGetResponse contains the response from method ApplicationGatewaysClient.Get.

type ApplicationGatewaysClientGetSSLPredefinedPolicyOptions 

type ApplicationGatewaysClientGetSSLPredefinedPolicyOptions struct {
}

ApplicationGatewaysClientGetSSLPredefinedPolicyOptions contains the optional parameters for the ApplicationGatewaysClient.GetSSLPredefinedPolicy method.

type ApplicationGatewaysClientGetSSLPredefinedPolicyResponse 

type ApplicationGatewaysClientGetSSLPredefinedPolicyResponse struct {
	// An Ssl predefined policy.
	ApplicationGatewaySSLPredefinedPolicy
}

ApplicationGatewaysClientGetSSLPredefinedPolicyResponse contains the response from method ApplicationGatewaysClient.GetSSLPredefinedPolicy.

type ApplicationGatewaysClientListAllOptions 

type ApplicationGatewaysClientListAllOptions struct {
}

ApplicationGatewaysClientListAllOptions contains the optional parameters for the ApplicationGatewaysClient.NewListAllPager method.

type ApplicationGatewaysClientListAllResponse 

type ApplicationGatewaysClientListAllResponse struct {
	// Response for ListApplicationGateways API service call.
	ApplicationGatewayListResult
}

ApplicationGatewaysClientListAllResponse contains the response from method ApplicationGatewaysClient.NewListAllPager.

type ApplicationGatewaysClientListAvailableRequestHeadersOptions 

type ApplicationGatewaysClientListAvailableRequestHeadersOptions struct {
}

ApplicationGatewaysClientListAvailableRequestHeadersOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableRequestHeaders method.

type ApplicationGatewaysClientListAvailableRequestHeadersResponse 

type ApplicationGatewaysClientListAvailableRequestHeadersResponse struct {
	// Response for ApplicationGatewayAvailableRequestHeaders API service call.
	StringArray []*string
}

ApplicationGatewaysClientListAvailableRequestHeadersResponse contains the response from method ApplicationGatewaysClient.ListAvailableRequestHeaders.

type ApplicationGatewaysClientListAvailableResponseHeadersOptions 

type ApplicationGatewaysClientListAvailableResponseHeadersOptions struct {
}

ApplicationGatewaysClientListAvailableResponseHeadersOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableResponseHeaders method.

type ApplicationGatewaysClientListAvailableResponseHeadersResponse 

type ApplicationGatewaysClientListAvailableResponseHeadersResponse struct {
	// Response for ApplicationGatewayAvailableResponseHeaders API service call.
	StringArray []*string
}

ApplicationGatewaysClientListAvailableResponseHeadersResponse contains the response from method ApplicationGatewaysClient.ListAvailableResponseHeaders.

type ApplicationGatewaysClientListAvailableSSLOptionsOptions 

type ApplicationGatewaysClientListAvailableSSLOptionsOptions struct {
}

ApplicationGatewaysClientListAvailableSSLOptionsOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableSSLOptions method.

type ApplicationGatewaysClientListAvailableSSLOptionsResponse 

type ApplicationGatewaysClientListAvailableSSLOptionsResponse struct {
	// Response for ApplicationGatewayAvailableSslOptions API service call.
	ApplicationGatewayAvailableSSLOptions
}

ApplicationGatewaysClientListAvailableSSLOptionsResponse contains the response from method ApplicationGatewaysClient.ListAvailableSSLOptions.

type ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesOptions 

type ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesOptions struct {
}

ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesOptions contains the optional parameters for the ApplicationGatewaysClient.NewListAvailableSSLPredefinedPoliciesPager method.

type ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesResponse 

type ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesResponse struct {
	// Response for ApplicationGatewayAvailableSslOptions API service call.
	ApplicationGatewayAvailableSSLPredefinedPolicies
}

ApplicationGatewaysClientListAvailableSSLPredefinedPoliciesResponse contains the response from method ApplicationGatewaysClient.NewListAvailableSSLPredefinedPoliciesPager.

type ApplicationGatewaysClientListAvailableServerVariablesOptions 

type ApplicationGatewaysClientListAvailableServerVariablesOptions struct {
}

ApplicationGatewaysClientListAvailableServerVariablesOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableServerVariables method.

type ApplicationGatewaysClientListAvailableServerVariablesResponse 

type ApplicationGatewaysClientListAvailableServerVariablesResponse struct {
	// Response for ApplicationGatewayAvailableServerVariables API service call.
	StringArray []*string
}

ApplicationGatewaysClientListAvailableServerVariablesResponse contains the response from method ApplicationGatewaysClient.ListAvailableServerVariables.

type ApplicationGatewaysClientListAvailableWafRuleSetsOptions 

type ApplicationGatewaysClientListAvailableWafRuleSetsOptions struct {
}

ApplicationGatewaysClientListAvailableWafRuleSetsOptions contains the optional parameters for the ApplicationGatewaysClient.ListAvailableWafRuleSets method.

type ApplicationGatewaysClientListAvailableWafRuleSetsResponse 

type ApplicationGatewaysClientListAvailableWafRuleSetsResponse struct {
	// Response for ApplicationGatewayAvailableWafRuleSets API service call.
	ApplicationGatewayAvailableWafRuleSetsResult
}

ApplicationGatewaysClientListAvailableWafRuleSetsResponse contains the response from method ApplicationGatewaysClient.ListAvailableWafRuleSets.

type ApplicationGatewaysClientListOptions 

type ApplicationGatewaysClientListOptions struct {
}

ApplicationGatewaysClientListOptions contains the optional parameters for the ApplicationGatewaysClient.NewListPager method.

type ApplicationGatewaysClientListResponse 

type ApplicationGatewaysClientListResponse struct {
	// Response for ListApplicationGateways API service call.
	ApplicationGatewayListResult
}

ApplicationGatewaysClientListResponse contains the response from method ApplicationGatewaysClient.NewListPager.

type ApplicationGatewaysClientStartResponse 

type ApplicationGatewaysClientStartResponse struct {
}

ApplicationGatewaysClientStartResponse contains the response from method ApplicationGatewaysClient.BeginStart.

type ApplicationGatewaysClientStopResponse 

type ApplicationGatewaysClientStopResponse struct {
}

ApplicationGatewaysClientStopResponse contains the response from method ApplicationGatewaysClient.BeginStop.

type ApplicationGatewaysClientUpdateTagsOptions 

type ApplicationGatewaysClientUpdateTagsOptions struct {
}

ApplicationGatewaysClientUpdateTagsOptions contains the optional parameters for the ApplicationGatewaysClient.UpdateTags method.

type ApplicationGatewaysClientUpdateTagsResponse 

type ApplicationGatewaysClientUpdateTagsResponse struct {
	// Application gateway resource.
	ApplicationGateway
}

ApplicationGatewaysClientUpdateTagsResponse contains the response from method ApplicationGatewaysClient.UpdateTags.

type ApplicationRule 

type ApplicationRule struct {
	// REQUIRED; Rule Type.
	RuleType *FirewallPolicyRuleType

	// Description of the rule.
	Description *string

	// List of destination IP addresses or Service Tags.
	DestinationAddresses []*string

	// List of FQDN Tags for this rule.
	FqdnTags []*string

	// List of HTTP/S headers to insert.
	HTTPHeadersToInsert []*FirewallPolicyHTTPHeaderToInsert

	// Name of the rule.
	Name *string

	// Array of Application Protocols.
	Protocols []*FirewallPolicyRuleApplicationProtocol

	// List of source IP addresses for this rule.
	SourceAddresses []*string

	// List of source IpGroups for this rule.
	SourceIPGroups []*string

	// List of FQDNs for this rule.
	TargetFqdns []*string

	// List of Urls for this rule condition.
	TargetUrls []*string

	// Terminate TLS connections for this rule.
	TerminateTLS *bool

	// List of destination azure web categories.
	WebCategories []*string
}

ApplicationRule - Rule of type application.

func (*ApplicationRule) GetFirewallPolicyRule 

func (a *ApplicationRule) GetFirewallPolicyRule() *FirewallPolicyRule

GetFirewallPolicyRule implements the FirewallPolicyRuleClassification interface for type ApplicationRule.

func (ApplicationRule) MarshalJSON 

func (a ApplicationRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationRule.

func (*ApplicationRule) UnmarshalJSON 

func (a *ApplicationRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationRule.

type ApplicationSecurityGroup 

type ApplicationSecurityGroup struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Properties of the application security group.
	Properties *ApplicationSecurityGroupPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ApplicationSecurityGroup - An application security group in a resource group.

func (ApplicationSecurityGroup) MarshalJSON 

func (a ApplicationSecurityGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationSecurityGroup.

func (*ApplicationSecurityGroup) UnmarshalJSON 

func (a *ApplicationSecurityGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationSecurityGroup.

type ApplicationSecurityGroupListResult 

type ApplicationSecurityGroupListResult struct {
	// A list of application security groups.
	Value []*ApplicationSecurityGroup

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

ApplicationSecurityGroupListResult - A list of application security groups.

func (ApplicationSecurityGroupListResult) MarshalJSON 

func (a ApplicationSecurityGroupListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationSecurityGroupListResult.

func (*ApplicationSecurityGroupListResult) UnmarshalJSON 

func (a *ApplicationSecurityGroupListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationSecurityGroupListResult.

type ApplicationSecurityGroupPropertiesFormat 

type ApplicationSecurityGroupPropertiesFormat struct {
	// READ-ONLY; The provisioning state of the application security group resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The resource GUID property of the application security group resource. It uniquely identifies a resource, even
	// if the user changes its name or migrate the resource across subscriptions or resource
	// groups.
	ResourceGUID *string
}

ApplicationSecurityGroupPropertiesFormat - Application security group properties.

func (ApplicationSecurityGroupPropertiesFormat) MarshalJSON 

func (a ApplicationSecurityGroupPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ApplicationSecurityGroupPropertiesFormat.

func (*ApplicationSecurityGroupPropertiesFormat) UnmarshalJSON 

func (a *ApplicationSecurityGroupPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationSecurityGroupPropertiesFormat.

type ApplicationSecurityGroupsClient 

type ApplicationSecurityGroupsClient struct {
	// contains filtered or unexported fields
}

ApplicationSecurityGroupsClient contains the methods for the ApplicationSecurityGroups group. Don't use this type directly, use NewApplicationSecurityGroupsClient() instead.

func NewApplicationSecurityGroupsClient 

func NewApplicationSecurityGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ApplicationSecurityGroupsClient, error)

NewApplicationSecurityGroupsClient creates a new instance of ApplicationSecurityGroupsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ApplicationSecurityGroupsClient) BeginCreateOrUpdate 

func (client *ApplicationSecurityGroupsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string, parameters ApplicationSecurityGroup, options *ApplicationSecurityGroupsClientBeginCreateOrUpdateOptions) (*runtime.Poller[ApplicationSecurityGroupsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an application security group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationSecurityGroupName - The name of the application security group.
  • parameters - Parameters supplied to the create or update ApplicationSecurityGroup operation.
  • options - ApplicationSecurityGroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the ApplicationSecurityGroupsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationSecurityGroupCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationSecurityGroupsClient().BeginCreateOrUpdate(ctx, "rg1", "test-asg", armnetwork.ApplicationSecurityGroup{
	Location:   to.Ptr("westus"),
	Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationSecurityGroup = armnetwork.ApplicationSecurityGroup{
// 	Name: to.Ptr("test-asg"),
// 	Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/test-asg"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 	},
// }

func (*ApplicationSecurityGroupsClient) BeginDelete 

func (client *ApplicationSecurityGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string, options *ApplicationSecurityGroupsClientBeginDeleteOptions) (*runtime.Poller[ApplicationSecurityGroupsClientDeleteResponse], error)

BeginDelete - Deletes the specified application security group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationSecurityGroupName - The name of the application security group.
  • options - ApplicationSecurityGroupsClientBeginDeleteOptions contains the optional parameters for the ApplicationSecurityGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationSecurityGroupDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewApplicationSecurityGroupsClient().BeginDelete(ctx, "rg1", "test-asg", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ApplicationSecurityGroupsClient) Get 

func (client *ApplicationSecurityGroupsClient) Get(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string, options *ApplicationSecurityGroupsClientGetOptions) (ApplicationSecurityGroupsClientGetResponse, error)

Get - Gets information about the specified application security group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationSecurityGroupName - The name of the application security group.
  • options - ApplicationSecurityGroupsClientGetOptions contains the optional parameters for the ApplicationSecurityGroupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationSecurityGroupGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationSecurityGroupsClient().Get(ctx, "rg1", "test-asg", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationSecurityGroup = armnetwork.ApplicationSecurityGroup{
// 	Name: to.Ptr("test-asg"),
// 	Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/test-asg"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 	},
// }

func (*ApplicationSecurityGroupsClient) NewListAllPager 

func (client *ApplicationSecurityGroupsClient) NewListAllPager(options *ApplicationSecurityGroupsClientListAllOptions) *runtime.Pager[ApplicationSecurityGroupsClientListAllResponse]

NewListAllPager - Gets all application security groups in a subscription.

Generated from API version 2024-03-01

  • options - ApplicationSecurityGroupsClientListAllOptions contains the optional parameters for the ApplicationSecurityGroupsClient.NewListAllPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationSecurityGroupListAll.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationSecurityGroupsClient().NewListAllPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationSecurityGroupListResult = armnetwork.ApplicationSecurityGroupListResult{
	// 	Value: []*armnetwork.ApplicationSecurityGroup{
	// 		{
	// 			Name: to.Ptr("asg1"),
	// 			Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/asg1"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("asg2"),
	// 			Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/asg2"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 	}},
	// }
}

func (*ApplicationSecurityGroupsClient) NewListPager 

func (client *ApplicationSecurityGroupsClient) NewListPager(resourceGroupName string, options *ApplicationSecurityGroupsClientListOptions) *runtime.Pager[ApplicationSecurityGroupsClientListResponse]

NewListPager - Gets all the application security groups in a resource group.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • options - ApplicationSecurityGroupsClientListOptions contains the optional parameters for the ApplicationSecurityGroupsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationSecurityGroupList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewApplicationSecurityGroupsClient().NewListPager("rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ApplicationSecurityGroupListResult = armnetwork.ApplicationSecurityGroupListResult{
	// 	Value: []*armnetwork.ApplicationSecurityGroup{
	// 		{
	// 			Name: to.Ptr("asg1"),
	// 			Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/asg1"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("asg2"),
	// 			Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/asg2"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 	}},
	// }
}

func (*ApplicationSecurityGroupsClient) UpdateTags 

func (client *ApplicationSecurityGroupsClient) UpdateTags(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string, parameters TagsObject, options *ApplicationSecurityGroupsClientUpdateTagsOptions) (ApplicationSecurityGroupsClientUpdateTagsResponse, error)

UpdateTags - Updates an application security group's tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • applicationSecurityGroupName - The name of the application security group.
  • parameters - Parameters supplied to update application security group tags.
  • options - ApplicationSecurityGroupsClientUpdateTagsOptions contains the optional parameters for the ApplicationSecurityGroupsClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ApplicationSecurityGroupUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewApplicationSecurityGroupsClient().UpdateTags(ctx, "rg1", "test-asg", armnetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ApplicationSecurityGroup = armnetwork.ApplicationSecurityGroup{
// 	Name: to.Ptr("test-asg"),
// 	Type: to.Ptr("Microsoft.Network/applicationSecurityGroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/applicationSecurityGroups/test-asg"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armnetwork.ApplicationSecurityGroupPropertiesFormat{
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ResourceGUID: to.Ptr("00000000-0000-0000-0000-000000000000"),
// 	},
// }

type ApplicationSecurityGroupsClientBeginCreateOrUpdateOptions 

type ApplicationSecurityGroupsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationSecurityGroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the ApplicationSecurityGroupsClient.BeginCreateOrUpdate method.

type ApplicationSecurityGroupsClientBeginDeleteOptions 

type ApplicationSecurityGroupsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ApplicationSecurityGroupsClientBeginDeleteOptions contains the optional parameters for the ApplicationSecurityGroupsClient.BeginDelete method.

type ApplicationSecurityGroupsClientCreateOrUpdateResponse 

type ApplicationSecurityGroupsClientCreateOrUpdateResponse struct {
	// An application security group in a resource group.
	ApplicationSecurityGroup
}

ApplicationSecurityGroupsClientCreateOrUpdateResponse contains the response from method ApplicationSecurityGroupsClient.BeginCreateOrUpdate.

type ApplicationSecurityGroupsClientDeleteResponse 

type ApplicationSecurityGroupsClientDeleteResponse struct {
}

ApplicationSecurityGroupsClientDeleteResponse contains the response from method ApplicationSecurityGroupsClient.BeginDelete.

type ApplicationSecurityGroupsClientGetOptions 

type ApplicationSecurityGroupsClientGetOptions struct {
}

ApplicationSecurityGroupsClientGetOptions contains the optional parameters for the ApplicationSecurityGroupsClient.Get method.

type ApplicationSecurityGroupsClientGetResponse 

type ApplicationSecurityGroupsClientGetResponse struct {
	// An application security group in a resource group.
	ApplicationSecurityGroup
}

ApplicationSecurityGroupsClientGetResponse contains the response from method ApplicationSecurityGroupsClient.Get.

type ApplicationSecurityGroupsClientListAllOptions 

type ApplicationSecurityGroupsClientListAllOptions struct {
}

ApplicationSecurityGroupsClientListAllOptions contains the optional parameters for the ApplicationSecurityGroupsClient.NewListAllPager method.

type ApplicationSecurityGroupsClientListAllResponse 

type ApplicationSecurityGroupsClientListAllResponse struct {
	// A list of application security groups.
	ApplicationSecurityGroupListResult
}

ApplicationSecurityGroupsClientListAllResponse contains the response from method ApplicationSecurityGroupsClient.NewListAllPager.

type ApplicationSecurityGroupsClientListOptions 

type ApplicationSecurityGroupsClientListOptions struct {
}

ApplicationSecurityGroupsClientListOptions contains the optional parameters for the ApplicationSecurityGroupsClient.NewListPager method.

type ApplicationSecurityGroupsClientListResponse 

type ApplicationSecurityGroupsClientListResponse struct {
	// A list of application security groups.
	ApplicationSecurityGroupListResult
}

ApplicationSecurityGroupsClientListResponse contains the response from method ApplicationSecurityGroupsClient.NewListPager.

type ApplicationSecurityGroupsClientUpdateTagsOptions 

type ApplicationSecurityGroupsClientUpdateTagsOptions struct {
}

ApplicationSecurityGroupsClientUpdateTagsOptions contains the optional parameters for the ApplicationSecurityGroupsClient.UpdateTags method.

type ApplicationSecurityGroupsClientUpdateTagsResponse 

type ApplicationSecurityGroupsClientUpdateTagsResponse struct {
	// An application security group in a resource group.
	ApplicationSecurityGroup
}

ApplicationSecurityGroupsClientUpdateTagsResponse contains the response from method ApplicationSecurityGroupsClient.UpdateTags.

type AssociationType 

type AssociationType string

AssociationType - The association type of the child resource to the parent resource. 

const (
	AssociationTypeAssociated AssociationType = "Associated"
	AssociationTypeContains   AssociationType = "Contains"
)

func PossibleAssociationTypeValues 

func PossibleAssociationTypeValues() []AssociationType

PossibleAssociationTypeValues returns the possible values for the AssociationType const type.

type AuthenticationMethod 

type AuthenticationMethod string

AuthenticationMethod - VPN client authentication method. 

const (
	AuthenticationMethodEAPMSCHAPv2 AuthenticationMethod = "EAPMSCHAPv2"
	AuthenticationMethodEAPTLS      AuthenticationMethod = "EAPTLS"
)

func PossibleAuthenticationMethodValues 

func PossibleAuthenticationMethodValues() []AuthenticationMethod

PossibleAuthenticationMethodValues returns the possible values for the AuthenticationMethod const type.

type AuthorizationListResult 

type AuthorizationListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// The authorizations in an ExpressRoute Circuit.
	Value []*ExpressRouteCircuitAuthorization
}

AuthorizationListResult - Response for ListAuthorizations API service call retrieves all authorizations that belongs to an ExpressRouteCircuit.

func (AuthorizationListResult) MarshalJSON 

func (a AuthorizationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AuthorizationListResult.

func (*AuthorizationListResult) UnmarshalJSON 

func (a *AuthorizationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AuthorizationListResult.

type AuthorizationPropertiesFormat 

type AuthorizationPropertiesFormat struct {
	// The authorization key.
	AuthorizationKey *string

	// The authorization use status.
	AuthorizationUseStatus *AuthorizationUseStatus

	// READ-ONLY; The reference to the ExpressRoute connection resource using the authorization.
	ConnectionResourceURI *string

	// READ-ONLY; The provisioning state of the authorization resource.
	ProvisioningState *ProvisioningState
}

AuthorizationPropertiesFormat - Properties of ExpressRouteCircuitAuthorization.

func (AuthorizationPropertiesFormat) MarshalJSON 

func (a AuthorizationPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AuthorizationPropertiesFormat.

func (*AuthorizationPropertiesFormat) UnmarshalJSON 

func (a *AuthorizationPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AuthorizationPropertiesFormat.

type AuthorizationUseStatus 

type AuthorizationUseStatus string

AuthorizationUseStatus - The authorization use status. 

const (
	AuthorizationUseStatusAvailable AuthorizationUseStatus = "Available"
	AuthorizationUseStatusInUse     AuthorizationUseStatus = "InUse"
)

func PossibleAuthorizationUseStatusValues 

func PossibleAuthorizationUseStatusValues() []AuthorizationUseStatus

PossibleAuthorizationUseStatusValues returns the possible values for the AuthorizationUseStatus const type.

type AutoApprovedPrivateLinkService 

type AutoApprovedPrivateLinkService struct {
	// The id of the private link service resource.
	PrivateLinkService *string
}

AutoApprovedPrivateLinkService - The information of an AutoApprovedPrivateLinkService.

func (AutoApprovedPrivateLinkService) MarshalJSON 

func (a AutoApprovedPrivateLinkService) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AutoApprovedPrivateLinkService.

func (*AutoApprovedPrivateLinkService) UnmarshalJSON 

func (a *AutoApprovedPrivateLinkService) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AutoApprovedPrivateLinkService.

type AutoApprovedPrivateLinkServicesResult 

type AutoApprovedPrivateLinkServicesResult struct {
	// An array of auto approved private link service.
	Value []*AutoApprovedPrivateLinkService

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

AutoApprovedPrivateLinkServicesResult - An array of private link service id that can be linked to a private end point with auto approved.

func (AutoApprovedPrivateLinkServicesResult) MarshalJSON 

func (a AutoApprovedPrivateLinkServicesResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AutoApprovedPrivateLinkServicesResult.

func (*AutoApprovedPrivateLinkServicesResult) UnmarshalJSON 

func (a *AutoApprovedPrivateLinkServicesResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AutoApprovedPrivateLinkServicesResult.

type AutoLearnPrivateRangesMode 

type AutoLearnPrivateRangesMode string

AutoLearnPrivateRangesMode - The operation mode for automatically learning private ranges to not be SNAT 

const (
	AutoLearnPrivateRangesModeDisabled AutoLearnPrivateRangesMode = "Disabled"
	AutoLearnPrivateRangesModeEnabled  AutoLearnPrivateRangesMode = "Enabled"
)

func PossibleAutoLearnPrivateRangesModeValues 

func PossibleAutoLearnPrivateRangesModeValues() []AutoLearnPrivateRangesMode

PossibleAutoLearnPrivateRangesModeValues returns the possible values for the AutoLearnPrivateRangesMode const type.

type Availability 

type Availability struct {
	// Duration of the availability blob.
	BlobDuration *string

	// The retention of the availability.
	Retention *string

	// The time grain of the availability.
	TimeGrain *string
}

Availability of the metric.

func (Availability) MarshalJSON 

func (a Availability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Availability.

func (*Availability) UnmarshalJSON 

func (a *Availability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Availability.

type AvailableDelegation 

type AvailableDelegation struct {
	// The actions permitted to the service upon delegation.
	Actions []*string

	// A unique identifier of the AvailableDelegation resource.
	ID *string

	// The name of the AvailableDelegation resource.
	Name *string

	// The name of the service and resource.
	ServiceName *string

	// Resource type.
	Type *string
}

AvailableDelegation - The serviceName of an AvailableDelegation indicates a possible delegation for a subnet.

func (AvailableDelegation) MarshalJSON 

func (a AvailableDelegation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableDelegation.

func (*AvailableDelegation) UnmarshalJSON 

func (a *AvailableDelegation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableDelegation.

type AvailableDelegationsClient 

type AvailableDelegationsClient struct {
	// contains filtered or unexported fields
}

AvailableDelegationsClient contains the methods for the AvailableDelegations group. Don't use this type directly, use NewAvailableDelegationsClient() instead.

func NewAvailableDelegationsClient 

func NewAvailableDelegationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailableDelegationsClient, error)

NewAvailableDelegationsClient creates a new instance of AvailableDelegationsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AvailableDelegationsClient) NewListPager 

func (client *AvailableDelegationsClient) NewListPager(location string, options *AvailableDelegationsClientListOptions) *runtime.Pager[AvailableDelegationsClientListResponse]

NewListPager - Gets all of the available subnet delegations for this subscription in this region.

Generated from API version 2024-03-01

  • location - The location of the subnet.
  • options - AvailableDelegationsClientListOptions contains the optional parameters for the AvailableDelegationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AvailableDelegationsSubscriptionGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailableDelegationsClient().NewListPager("westcentralus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AvailableDelegationsResult = armnetwork.AvailableDelegationsResult{
	// 	Value: []*armnetwork.AvailableDelegation{
	// 		{
	// 			Name: to.Ptr("Microsoft.Provider.resourceType"),
	// 			Type: to.Ptr("Microsoft.Network/availableDelegations"),
	// 			Actions: []*string{
	// 				to.Ptr("Microsoft.Network/resource/action")},
	// 				ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/availableDelegations/Microsoft.Provider.resourceType"),
	// 				ServiceName: to.Ptr("Microsoft.Provider/resourceType"),
	// 		}},
	// 	}
}

type AvailableDelegationsClientListOptions 

type AvailableDelegationsClientListOptions struct {
}

AvailableDelegationsClientListOptions contains the optional parameters for the AvailableDelegationsClient.NewListPager method.

type AvailableDelegationsClientListResponse 

type AvailableDelegationsClientListResponse struct {
	// An array of available delegations.
	AvailableDelegationsResult
}

AvailableDelegationsClientListResponse contains the response from method AvailableDelegationsClient.NewListPager.

type AvailableDelegationsResult 

type AvailableDelegationsResult struct {
	// An array of available delegations.
	Value []*AvailableDelegation

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

AvailableDelegationsResult - An array of available delegations.

func (AvailableDelegationsResult) MarshalJSON 

func (a AvailableDelegationsResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableDelegationsResult.

func (*AvailableDelegationsResult) UnmarshalJSON 

func (a *AvailableDelegationsResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableDelegationsResult.

type AvailableEndpointServicesClient 

type AvailableEndpointServicesClient struct {
	// contains filtered or unexported fields
}

AvailableEndpointServicesClient contains the methods for the AvailableEndpointServices group. Don't use this type directly, use NewAvailableEndpointServicesClient() instead.

func NewAvailableEndpointServicesClient 

func NewAvailableEndpointServicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailableEndpointServicesClient, error)

NewAvailableEndpointServicesClient creates a new instance of AvailableEndpointServicesClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AvailableEndpointServicesClient) NewListPager 

func (client *AvailableEndpointServicesClient) NewListPager(location string, options *AvailableEndpointServicesClientListOptions) *runtime.Pager[AvailableEndpointServicesClientListResponse]

NewListPager - List what values of endpoint services are available for use.

Generated from API version 2024-03-01

  • location - The location to check available endpoint services.
  • options - AvailableEndpointServicesClientListOptions contains the optional parameters for the AvailableEndpointServicesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/EndpointServicesList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailableEndpointServicesClient().NewListPager("westus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.EndpointServicesListResult = armnetwork.EndpointServicesListResult{
	// 	Value: []*armnetwork.EndpointServiceResult{
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/virtualNetworkEndpointServices/Microsoft.Storage"),
	// 			Name: to.Ptr("Microsoft.Storage"),
	// 			Type: to.Ptr("Microsoft.Network/virtualNetworkEndpointServices"),
	// 		},
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/virtualNetworkEndpointServices/Microsoft.Sql"),
	// 			Name: to.Ptr("Microsoft.Sql"),
	// 			Type: to.Ptr("Microsoft.Network/virtualNetworkEndpointServices"),
	// 		},
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/virtualNetworkEndpointServices/Microsoft.AzureActiveDirectory"),
	// 			Name: to.Ptr("Microsoft.AzureActiveDirectory"),
	// 			Type: to.Ptr("Microsoft.Network/virtualNetworkEndpointServices"),
	// 	}},
	// }
}

type AvailableEndpointServicesClientListOptions 

type AvailableEndpointServicesClientListOptions struct {
}

AvailableEndpointServicesClientListOptions contains the optional parameters for the AvailableEndpointServicesClient.NewListPager method.

type AvailableEndpointServicesClientListResponse 

type AvailableEndpointServicesClientListResponse struct {
	// Response for the ListAvailableEndpointServices API service call.
	EndpointServicesListResult
}

AvailableEndpointServicesClientListResponse contains the response from method AvailableEndpointServicesClient.NewListPager.

type AvailablePrivateEndpointType 

type AvailablePrivateEndpointType struct {
	// Display name of the resource.
	DisplayName *string

	// A unique identifier of the AvailablePrivateEndpoint Type resource.
	ID *string

	// The name of the service and resource.
	Name *string

	// The name of the service and resource.
	ResourceName *string

	// Resource type.
	Type *string
}

AvailablePrivateEndpointType - The information of an AvailablePrivateEndpointType.

func (AvailablePrivateEndpointType) MarshalJSON 

func (a AvailablePrivateEndpointType) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailablePrivateEndpointType.

func (*AvailablePrivateEndpointType) UnmarshalJSON 

func (a *AvailablePrivateEndpointType) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailablePrivateEndpointType.

type AvailablePrivateEndpointTypesClient 

type AvailablePrivateEndpointTypesClient struct {
	// contains filtered or unexported fields
}

AvailablePrivateEndpointTypesClient contains the methods for the AvailablePrivateEndpointTypes group. Don't use this type directly, use NewAvailablePrivateEndpointTypesClient() instead.

func NewAvailablePrivateEndpointTypesClient 

func NewAvailablePrivateEndpointTypesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailablePrivateEndpointTypesClient, error)

NewAvailablePrivateEndpointTypesClient creates a new instance of AvailablePrivateEndpointTypesClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AvailablePrivateEndpointTypesClient) NewListByResourceGroupPager 

func (client *AvailablePrivateEndpointTypesClient) NewListByResourceGroupPager(location string, resourceGroupName string, options *AvailablePrivateEndpointTypesClientListByResourceGroupOptions) *runtime.Pager[AvailablePrivateEndpointTypesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Returns all of the resource types that can be linked to a Private Endpoint in this subscription in this region.

Generated from API version 2024-03-01

  • location - The location of the domain name.
  • resourceGroupName - The name of the resource group.
  • options - AvailablePrivateEndpointTypesClientListByResourceGroupOptions contains the optional parameters for the AvailablePrivateEndpointTypesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AvailablePrivateEndpointTypesResourceGroupGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailablePrivateEndpointTypesClient().NewListByResourceGroupPager("regionName", "rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AvailablePrivateEndpointTypesResult = armnetwork.AvailablePrivateEndpointTypesResult{
	// 	Value: []*armnetwork.AvailablePrivateEndpointType{
	// 		{
	// 			Type: to.Ptr("Microsoft.Network/availablePrivateEndpointTypes"),
	// 			ID: to.Ptr("/subscriptions/subId/resourceGroups/rg1/providers/Microsoft.Network/availablePrivateEndpointTypes/Microsoft.Provider.resourceType"),
	// 			ResourceName: to.Ptr("Microsoft.Provider/resourceType"),
	// 	}},
	// }
}

func (*AvailablePrivateEndpointTypesClient) NewListPager 

func (client *AvailablePrivateEndpointTypesClient) NewListPager(location string, options *AvailablePrivateEndpointTypesClientListOptions) *runtime.Pager[AvailablePrivateEndpointTypesClientListResponse]

NewListPager - Returns all of the resource types that can be linked to a Private Endpoint in this subscription in this region.

Generated from API version 2024-03-01

  • location - The location of the domain name.
  • options - AvailablePrivateEndpointTypesClientListOptions contains the optional parameters for the AvailablePrivateEndpointTypesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AvailablePrivateEndpointTypesGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailablePrivateEndpointTypesClient().NewListPager("regionName", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AvailablePrivateEndpointTypesResult = armnetwork.AvailablePrivateEndpointTypesResult{
	// 	Value: []*armnetwork.AvailablePrivateEndpointType{
	// 		{
	// 			Type: to.Ptr("Microsoft.Network/availablePrivateEndpointTypes"),
	// 			ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/availablePrivateEndpointTypes/Microsoft.Provider.resourceType"),
	// 			ResourceName: to.Ptr("Microsoft.Provider/resourceType"),
	// 	}},
	// }
}

type AvailablePrivateEndpointTypesClientListByResourceGroupOptions 

type AvailablePrivateEndpointTypesClientListByResourceGroupOptions struct {
}

AvailablePrivateEndpointTypesClientListByResourceGroupOptions contains the optional parameters for the AvailablePrivateEndpointTypesClient.NewListByResourceGroupPager method.

type AvailablePrivateEndpointTypesClientListByResourceGroupResponse 

type AvailablePrivateEndpointTypesClientListByResourceGroupResponse struct {
	// An array of available PrivateEndpoint types.
	AvailablePrivateEndpointTypesResult
}

AvailablePrivateEndpointTypesClientListByResourceGroupResponse contains the response from method AvailablePrivateEndpointTypesClient.NewListByResourceGroupPager.

type AvailablePrivateEndpointTypesClientListOptions 

type AvailablePrivateEndpointTypesClientListOptions struct {
}

AvailablePrivateEndpointTypesClientListOptions contains the optional parameters for the AvailablePrivateEndpointTypesClient.NewListPager method.

type AvailablePrivateEndpointTypesClientListResponse 

type AvailablePrivateEndpointTypesClientListResponse struct {
	// An array of available PrivateEndpoint types.
	AvailablePrivateEndpointTypesResult
}

AvailablePrivateEndpointTypesClientListResponse contains the response from method AvailablePrivateEndpointTypesClient.NewListPager.

type AvailablePrivateEndpointTypesResult 

type AvailablePrivateEndpointTypesResult struct {
	// An array of available privateEndpoint type.
	Value []*AvailablePrivateEndpointType

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

AvailablePrivateEndpointTypesResult - An array of available PrivateEndpoint types.

func (AvailablePrivateEndpointTypesResult) MarshalJSON 

func (a AvailablePrivateEndpointTypesResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailablePrivateEndpointTypesResult.

func (*AvailablePrivateEndpointTypesResult) UnmarshalJSON 

func (a *AvailablePrivateEndpointTypesResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailablePrivateEndpointTypesResult.

type AvailableProvidersList 

type AvailableProvidersList struct {
	// REQUIRED; List of available countries.
	Countries []*AvailableProvidersListCountry
}

AvailableProvidersList - List of available countries with details.

func (AvailableProvidersList) MarshalJSON 

func (a AvailableProvidersList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableProvidersList.

func (*AvailableProvidersList) UnmarshalJSON 

func (a *AvailableProvidersList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProvidersList.

type AvailableProvidersListCity 

type AvailableProvidersListCity struct {
	// The city or town name.
	CityName *string

	// A list of Internet service providers.
	Providers []*string
}

AvailableProvidersListCity - City or town details.

func (AvailableProvidersListCity) MarshalJSON 

func (a AvailableProvidersListCity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableProvidersListCity.

func (*AvailableProvidersListCity) UnmarshalJSON 

func (a *AvailableProvidersListCity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProvidersListCity.

type AvailableProvidersListCountry 

type AvailableProvidersListCountry struct {
	// The country name.
	CountryName *string

	// A list of Internet service providers.
	Providers []*string

	// List of available states in the country.
	States []*AvailableProvidersListState
}

AvailableProvidersListCountry - Country details.

func (AvailableProvidersListCountry) MarshalJSON 

func (a AvailableProvidersListCountry) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableProvidersListCountry.

func (*AvailableProvidersListCountry) UnmarshalJSON 

func (a *AvailableProvidersListCountry) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProvidersListCountry.

type AvailableProvidersListParameters 

type AvailableProvidersListParameters struct {
	// A list of Azure regions.
	AzureLocations []*string

	// The city or town for available providers list.
	City *string

	// The country for available providers list.
	Country *string

	// The state for available providers list.
	State *string
}

AvailableProvidersListParameters - Constraints that determine the list of available Internet service providers.

func (AvailableProvidersListParameters) MarshalJSON 

func (a AvailableProvidersListParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableProvidersListParameters.

func (*AvailableProvidersListParameters) UnmarshalJSON 

func (a *AvailableProvidersListParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProvidersListParameters.

type AvailableProvidersListState 

type AvailableProvidersListState struct {
	// List of available cities or towns in the state.
	Cities []*AvailableProvidersListCity

	// A list of Internet service providers.
	Providers []*string

	// The state name.
	StateName *string
}

AvailableProvidersListState - State details.

func (AvailableProvidersListState) MarshalJSON 

func (a AvailableProvidersListState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableProvidersListState.

func (*AvailableProvidersListState) UnmarshalJSON 

func (a *AvailableProvidersListState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProvidersListState.

type AvailableResourceGroupDelegationsClient 

type AvailableResourceGroupDelegationsClient struct {
	// contains filtered or unexported fields
}

AvailableResourceGroupDelegationsClient contains the methods for the AvailableResourceGroupDelegations group. Don't use this type directly, use NewAvailableResourceGroupDelegationsClient() instead.

func NewAvailableResourceGroupDelegationsClient 

func NewAvailableResourceGroupDelegationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailableResourceGroupDelegationsClient, error)

NewAvailableResourceGroupDelegationsClient creates a new instance of AvailableResourceGroupDelegationsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AvailableResourceGroupDelegationsClient) NewListPager 

func (client *AvailableResourceGroupDelegationsClient) NewListPager(location string, resourceGroupName string, options *AvailableResourceGroupDelegationsClientListOptions) *runtime.Pager[AvailableResourceGroupDelegationsClientListResponse]

NewListPager - Gets all of the available subnet delegations for this resource group in this region.

Generated from API version 2024-03-01

  • location - The location of the domain name.
  • resourceGroupName - The name of the resource group.
  • options - AvailableResourceGroupDelegationsClientListOptions contains the optional parameters for the AvailableResourceGroupDelegationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AvailableDelegationsResourceGroupGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailableResourceGroupDelegationsClient().NewListPager("westcentralus", "rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AvailableDelegationsResult = armnetwork.AvailableDelegationsResult{
	// 	Value: []*armnetwork.AvailableDelegation{
	// 		{
	// 			Name: to.Ptr("Microsoft.Provider.resourceType"),
	// 			Type: to.Ptr("Microsoft.Network/availableDelegations"),
	// 			Actions: []*string{
	// 				to.Ptr("Microsoft.Network/resource/action")},
	// 				ID: to.Ptr("/subscriptions/subId/resourceGroups/rg1/providers/Microsoft.Network/availableDelegations/Microsoft.Provider.resourceType"),
	// 				ServiceName: to.Ptr("Microsoft.Provider/resourceType"),
	// 		}},
	// 	}
}

type AvailableResourceGroupDelegationsClientListOptions 

type AvailableResourceGroupDelegationsClientListOptions struct {
}

AvailableResourceGroupDelegationsClientListOptions contains the optional parameters for the AvailableResourceGroupDelegationsClient.NewListPager method.

type AvailableResourceGroupDelegationsClientListResponse 

type AvailableResourceGroupDelegationsClientListResponse struct {
	// An array of available delegations.
	AvailableDelegationsResult
}

AvailableResourceGroupDelegationsClientListResponse contains the response from method AvailableResourceGroupDelegationsClient.NewListPager.

type AvailableServiceAlias 

type AvailableServiceAlias struct {
	// The ID of the service alias.
	ID *string

	// The name of the service alias.
	Name *string

	// The resource name of the service alias.
	ResourceName *string

	// The type of the resource.
	Type *string
}

AvailableServiceAlias - The available service alias.

func (AvailableServiceAlias) MarshalJSON 

func (a AvailableServiceAlias) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableServiceAlias.

func (*AvailableServiceAlias) UnmarshalJSON 

func (a *AvailableServiceAlias) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableServiceAlias.

type AvailableServiceAliasesClient 

type AvailableServiceAliasesClient struct {
	// contains filtered or unexported fields
}

AvailableServiceAliasesClient contains the methods for the AvailableServiceAliases group. Don't use this type directly, use NewAvailableServiceAliasesClient() instead.

func NewAvailableServiceAliasesClient 

func NewAvailableServiceAliasesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailableServiceAliasesClient, error)

NewAvailableServiceAliasesClient creates a new instance of AvailableServiceAliasesClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AvailableServiceAliasesClient) NewListByResourceGroupPager 

func (client *AvailableServiceAliasesClient) NewListByResourceGroupPager(resourceGroupName string, location string, options *AvailableServiceAliasesClientListByResourceGroupOptions) *runtime.Pager[AvailableServiceAliasesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets all available service aliases for this resource group in this region.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • location - The location.
  • options - AvailableServiceAliasesClientListByResourceGroupOptions contains the optional parameters for the AvailableServiceAliasesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AvailableServiceAliasesListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailableServiceAliasesClient().NewListByResourceGroupPager("rg1", "westcentralus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AvailableServiceAliasesResult = armnetwork.AvailableServiceAliasesResult{
	// 	Value: []*armnetwork.AvailableServiceAlias{
	// 		{
	// 			Name: to.Ptr("servicesAzure"),
	// 			Type: to.Ptr("Microsoft.Network/AvailableServiceAliases"),
	// 			ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/AvailableServiceAliases/servicesAzure"),
	// 			ResourceName: to.Ptr("/services/Azure"),
	// 		},
	// 		{
	// 			Name: to.Ptr("servicesAzureManagedInstance"),
	// 			Type: to.Ptr("Microsoft.Network/AvailableServiceAliases"),
	// 			ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/AvailableServiceAliases/servicesAzureManagedInstance"),
	// 			ResourceName: to.Ptr("/services/Azure/ManagedInstance"),
	// 	}},
	// }
}

func (*AvailableServiceAliasesClient) NewListPager 

func (client *AvailableServiceAliasesClient) NewListPager(location string, options *AvailableServiceAliasesClientListOptions) *runtime.Pager[AvailableServiceAliasesClientListResponse]

NewListPager - Gets all available service aliases for this subscription in this region.

Generated from API version 2024-03-01

  • location - The location.
  • options - AvailableServiceAliasesClientListOptions contains the optional parameters for the AvailableServiceAliasesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AvailableServiceAliasesList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAvailableServiceAliasesClient().NewListPager("westcentralus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AvailableServiceAliasesResult = armnetwork.AvailableServiceAliasesResult{
	// 	Value: []*armnetwork.AvailableServiceAlias{
	// 		{
	// 			Name: to.Ptr("servicesAzure"),
	// 			Type: to.Ptr("Microsoft.Network/AvailableServiceAliases"),
	// 			ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/AvailableServiceAliases/servicesAzure"),
	// 			ResourceName: to.Ptr("/services/Azure"),
	// 		},
	// 		{
	// 			Name: to.Ptr("servicesAzureManagedInstance"),
	// 			Type: to.Ptr("Microsoft.Network/AvailableServiceAliases"),
	// 			ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/AvailableServiceAliases/servicesAzureManagedInstance"),
	// 			ResourceName: to.Ptr("/services/Azure/ManagedInstance"),
	// 	}},
	// }
}

type AvailableServiceAliasesClientListByResourceGroupOptions 

type AvailableServiceAliasesClientListByResourceGroupOptions struct {
}

AvailableServiceAliasesClientListByResourceGroupOptions contains the optional parameters for the AvailableServiceAliasesClient.NewListByResourceGroupPager method.

type AvailableServiceAliasesClientListByResourceGroupResponse 

type AvailableServiceAliasesClientListByResourceGroupResponse struct {
	// An array of available service aliases.
	AvailableServiceAliasesResult
}

AvailableServiceAliasesClientListByResourceGroupResponse contains the response from method AvailableServiceAliasesClient.NewListByResourceGroupPager.

type AvailableServiceAliasesClientListOptions 

type AvailableServiceAliasesClientListOptions struct {
}

AvailableServiceAliasesClientListOptions contains the optional parameters for the AvailableServiceAliasesClient.NewListPager method.

type AvailableServiceAliasesClientListResponse 

type AvailableServiceAliasesClientListResponse struct {
	// An array of available service aliases.
	AvailableServiceAliasesResult
}

AvailableServiceAliasesClientListResponse contains the response from method AvailableServiceAliasesClient.NewListPager.

type AvailableServiceAliasesResult 

type AvailableServiceAliasesResult struct {
	// An array of available service aliases.
	Value []*AvailableServiceAlias

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

AvailableServiceAliasesResult - An array of available service aliases.

func (AvailableServiceAliasesResult) MarshalJSON 

func (a AvailableServiceAliasesResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AvailableServiceAliasesResult.

func (*AvailableServiceAliasesResult) UnmarshalJSON 

func (a *AvailableServiceAliasesResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableServiceAliasesResult.

type AzureAsyncOperationResult 

type AzureAsyncOperationResult struct {
	// Details of the error occurred during specified asynchronous operation.
	Error *Error

	// Status of the Azure async operation.
	Status *NetworkOperationStatus
}

AzureAsyncOperationResult - The response body contains the status of the specified asynchronous operation, indicating whether it has succeeded, is in progress, or has failed. Note that this status is distinct from the HTTP status code returned for the Get Operation Status operation itself. If the asynchronous operation succeeded, the response body includes the HTTP status code for the successful request. If the asynchronous operation failed, the response body includes the HTTP status code for the failed request and error information regarding the failure.

func (AzureAsyncOperationResult) MarshalJSON 

func (a AzureAsyncOperationResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureAsyncOperationResult.

func (*AzureAsyncOperationResult) UnmarshalJSON 

func (a *AzureAsyncOperationResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureAsyncOperationResult.

type AzureFirewall 

type AzureFirewall struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Properties of the azure firewall.
	Properties *AzureFirewallPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// A list of availability zones denoting where the resource needs to come from.
	Zones []*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

AzureFirewall - Azure Firewall resource.

func (AzureFirewall) MarshalJSON 

func (a AzureFirewall) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewall.

func (*AzureFirewall) UnmarshalJSON 

func (a *AzureFirewall) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewall.

type AzureFirewallApplicationRule 

type AzureFirewallApplicationRule struct {
	// Description of the rule.
	Description *string

	// List of FQDN Tags for this rule.
	FqdnTags []*string

	// Name of the application rule.
	Name *string

	// Array of ApplicationRuleProtocols.
	Protocols []*AzureFirewallApplicationRuleProtocol

	// List of source IP addresses for this rule.
	SourceAddresses []*string

	// List of source IpGroups for this rule.
	SourceIPGroups []*string

	// List of FQDNs for this rule.
	TargetFqdns []*string
}

AzureFirewallApplicationRule - Properties of an application rule.

func (AzureFirewallApplicationRule) MarshalJSON 

func (a AzureFirewallApplicationRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallApplicationRule.

func (*AzureFirewallApplicationRule) UnmarshalJSON 

func (a *AzureFirewallApplicationRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallApplicationRule.

type AzureFirewallApplicationRuleCollection 

type AzureFirewallApplicationRuleCollection struct {
	// Resource ID.
	ID *string

	// The name of the resource that is unique within the Azure firewall. This name can be used to access the resource.
	Name *string

	// Properties of the azure firewall application rule collection.
	Properties *AzureFirewallApplicationRuleCollectionPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string
}

AzureFirewallApplicationRuleCollection - Application rule collection resource.

func (AzureFirewallApplicationRuleCollection) MarshalJSON 

func (a AzureFirewallApplicationRuleCollection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallApplicationRuleCollection.

func (*AzureFirewallApplicationRuleCollection) UnmarshalJSON 

func (a *AzureFirewallApplicationRuleCollection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallApplicationRuleCollection.

type AzureFirewallApplicationRuleCollectionPropertiesFormat 

type AzureFirewallApplicationRuleCollectionPropertiesFormat struct {
	// The action type of a rule collection.
	Action *AzureFirewallRCAction

	// Priority of the application rule collection resource.
	Priority *int32

	// Collection of rules used by a application rule collection.
	Rules []*AzureFirewallApplicationRule

	// READ-ONLY; The provisioning state of the application rule collection resource.
	ProvisioningState *ProvisioningState
}

AzureFirewallApplicationRuleCollectionPropertiesFormat - Properties of the application rule collection.

func (AzureFirewallApplicationRuleCollectionPropertiesFormat) MarshalJSON 

func (a AzureFirewallApplicationRuleCollectionPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallApplicationRuleCollectionPropertiesFormat.

func (*AzureFirewallApplicationRuleCollectionPropertiesFormat) UnmarshalJSON 

func (a *AzureFirewallApplicationRuleCollectionPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallApplicationRuleCollectionPropertiesFormat.

type AzureFirewallApplicationRuleProtocol 

type AzureFirewallApplicationRuleProtocol struct {
	// Port number for the protocol, cannot be greater than 64000. This field is optional.
	Port *int32

	// Protocol type.
	ProtocolType *AzureFirewallApplicationRuleProtocolType
}

AzureFirewallApplicationRuleProtocol - Properties of the application rule protocol.

func (AzureFirewallApplicationRuleProtocol) MarshalJSON 

func (a AzureFirewallApplicationRuleProtocol) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallApplicationRuleProtocol.

func (*AzureFirewallApplicationRuleProtocol) UnmarshalJSON 

func (a *AzureFirewallApplicationRuleProtocol) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallApplicationRuleProtocol.

type AzureFirewallApplicationRuleProtocolType 

type AzureFirewallApplicationRuleProtocolType string

AzureFirewallApplicationRuleProtocolType - The protocol type of a Application Rule resource. 

const (
	AzureFirewallApplicationRuleProtocolTypeHTTP  AzureFirewallApplicationRuleProtocolType = "Http"
	AzureFirewallApplicationRuleProtocolTypeHTTPS AzureFirewallApplicationRuleProtocolType = "Https"
	AzureFirewallApplicationRuleProtocolTypeMssql AzureFirewallApplicationRuleProtocolType = "Mssql"
)

func PossibleAzureFirewallApplicationRuleProtocolTypeValues 

func PossibleAzureFirewallApplicationRuleProtocolTypeValues() []AzureFirewallApplicationRuleProtocolType

PossibleAzureFirewallApplicationRuleProtocolTypeValues returns the possible values for the AzureFirewallApplicationRuleProtocolType const type.

type AzureFirewallAutoscaleConfiguration 

type AzureFirewallAutoscaleConfiguration struct {
	// The maximum number of capacity units for this azure firewall. Use null to reset the value to the service default.
	MaxCapacity *int32

	// The minimum number of capacity units for this azure firewall. Use null to reset the value to the service default.
	MinCapacity *int32
}

AzureFirewallAutoscaleConfiguration - Azure Firewall Autoscale Configuration parameters.

func (AzureFirewallAutoscaleConfiguration) MarshalJSON 

func (a AzureFirewallAutoscaleConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallAutoscaleConfiguration.

func (*AzureFirewallAutoscaleConfiguration) UnmarshalJSON 

func (a *AzureFirewallAutoscaleConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallAutoscaleConfiguration.

type AzureFirewallFqdnTag 

type AzureFirewallFqdnTag struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Properties of the azure firewall FQDN tag.
	Properties *AzureFirewallFqdnTagPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

AzureFirewallFqdnTag - Azure Firewall FQDN Tag Resource.

func (AzureFirewallFqdnTag) MarshalJSON 

func (a AzureFirewallFqdnTag) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallFqdnTag.

func (*AzureFirewallFqdnTag) UnmarshalJSON 

func (a *AzureFirewallFqdnTag) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallFqdnTag.

type AzureFirewallFqdnTagListResult 

type AzureFirewallFqdnTagListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of Azure Firewall FQDN Tags in a resource group.
	Value []*AzureFirewallFqdnTag
}

AzureFirewallFqdnTagListResult - Response for ListAzureFirewallFqdnTags API service call.

func (AzureFirewallFqdnTagListResult) MarshalJSON 

func (a AzureFirewallFqdnTagListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallFqdnTagListResult.

func (*AzureFirewallFqdnTagListResult) UnmarshalJSON 

func (a *AzureFirewallFqdnTagListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallFqdnTagListResult.

type AzureFirewallFqdnTagPropertiesFormat 

type AzureFirewallFqdnTagPropertiesFormat struct {
	// READ-ONLY; The name of this FQDN Tag.
	FqdnTagName *string

	// READ-ONLY; The provisioning state of the Azure firewall FQDN tag resource.
	ProvisioningState *ProvisioningState
}

AzureFirewallFqdnTagPropertiesFormat - Azure Firewall FQDN Tag Properties.

func (AzureFirewallFqdnTagPropertiesFormat) MarshalJSON 

func (a AzureFirewallFqdnTagPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallFqdnTagPropertiesFormat.

func (*AzureFirewallFqdnTagPropertiesFormat) UnmarshalJSON 

func (a *AzureFirewallFqdnTagPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallFqdnTagPropertiesFormat.

type AzureFirewallFqdnTagsClient 

type AzureFirewallFqdnTagsClient struct {
	// contains filtered or unexported fields
}

AzureFirewallFqdnTagsClient contains the methods for the AzureFirewallFqdnTags group. Don't use this type directly, use NewAzureFirewallFqdnTagsClient() instead.

func NewAzureFirewallFqdnTagsClient 

func NewAzureFirewallFqdnTagsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AzureFirewallFqdnTagsClient, error)

NewAzureFirewallFqdnTagsClient creates a new instance of AzureFirewallFqdnTagsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AzureFirewallFqdnTagsClient) NewListAllPager 

func (client *AzureFirewallFqdnTagsClient) NewListAllPager(options *AzureFirewallFqdnTagsClientListAllOptions) *runtime.Pager[AzureFirewallFqdnTagsClientListAllResponse]

NewListAllPager - Gets all the Azure Firewall FQDN Tags in a subscription.

Generated from API version 2024-03-01

  • options - AzureFirewallFqdnTagsClientListAllOptions contains the optional parameters for the AzureFirewallFqdnTagsClient.NewListAllPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallFqdnTagsListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAzureFirewallFqdnTagsClient().NewListAllPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AzureFirewallFqdnTagListResult = armnetwork.AzureFirewallFqdnTagListResult{
	// 	Value: []*armnetwork.AzureFirewallFqdnTag{
	// 		{
	// 			Name: to.Ptr("azfwfqdntag"),
	// 			Type: to.Ptr("Microsoft.Network/azureFirewallFqdnTags"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewallFqdnTags/azfwfqdntag"),
	// 			Location: to.Ptr("West US"),
	// 			Tags: map[string]*string{
	// 				"key1": to.Ptr("value1"),
	// 			},
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.AzureFirewallFqdnTagPropertiesFormat{
	// 				FqdnTagName: to.Ptr("azfwfqdntag"),
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

type AzureFirewallFqdnTagsClientListAllOptions 

type AzureFirewallFqdnTagsClientListAllOptions struct {
}

AzureFirewallFqdnTagsClientListAllOptions contains the optional parameters for the AzureFirewallFqdnTagsClient.NewListAllPager method.

type AzureFirewallFqdnTagsClientListAllResponse 

type AzureFirewallFqdnTagsClientListAllResponse struct {
	// Response for ListAzureFirewallFqdnTags API service call.
	AzureFirewallFqdnTagListResult
}

AzureFirewallFqdnTagsClientListAllResponse contains the response from method AzureFirewallFqdnTagsClient.NewListAllPager.

type AzureFirewallIPConfiguration 

type AzureFirewallIPConfiguration struct {
	// Resource ID.
	ID *string

	// Name of the resource that is unique within a resource group. This name can be used to access the resource.
	Name *string

	// Properties of the azure firewall IP configuration.
	Properties *AzureFirewallIPConfigurationPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

AzureFirewallIPConfiguration - IP configuration of an Azure Firewall.

func (AzureFirewallIPConfiguration) MarshalJSON 

func (a AzureFirewallIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallIPConfiguration.

func (*AzureFirewallIPConfiguration) UnmarshalJSON 

func (a *AzureFirewallIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallIPConfiguration.

type AzureFirewallIPConfigurationPropertiesFormat 

type AzureFirewallIPConfigurationPropertiesFormat struct {
	// Reference to the PublicIP resource. This field is a mandatory input if subnet is not null.
	PublicIPAddress *SubResource

	// Reference to the subnet resource. This resource must be named 'AzureFirewallSubnet' or 'AzureFirewallManagementSubnet'.
	Subnet *SubResource

	// READ-ONLY; The Firewall Internal Load Balancer IP to be used as the next hop in User Defined Routes.
	PrivateIPAddress *string

	// READ-ONLY; The provisioning state of the Azure firewall IP configuration resource.
	ProvisioningState *ProvisioningState
}

AzureFirewallIPConfigurationPropertiesFormat - Properties of IP configuration of an Azure Firewall.

func (AzureFirewallIPConfigurationPropertiesFormat) MarshalJSON 

func (a AzureFirewallIPConfigurationPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallIPConfigurationPropertiesFormat.

func (*AzureFirewallIPConfigurationPropertiesFormat) UnmarshalJSON 

func (a *AzureFirewallIPConfigurationPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallIPConfigurationPropertiesFormat.

type AzureFirewallIPGroups 

type AzureFirewallIPGroups struct {
	// READ-ONLY; The iteration number.
	ChangeNumber *string

	// READ-ONLY; Resource ID.
	ID *string
}

AzureFirewallIPGroups - IpGroups associated with azure firewall.

func (AzureFirewallIPGroups) MarshalJSON 

func (a AzureFirewallIPGroups) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallIPGroups.

func (*AzureFirewallIPGroups) UnmarshalJSON 

func (a *AzureFirewallIPGroups) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallIPGroups.

type AzureFirewallListResult 

type AzureFirewallListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of Azure Firewalls in a resource group.
	Value []*AzureFirewall
}

AzureFirewallListResult - Response for ListAzureFirewalls API service call.

func (AzureFirewallListResult) MarshalJSON 

func (a AzureFirewallListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallListResult.

func (*AzureFirewallListResult) UnmarshalJSON 

func (a *AzureFirewallListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallListResult.

type AzureFirewallNatRCAction 

type AzureFirewallNatRCAction struct {
	// The type of action.
	Type *AzureFirewallNatRCActionType
}

AzureFirewallNatRCAction - AzureFirewall NAT Rule Collection Action.

func (AzureFirewallNatRCAction) MarshalJSON 

func (a AzureFirewallNatRCAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNatRCAction.

func (*AzureFirewallNatRCAction) UnmarshalJSON 

func (a *AzureFirewallNatRCAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNatRCAction.

type AzureFirewallNatRCActionType 

type AzureFirewallNatRCActionType string

AzureFirewallNatRCActionType - The action type of a NAT rule collection. 

const (
	AzureFirewallNatRCActionTypeDnat AzureFirewallNatRCActionType = "Dnat"
	AzureFirewallNatRCActionTypeSnat AzureFirewallNatRCActionType = "Snat"
)

func PossibleAzureFirewallNatRCActionTypeValues 

func PossibleAzureFirewallNatRCActionTypeValues() []AzureFirewallNatRCActionType

PossibleAzureFirewallNatRCActionTypeValues returns the possible values for the AzureFirewallNatRCActionType const type.

type AzureFirewallNatRule 

type AzureFirewallNatRule struct {
	// Description of the rule.
	Description *string

	// List of destination IP addresses for this rule. Supports IP ranges, prefixes, and service tags.
	DestinationAddresses []*string

	// List of destination ports.
	DestinationPorts []*string

	// Name of the NAT rule.
	Name *string

	// Array of AzureFirewallNetworkRuleProtocols applicable to this NAT rule.
	Protocols []*AzureFirewallNetworkRuleProtocol

	// List of source IP addresses for this rule.
	SourceAddresses []*string

	// List of source IpGroups for this rule.
	SourceIPGroups []*string

	// The translated address for this NAT rule.
	TranslatedAddress *string

	// The translated FQDN for this NAT rule.
	TranslatedFqdn *string

	// The translated port for this NAT rule.
	TranslatedPort *string
}

AzureFirewallNatRule - Properties of a NAT rule.

func (AzureFirewallNatRule) MarshalJSON 

func (a AzureFirewallNatRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNatRule.

func (*AzureFirewallNatRule) UnmarshalJSON 

func (a *AzureFirewallNatRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNatRule.

type AzureFirewallNatRuleCollection 

type AzureFirewallNatRuleCollection struct {
	// Resource ID.
	ID *string

	// The name of the resource that is unique within the Azure firewall. This name can be used to access the resource.
	Name *string

	// Properties of the azure firewall NAT rule collection.
	Properties *AzureFirewallNatRuleCollectionProperties

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string
}

AzureFirewallNatRuleCollection - NAT rule collection resource.

func (AzureFirewallNatRuleCollection) MarshalJSON 

func (a AzureFirewallNatRuleCollection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNatRuleCollection.

func (*AzureFirewallNatRuleCollection) UnmarshalJSON 

func (a *AzureFirewallNatRuleCollection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNatRuleCollection.

type AzureFirewallNatRuleCollectionProperties 

type AzureFirewallNatRuleCollectionProperties struct {
	// The action type of a NAT rule collection.
	Action *AzureFirewallNatRCAction

	// Priority of the NAT rule collection resource.
	Priority *int32

	// Collection of rules used by a NAT rule collection.
	Rules []*AzureFirewallNatRule

	// READ-ONLY; The provisioning state of the NAT rule collection resource.
	ProvisioningState *ProvisioningState
}

AzureFirewallNatRuleCollectionProperties - Properties of the NAT rule collection.

func (AzureFirewallNatRuleCollectionProperties) MarshalJSON 

func (a AzureFirewallNatRuleCollectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNatRuleCollectionProperties.

func (*AzureFirewallNatRuleCollectionProperties) UnmarshalJSON 

func (a *AzureFirewallNatRuleCollectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNatRuleCollectionProperties.

type AzureFirewallNetworkRule 

type AzureFirewallNetworkRule struct {
	// Description of the rule.
	Description *string

	// List of destination IP addresses.
	DestinationAddresses []*string

	// List of destination FQDNs.
	DestinationFqdns []*string

	// List of destination IpGroups for this rule.
	DestinationIPGroups []*string

	// List of destination ports.
	DestinationPorts []*string

	// Name of the network rule.
	Name *string

	// Array of AzureFirewallNetworkRuleProtocols.
	Protocols []*AzureFirewallNetworkRuleProtocol

	// List of source IP addresses for this rule.
	SourceAddresses []*string

	// List of source IpGroups for this rule.
	SourceIPGroups []*string
}

AzureFirewallNetworkRule - Properties of the network rule.

func (AzureFirewallNetworkRule) MarshalJSON 

func (a AzureFirewallNetworkRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNetworkRule.

func (*AzureFirewallNetworkRule) UnmarshalJSON 

func (a *AzureFirewallNetworkRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNetworkRule.

type AzureFirewallNetworkRuleCollection 

type AzureFirewallNetworkRuleCollection struct {
	// Resource ID.
	ID *string

	// The name of the resource that is unique within the Azure firewall. This name can be used to access the resource.
	Name *string

	// Properties of the azure firewall network rule collection.
	Properties *AzureFirewallNetworkRuleCollectionPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string
}

AzureFirewallNetworkRuleCollection - Network rule collection resource.

func (AzureFirewallNetworkRuleCollection) MarshalJSON 

func (a AzureFirewallNetworkRuleCollection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNetworkRuleCollection.

func (*AzureFirewallNetworkRuleCollection) UnmarshalJSON 

func (a *AzureFirewallNetworkRuleCollection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNetworkRuleCollection.

type AzureFirewallNetworkRuleCollectionPropertiesFormat 

type AzureFirewallNetworkRuleCollectionPropertiesFormat struct {
	// The action type of a rule collection.
	Action *AzureFirewallRCAction

	// Priority of the network rule collection resource.
	Priority *int32

	// Collection of rules used by a network rule collection.
	Rules []*AzureFirewallNetworkRule

	// READ-ONLY; The provisioning state of the network rule collection resource.
	ProvisioningState *ProvisioningState
}

AzureFirewallNetworkRuleCollectionPropertiesFormat - Properties of the network rule collection.

func (AzureFirewallNetworkRuleCollectionPropertiesFormat) MarshalJSON 

func (a AzureFirewallNetworkRuleCollectionPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallNetworkRuleCollectionPropertiesFormat.

func (*AzureFirewallNetworkRuleCollectionPropertiesFormat) UnmarshalJSON 

func (a *AzureFirewallNetworkRuleCollectionPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallNetworkRuleCollectionPropertiesFormat.

type AzureFirewallNetworkRuleProtocol 

type AzureFirewallNetworkRuleProtocol string

AzureFirewallNetworkRuleProtocol - The protocol of a Network Rule resource. 

const (
	AzureFirewallNetworkRuleProtocolAny  AzureFirewallNetworkRuleProtocol = "Any"
	AzureFirewallNetworkRuleProtocolICMP AzureFirewallNetworkRuleProtocol = "ICMP"
	AzureFirewallNetworkRuleProtocolTCP  AzureFirewallNetworkRuleProtocol = "TCP"
	AzureFirewallNetworkRuleProtocolUDP  AzureFirewallNetworkRuleProtocol = "UDP"
)

func PossibleAzureFirewallNetworkRuleProtocolValues 

func PossibleAzureFirewallNetworkRuleProtocolValues() []AzureFirewallNetworkRuleProtocol

PossibleAzureFirewallNetworkRuleProtocolValues returns the possible values for the AzureFirewallNetworkRuleProtocol const type.

type AzureFirewallPacketCaptureFlags 

type AzureFirewallPacketCaptureFlags struct {
	// Flags to capture
	Type *AzureFirewallPacketCaptureFlagsType
}

AzureFirewallPacketCaptureFlags - Properties of the AzureFirewallRCAction.

func (AzureFirewallPacketCaptureFlags) MarshalJSON 

func (a AzureFirewallPacketCaptureFlags) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallPacketCaptureFlags.

func (*AzureFirewallPacketCaptureFlags) UnmarshalJSON 

func (a *AzureFirewallPacketCaptureFlags) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallPacketCaptureFlags.

type AzureFirewallPacketCaptureFlagsType 

type AzureFirewallPacketCaptureFlagsType string

AzureFirewallPacketCaptureFlagsType - The flags type to be captured. 

const (
	AzureFirewallPacketCaptureFlagsTypeAck  AzureFirewallPacketCaptureFlagsType = "ack"
	AzureFirewallPacketCaptureFlagsTypeFin  AzureFirewallPacketCaptureFlagsType = "fin"
	AzureFirewallPacketCaptureFlagsTypePush AzureFirewallPacketCaptureFlagsType = "push"
	AzureFirewallPacketCaptureFlagsTypeRst  AzureFirewallPacketCaptureFlagsType = "rst"
	AzureFirewallPacketCaptureFlagsTypeSyn  AzureFirewallPacketCaptureFlagsType = "syn"
	AzureFirewallPacketCaptureFlagsTypeUrg  AzureFirewallPacketCaptureFlagsType = "urg"
)

func PossibleAzureFirewallPacketCaptureFlagsTypeValues 

func PossibleAzureFirewallPacketCaptureFlagsTypeValues() []AzureFirewallPacketCaptureFlagsType

PossibleAzureFirewallPacketCaptureFlagsTypeValues returns the possible values for the AzureFirewallPacketCaptureFlagsType const type.

type AzureFirewallPacketCaptureRule 

type AzureFirewallPacketCaptureRule struct {
	// List of ports to be captured.
	DestinationPorts []*string

	// List of destination IP addresses/subnets to be captured.
	Destinations []*string

	// List of source IP addresses/subnets to be captured.
	Sources []*string
}

AzureFirewallPacketCaptureRule - Group of src/dest ips and ports to be captured.

func (AzureFirewallPacketCaptureRule) MarshalJSON 

func (a AzureFirewallPacketCaptureRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallPacketCaptureRule.

func (*AzureFirewallPacketCaptureRule) UnmarshalJSON 

func (a *AzureFirewallPacketCaptureRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallPacketCaptureRule.

type AzureFirewallPropertiesFormat 

type AzureFirewallPropertiesFormat struct {
	// The additional properties used to further config this azure firewall.
	AdditionalProperties map[string]*string

	// Collection of application rule collections used by Azure Firewall.
	ApplicationRuleCollections []*AzureFirewallApplicationRuleCollection

	// Properties to provide a custom autoscale configuration to this azure firewall.
	AutoscaleConfiguration *AzureFirewallAutoscaleConfiguration

	// The firewallPolicy associated with this azure firewall.
	FirewallPolicy *SubResource

	// IP addresses associated with AzureFirewall.
	HubIPAddresses *HubIPAddresses

	// IP configuration of the Azure Firewall resource.
	IPConfigurations []*AzureFirewallIPConfiguration

	// IP configuration of the Azure Firewall used for management traffic.
	ManagementIPConfiguration *AzureFirewallIPConfiguration

	// Collection of NAT rule collections used by Azure Firewall.
	NatRuleCollections []*AzureFirewallNatRuleCollection

	// Collection of network rule collections used by Azure Firewall.
	NetworkRuleCollections []*AzureFirewallNetworkRuleCollection

	// The Azure Firewall Resource SKU.
	SKU *AzureFirewallSKU

	// The operation mode for Threat Intelligence.
	ThreatIntelMode *AzureFirewallThreatIntelMode

	// The virtualHub to which the firewall belongs.
	VirtualHub *SubResource

	// READ-ONLY; IpGroups associated with AzureFirewall.
	IPGroups []*AzureFirewallIPGroups

	// READ-ONLY; The provisioning state of the Azure firewall resource.
	ProvisioningState *ProvisioningState
}

AzureFirewallPropertiesFormat - Properties of the Azure Firewall.

func (AzureFirewallPropertiesFormat) MarshalJSON 

func (a AzureFirewallPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallPropertiesFormat.

func (*AzureFirewallPropertiesFormat) UnmarshalJSON 

func (a *AzureFirewallPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallPropertiesFormat.

type AzureFirewallPublicIPAddress 

type AzureFirewallPublicIPAddress struct {
	// Public IP Address value.
	Address *string
}

AzureFirewallPublicIPAddress - Public IP Address associated with azure firewall.

func (AzureFirewallPublicIPAddress) MarshalJSON 

func (a AzureFirewallPublicIPAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallPublicIPAddress.

func (*AzureFirewallPublicIPAddress) UnmarshalJSON 

func (a *AzureFirewallPublicIPAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallPublicIPAddress.

type AzureFirewallRCAction 

type AzureFirewallRCAction struct {
	// The type of action.
	Type *AzureFirewallRCActionType
}

AzureFirewallRCAction - Properties of the AzureFirewallRCAction.

func (AzureFirewallRCAction) MarshalJSON 

func (a AzureFirewallRCAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallRCAction.

func (*AzureFirewallRCAction) UnmarshalJSON 

func (a *AzureFirewallRCAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallRCAction.

type AzureFirewallRCActionType 

type AzureFirewallRCActionType string

AzureFirewallRCActionType - The action type of a rule collection. 

const (
	AzureFirewallRCActionTypeAllow AzureFirewallRCActionType = "Allow"
	AzureFirewallRCActionTypeDeny  AzureFirewallRCActionType = "Deny"
)

func PossibleAzureFirewallRCActionTypeValues 

func PossibleAzureFirewallRCActionTypeValues() []AzureFirewallRCActionType

PossibleAzureFirewallRCActionTypeValues returns the possible values for the AzureFirewallRCActionType const type.

type AzureFirewallSKU 

type AzureFirewallSKU struct {
	// Name of an Azure Firewall SKU.
	Name *AzureFirewallSKUName

	// Tier of an Azure Firewall.
	Tier *AzureFirewallSKUTier
}

AzureFirewallSKU - SKU of an Azure Firewall.

func (AzureFirewallSKU) MarshalJSON 

func (a AzureFirewallSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureFirewallSKU.

func (*AzureFirewallSKU) UnmarshalJSON 

func (a *AzureFirewallSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureFirewallSKU.

type AzureFirewallSKUName 

type AzureFirewallSKUName string

AzureFirewallSKUName - Name of an Azure Firewall SKU. 

const (
	AzureFirewallSKUNameAZFWHub  AzureFirewallSKUName = "AZFW_Hub"
	AzureFirewallSKUNameAZFWVnet AzureFirewallSKUName = "AZFW_VNet"
)

func PossibleAzureFirewallSKUNameValues 

func PossibleAzureFirewallSKUNameValues() []AzureFirewallSKUName

PossibleAzureFirewallSKUNameValues returns the possible values for the AzureFirewallSKUName const type.

type AzureFirewallSKUTier 

type AzureFirewallSKUTier string

AzureFirewallSKUTier - Tier of an Azure Firewall. 

const (
	AzureFirewallSKUTierBasic    AzureFirewallSKUTier = "Basic"
	AzureFirewallSKUTierPremium  AzureFirewallSKUTier = "Premium"
	AzureFirewallSKUTierStandard AzureFirewallSKUTier = "Standard"
)

func PossibleAzureFirewallSKUTierValues 

func PossibleAzureFirewallSKUTierValues() []AzureFirewallSKUTier

PossibleAzureFirewallSKUTierValues returns the possible values for the AzureFirewallSKUTier const type.

type AzureFirewallThreatIntelMode 

type AzureFirewallThreatIntelMode string

AzureFirewallThreatIntelMode - The operation mode for Threat Intel. 

const (
	AzureFirewallThreatIntelModeAlert AzureFirewallThreatIntelMode = "Alert"
	AzureFirewallThreatIntelModeDeny  AzureFirewallThreatIntelMode = "Deny"
	AzureFirewallThreatIntelModeOff   AzureFirewallThreatIntelMode = "Off"
)

func PossibleAzureFirewallThreatIntelModeValues 

func PossibleAzureFirewallThreatIntelModeValues() []AzureFirewallThreatIntelMode

PossibleAzureFirewallThreatIntelModeValues returns the possible values for the AzureFirewallThreatIntelMode const type.

type AzureFirewallsClient 

type AzureFirewallsClient struct {
	// contains filtered or unexported fields
}

AzureFirewallsClient contains the methods for the AzureFirewalls group. Don't use this type directly, use NewAzureFirewallsClient() instead.

func NewAzureFirewallsClient 

func NewAzureFirewallsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AzureFirewallsClient, error)

NewAzureFirewallsClient creates a new instance of AzureFirewallsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AzureFirewallsClient) BeginCreateOrUpdate 

func (client *AzureFirewallsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters AzureFirewall, options *AzureFirewallsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AzureFirewallsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the specified Azure Firewall. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • azureFirewallName - The name of the Azure Firewall.
  • parameters - Parameters supplied to the create or update Azure Firewall operation.
  • options - AzureFirewallsClientBeginCreateOrUpdateOptions contains the optional parameters for the AzureFirewallsClient.BeginCreateOrUpdate method.
Example (CreateAzureFirewall)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginCreateOrUpdate(ctx, "rg1", "azurefirewall", armnetwork.AzureFirewall{
	Location: to.Ptr("West US"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armnetwork.AzureFirewallPropertiesFormat{
		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
				Name: to.Ptr("apprulecoll"),
				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](110),
					Rules: []*armnetwork.AzureFirewallApplicationRule{
						{
							Name:        to.Ptr("rule1"),
							Description: to.Ptr("Deny inbound rule"),
							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
								{
									Port:         to.Ptr[int32](443),
									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
								}},
							SourceAddresses: []*string{
								to.Ptr("216.58.216.164"),
								to.Ptr("10.0.0.0/24")},
							TargetFqdns: []*string{
								to.Ptr("www.test.com")},
						}},
				},
			}},
		IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
			{
				Name: to.Ptr("azureFirewallIpConfiguration"),
				Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
					},
				},
			}},
		NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
				Name: to.Ptr("natrulecoll"),
				Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
					Action: &armnetwork.AzureFirewallNatRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNatRule{
						{
							Name:        to.Ptr("DNAT-HTTPS-traffic"),
							Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedAddress: to.Ptr("1.2.3.5"),
							TranslatedPort:    to.Ptr("8443"),
						},
						{
							Name:        to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
							Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("80")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedFqdn: to.Ptr("internalhttpserver"),
							TranslatedPort: to.Ptr("880"),
						}},
				},
			}},
		NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
				Name: to.Ptr("netrulecoll"),
				Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNetworkRule{
						{
							Name:        to.Ptr("L4-traffic"),
							Description: to.Ptr("Block traffic based on source IPs and ports"),
							DestinationAddresses: []*string{
								to.Ptr("*")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("192.168.1.1-192.168.1.12"),
								to.Ptr("10.1.4.12-10.1.4.255")},
						},
						{
							Name:        to.Ptr("L4-traffic-with-FQDN"),
							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
							DestinationFqdns: []*string{
								to.Ptr("www.amazon.com")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("10.2.4.12-10.2.4.255")},
						}},
				},
			}},
		SKU: &armnetwork.AzureFirewallSKU{
			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
		},
		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	},
	Zones: []*string{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				IPGroups: []*armnetwork.AzureFirewallIPGroups{
// 				},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (CreateAzureFirewallInVirtualHub)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPutInHub.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginCreateOrUpdate(ctx, "rg1", "azurefirewall", armnetwork.AzureFirewall{
	Location: to.Ptr("West US"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armnetwork.AzureFirewallPropertiesFormat{
		FirewallPolicy: &armnetwork.SubResource{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/firewallPolicies/policy1"),
		},
		HubIPAddresses: &armnetwork.HubIPAddresses{
			PublicIPs: &armnetwork.HubPublicIPAddresses{
				Addresses: []*armnetwork.AzureFirewallPublicIPAddress{},
				Count:     to.Ptr[int32](1),
			},
		},
		SKU: &armnetwork.AzureFirewallSKU{
			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWHub),
			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
		},
		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
		VirtualHub: &armnetwork.SubResource{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualHubs/hub1"),
		},
	},
	Zones: []*string{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		FirewallPolicy: &armnetwork.SubResource{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/firewallPolicies/policy1"),
// 		},
// 		HubIPAddresses: &armnetwork.HubIPAddresses{
// 			PrivateIPAddress: to.Ptr("10.0.0.0"),
// 			PublicIPs: &armnetwork.HubPublicIPAddresses{
// 				Addresses: []*armnetwork.AzureFirewallPublicIPAddress{
// 					{
// 						Address: to.Ptr("13.73.240.12"),
// 				}},
// 				Count: to.Ptr[int32](1),
// 			},
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		SKU: &armnetwork.AzureFirewallSKU{
// 			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWHub),
// 			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 		},
// 		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 		VirtualHub: &armnetwork.SubResource{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualHubs/hub1"),
// 		},
// 	},
// 	Zones: []*string{
// 	},
// }
Example (CreateAzureFirewallWithAdditionalProperties)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPutWithAdditionalProperties.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginCreateOrUpdate(ctx, "rg1", "azurefirewall", armnetwork.AzureFirewall{
	Location: to.Ptr("West US"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armnetwork.AzureFirewallPropertiesFormat{
		AdditionalProperties: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
				Name: to.Ptr("apprulecoll"),
				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](110),
					Rules: []*armnetwork.AzureFirewallApplicationRule{
						{
							Name:        to.Ptr("rule1"),
							Description: to.Ptr("Deny inbound rule"),
							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
								{
									Port:         to.Ptr[int32](443),
									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
								}},
							SourceAddresses: []*string{
								to.Ptr("216.58.216.164"),
								to.Ptr("10.0.0.0/24")},
							TargetFqdns: []*string{
								to.Ptr("www.test.com")},
						}},
				},
			}},
		IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
			{
				Name: to.Ptr("azureFirewallIpConfiguration"),
				Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
					},
				},
			}},
		IPGroups: []*armnetwork.AzureFirewallIPGroups{},
		NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
				Name: to.Ptr("natrulecoll"),
				Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
					Action: &armnetwork.AzureFirewallNatRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNatRule{
						{
							Name:        to.Ptr("DNAT-HTTPS-traffic"),
							Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedAddress: to.Ptr("1.2.3.5"),
							TranslatedPort:    to.Ptr("8443"),
						},
						{
							Name:        to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
							Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("80")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedFqdn: to.Ptr("internalhttpserver"),
							TranslatedPort: to.Ptr("880"),
						}},
				},
			}},
		NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
				Name: to.Ptr("netrulecoll"),
				Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNetworkRule{
						{
							Name:        to.Ptr("L4-traffic"),
							Description: to.Ptr("Block traffic based on source IPs and ports"),
							DestinationAddresses: []*string{
								to.Ptr("*")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("192.168.1.1-192.168.1.12"),
								to.Ptr("10.1.4.12-10.1.4.255")},
						},
						{
							Name:        to.Ptr("L4-traffic-with-FQDN"),
							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
							DestinationFqdns: []*string{
								to.Ptr("www.amazon.com")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("10.2.4.12-10.2.4.255")},
						}},
				},
			}},
		SKU: &armnetwork.AzureFirewallSKU{
			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
		},
		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	},
	Zones: []*string{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 			"key1": to.Ptr("value1"),
// 			"key2": to.Ptr("value2"),
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (CreateAzureFirewallWithIpGroups)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPutWithIpGroups.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginCreateOrUpdate(ctx, "rg1", "azurefirewall", armnetwork.AzureFirewall{
	Location: to.Ptr("West US"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armnetwork.AzureFirewallPropertiesFormat{
		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
				Name: to.Ptr("apprulecoll"),
				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](110),
					Rules: []*armnetwork.AzureFirewallApplicationRule{
						{
							Name:        to.Ptr("rule1"),
							Description: to.Ptr("Deny inbound rule"),
							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
								{
									Port:         to.Ptr[int32](443),
									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
								}},
							SourceAddresses: []*string{
								to.Ptr("216.58.216.164"),
								to.Ptr("10.0.0.0/24")},
							TargetFqdns: []*string{
								to.Ptr("www.test.com")},
						}},
				},
			}},
		IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
			{
				Name: to.Ptr("azureFirewallIpConfiguration"),
				Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
					},
				},
			}},
		NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
				Name: to.Ptr("natrulecoll"),
				Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
					Action: &armnetwork.AzureFirewallNatRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNatRule{
						{
							Name:        to.Ptr("DNAT-HTTPS-traffic"),
							Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedAddress: to.Ptr("1.2.3.5"),
							TranslatedPort:    to.Ptr("8443"),
						},
						{
							Name:        to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
							Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("80")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedFqdn: to.Ptr("internalhttpserver"),
							TranslatedPort: to.Ptr("880"),
						}},
				},
			}},
		NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
				Name: to.Ptr("netrulecoll"),
				Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNetworkRule{
						{
							Name:        to.Ptr("L4-traffic"),
							Description: to.Ptr("Block traffic based on source IPs and ports"),
							DestinationAddresses: []*string{
								to.Ptr("*")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("192.168.1.1-192.168.1.12"),
								to.Ptr("10.1.4.12-10.1.4.255")},
						},
						{
							Name:        to.Ptr("L4-traffic-with-FQDN"),
							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
							DestinationFqdns: []*string{
								to.Ptr("www.amazon.com")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("10.2.4.12-10.2.4.255")},
						}},
				},
			}},
		SKU: &armnetwork.AzureFirewallSKU{
			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
		},
		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	},
	Zones: []*string{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (CreateAzureFirewallWithManagementSubnet)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPutWithMgmtSubnet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginCreateOrUpdate(ctx, "rg1", "azurefirewall", armnetwork.AzureFirewall{
	Location: to.Ptr("West US"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armnetwork.AzureFirewallPropertiesFormat{
		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
				Name: to.Ptr("apprulecoll"),
				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](110),
					Rules: []*armnetwork.AzureFirewallApplicationRule{
						{
							Name:        to.Ptr("rule1"),
							Description: to.Ptr("Deny inbound rule"),
							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
								{
									Port:         to.Ptr[int32](443),
									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
								}},
							SourceAddresses: []*string{
								to.Ptr("216.58.216.164"),
								to.Ptr("10.0.0.0/24")},
							TargetFqdns: []*string{
								to.Ptr("www.test.com")},
						}},
				},
			}},
		IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
			{
				Name: to.Ptr("azureFirewallIpConfiguration"),
				Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
					},
				},
			}},
		ManagementIPConfiguration: &armnetwork.AzureFirewallIPConfiguration{
			Name: to.Ptr("azureFirewallMgmtIpConfiguration"),
			Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
				PublicIPAddress: &armnetwork.SubResource{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/managementPipName"),
				},
				Subnet: &armnetwork.SubResource{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallManagementSubnet"),
				},
			},
		},
		NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
				Name: to.Ptr("natrulecoll"),
				Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
					Action: &armnetwork.AzureFirewallNatRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNatRule{
						{
							Name:        to.Ptr("DNAT-HTTPS-traffic"),
							Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedAddress: to.Ptr("1.2.3.5"),
							TranslatedPort:    to.Ptr("8443"),
						},
						{
							Name:        to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
							Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("80")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedFqdn: to.Ptr("internalhttpserver"),
							TranslatedPort: to.Ptr("880"),
						}},
				},
			}},
		NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
				Name: to.Ptr("netrulecoll"),
				Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNetworkRule{
						{
							Name:        to.Ptr("L4-traffic"),
							Description: to.Ptr("Block traffic based on source IPs and ports"),
							DestinationAddresses: []*string{
								to.Ptr("*")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("192.168.1.1-192.168.1.12"),
								to.Ptr("10.1.4.12-10.1.4.255")},
						},
						{
							Name:        to.Ptr("L4-traffic-with-FQDN"),
							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
							DestinationFqdns: []*string{
								to.Ptr("www.amazon.com")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("10.2.4.12-10.2.4.255")},
						}},
				},
			}},
		SKU: &armnetwork.AzureFirewallSKU{
			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
		},
		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	},
	Zones: []*string{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (CreateAzureFirewallWithZones)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPutWithZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginCreateOrUpdate(ctx, "rg1", "azurefirewall", armnetwork.AzureFirewall{
	Location: to.Ptr("West US 2"),
	Tags: map[string]*string{
		"key1": to.Ptr("value1"),
	},
	Properties: &armnetwork.AzureFirewallPropertiesFormat{
		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
				Name: to.Ptr("apprulecoll"),
				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](110),
					Rules: []*armnetwork.AzureFirewallApplicationRule{
						{
							Name:        to.Ptr("rule1"),
							Description: to.Ptr("Deny inbound rule"),
							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
								{
									Port:         to.Ptr[int32](443),
									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
								}},
							SourceAddresses: []*string{
								to.Ptr("216.58.216.164"),
								to.Ptr("10.0.0.0/24")},
							TargetFqdns: []*string{
								to.Ptr("www.test.com")},
						}},
				},
			}},
		IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
			{
				Name: to.Ptr("azureFirewallIpConfiguration"),
				Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
					},
				},
			}},
		NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
				Name: to.Ptr("natrulecoll"),
				Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
					Action: &armnetwork.AzureFirewallNatRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNatRule{
						{
							Name:        to.Ptr("DNAT-HTTPS-traffic"),
							Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedAddress: to.Ptr("1.2.3.5"),
							TranslatedPort:    to.Ptr("8443"),
						},
						{
							Name:        to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
							Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
							DestinationAddresses: []*string{
								to.Ptr("1.2.3.4")},
							DestinationPorts: []*string{
								to.Ptr("80")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("*")},
							TranslatedFqdn: to.Ptr("internalhttpserver"),
							TranslatedPort: to.Ptr("880"),
						}},
				},
			}},
		NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
			{
				ID:   to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
				Name: to.Ptr("netrulecoll"),
				Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
					Action: &armnetwork.AzureFirewallRCAction{
						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
					},
					Priority: to.Ptr[int32](112),
					Rules: []*armnetwork.AzureFirewallNetworkRule{
						{
							Name:        to.Ptr("L4-traffic"),
							Description: to.Ptr("Block traffic based on source IPs and ports"),
							DestinationAddresses: []*string{
								to.Ptr("*")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("192.168.1.1-192.168.1.12"),
								to.Ptr("10.1.4.12-10.1.4.255")},
						},
						{
							Name:        to.Ptr("L4-traffic-with-FQDN"),
							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
							DestinationFqdns: []*string{
								to.Ptr("www.amazon.com")},
							DestinationPorts: []*string{
								to.Ptr("443-444"),
								to.Ptr("8443")},
							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
							SourceAddresses: []*string{
								to.Ptr("10.2.4.12-10.2.4.255")},
						}},
				},
			}},
		SKU: &armnetwork.AzureFirewallSKU{
			Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
			Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
		},
		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	},
	Zones: []*string{
		to.Ptr("1"),
		to.Ptr("2"),
		to.Ptr("3")},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				IPGroups: []*armnetwork.AzureFirewallIPGroups{
// 				},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																				to.Ptr("1"),
// 																				to.Ptr("2"),
// 																				to.Ptr("3")},
// 																			}

func (*AzureFirewallsClient) BeginDelete 

func (client *AzureFirewallsClient) BeginDelete(ctx context.Context, resourceGroupName string, azureFirewallName string, options *AzureFirewallsClientBeginDeleteOptions) (*runtime.Poller[AzureFirewallsClientDeleteResponse], error)

BeginDelete - Deletes the specified Azure Firewall. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • azureFirewallName - The name of the Azure Firewall.
  • options - AzureFirewallsClientBeginDeleteOptions contains the optional parameters for the AzureFirewallsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginDelete(ctx, "rg1", "azurefirewall", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*AzureFirewallsClient) BeginListLearnedPrefixes 

func (client *AzureFirewallsClient) BeginListLearnedPrefixes(ctx context.Context, resourceGroupName string, azureFirewallName string, options *AzureFirewallsClientBeginListLearnedPrefixesOptions) (*runtime.Poller[AzureFirewallsClientListLearnedPrefixesResponse], error)

BeginListLearnedPrefixes - Retrieves a list of all IP prefixes that azure firewall has learned to not SNAT. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • azureFirewallName - The name of the azure firewall.
  • options - AzureFirewallsClientBeginListLearnedPrefixesOptions contains the optional parameters for the AzureFirewallsClient.BeginListLearnedPrefixes method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallListLearnedIPPrefixes.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginListLearnedPrefixes(ctx, "rg1", "azureFirewall1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.IPPrefixesList = armnetwork.IPPrefixesList{
// 	IPPrefixes: []*string{
// 		to.Ptr("10.101.0.0/16"),
// 		to.Ptr("10.102.0.0/16")},
// 	}

func (*AzureFirewallsClient) BeginPacketCapture 

func (client *AzureFirewallsClient) BeginPacketCapture(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters FirewallPacketCaptureParameters, options *AzureFirewallsClientBeginPacketCaptureOptions) (*runtime.Poller[AzureFirewallsClientPacketCaptureResponse], error)

BeginPacketCapture - Runs a packet capture on AzureFirewall. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • azureFirewallName - The name of the Azure Firewall.
  • parameters - Parameters supplied to run packet capture on azure firewall.
  • options - AzureFirewallsClientBeginPacketCaptureOptions contains the optional parameters for the AzureFirewallsClient.BeginPacketCapture method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallPacketCapture.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginPacketCapture(ctx, "rg1", "azureFirewall1", armnetwork.FirewallPacketCaptureParameters{
	DurationInSeconds: to.Ptr[int32](300),
	FileName:          to.Ptr("azureFirewallPacketCapture"),
	Filters: []*armnetwork.AzureFirewallPacketCaptureRule{
		{
			DestinationPorts: []*string{
				to.Ptr("4500")},
			Destinations: []*string{
				to.Ptr("20.1.2.0")},
			Sources: []*string{
				to.Ptr("20.1.1.0")},
		},
		{
			DestinationPorts: []*string{
				to.Ptr("123"),
				to.Ptr("80")},
			Destinations: []*string{
				to.Ptr("10.1.2.0")},
			Sources: []*string{
				to.Ptr("10.1.1.0"),
				to.Ptr("10.1.1.1")},
		}},
	Flags: []*armnetwork.AzureFirewallPacketCaptureFlags{
		{
			Type: to.Ptr(armnetwork.AzureFirewallPacketCaptureFlagsTypeSyn),
		},
		{
			Type: to.Ptr(armnetwork.AzureFirewallPacketCaptureFlagsTypeFin),
		}},
	NumberOfPacketsToCapture: to.Ptr[int32](5000),
	SasURL:                   to.Ptr("someSASURL"),
	Protocol:                 to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolAny),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*AzureFirewallsClient) BeginUpdateTags 

func (client *AzureFirewallsClient) BeginUpdateTags(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters TagsObject, options *AzureFirewallsClientBeginUpdateTagsOptions) (*runtime.Poller[AzureFirewallsClientUpdateTagsResponse], error)

BeginUpdateTags - Updates tags of an Azure Firewall resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • azureFirewallName - The name of the Azure Firewall.
  • parameters - Parameters supplied to update azure firewall tags.
  • options - AzureFirewallsClientBeginUpdateTagsOptions contains the optional parameters for the AzureFirewallsClient.BeginUpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAzureFirewallsClient().BeginUpdateTags(ctx, "azfwtest", "fw1", armnetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("fw1"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/azfwtest/providers/Microsoft.Network/azureFirewalls/fw1"),
// 	Location: to.Ptr("brazilsouth"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 	},
// }

func (*AzureFirewallsClient) Get 

func (client *AzureFirewallsClient) Get(ctx context.Context, resourceGroupName string, azureFirewallName string, options *AzureFirewallsClientGetOptions) (AzureFirewallsClientGetResponse, error)

Get - Gets the specified Azure Firewall. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • azureFirewallName - The name of the Azure Firewall.
  • options - AzureFirewallsClientGetOptions contains the optional parameters for the AzureFirewallsClient.Get method.
Example (GetAzureFirewall)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAzureFirewallsClient().Get(ctx, "rg1", "azurefirewall", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				AutoscaleConfiguration: &armnetwork.AzureFirewallAutoscaleConfiguration{
// 					MaxCapacity: to.Ptr[int32](15),
// 					MinCapacity: to.Ptr[int32](10),
// 				},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				IPGroups: []*armnetwork.AzureFirewallIPGroups{
// 				},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (GetAzureFirewallWithAdditionalProperties)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallGetWithAdditionalProperties.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAzureFirewallsClient().Get(ctx, "rg1", "azurefirewall", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 			"key1": to.Ptr("value1"),
// 			"key2": to.Ptr("value2"),
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (GetAzureFirewallWithIpGroups)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallGetWithIpGroups.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAzureFirewallsClient().Get(ctx, "rg1", "azurefirewall", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceIPGroups: []*string{
// 								to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups1")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				IPGroups: []*armnetwork.AzureFirewallIPGroups{
// 					{
// 						ChangeNumber: to.Ptr("5"),
// 						ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups1"),
// 					},
// 					{
// 						ChangeNumber: to.Ptr("4"),
// 						ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups2"),
// 					},
// 					{
// 						ChangeNumber: to.Ptr("1"),
// 						ID: to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups3"),
// 				}},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceIPGroups: []*string{
// 																	to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups1")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationIPGroups: []*string{
// 																		to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups2")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceIPGroups: []*string{
// 																									to.Ptr("/subscriptions/subId/providers/Microsoft.Network/resourceGroup/myResourceGroup/ipGroups/ipGroups3")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (GetAzureFirewallWithManagementSubnet)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallGetWithMgmtSubnet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAzureFirewallsClient().Get(ctx, "rg1", "azurefirewall", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				ManagementIPConfiguration: &armnetwork.AzureFirewallIPConfiguration{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallMgmtIpConfiguration"),
// 					Name: to.Ptr("azureFirewallMgmtIpConfiguration"),
// 					Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 					Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 						ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 						PublicIPAddress: &armnetwork.SubResource{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/managementPipName"),
// 						},
// 						Subnet: &armnetwork.SubResource{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallManagementSubnet"),
// 						},
// 					},
// 				},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																			},
// 																		}
Example (GetAzureFirewallWithZones)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallGetWithZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAzureFirewallsClient().Get(ctx, "rg1", "azurefirewall", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.AzureFirewall = armnetwork.AzureFirewall{
// 	Name: to.Ptr("azurefirewall"),
// 	Type: to.Ptr("Microsoft.Network/azureFirewalls"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.AzureFirewallPropertiesFormat{
// 		AdditionalProperties: map[string]*string{
// 		},
// 		ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
// 				Name: to.Ptr("apprulecoll"),
// 				Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
// 					Action: &armnetwork.AzureFirewallRCAction{
// 						Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 					},
// 					Priority: to.Ptr[int32](110),
// 					Rules: []*armnetwork.AzureFirewallApplicationRule{
// 						{
// 							Name: to.Ptr("rule1"),
// 							Description: to.Ptr("Deny inbound rule"),
// 							Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
// 								{
// 									Port: to.Ptr[int32](443),
// 									ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
// 							}},
// 							SourceAddresses: []*string{
// 								to.Ptr("216.58.216.164"),
// 								to.Ptr("10.0.0.0/24")},
// 								TargetFqdns: []*string{
// 									to.Ptr("www.test.com")},
// 							}},
// 						},
// 				}},
// 				IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
// 						Name: to.Ptr("azureFirewallIpConfiguration"),
// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 						Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
// 							PrivateIPAddress: to.Ptr("10.0.0.0"),
// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 							PublicIPAddress: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 							},
// 							Subnet: &armnetwork.SubResource{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
// 							},
// 						},
// 				}},
// 				IPGroups: []*armnetwork.AzureFirewallIPGroups{
// 				},
// 				NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
// 					{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
// 						Name: to.Ptr("natrulecoll"),
// 						Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
// 							Action: &armnetwork.AzureFirewallNatRCAction{
// 								Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
// 							},
// 							Priority: to.Ptr[int32](112),
// 							Rules: []*armnetwork.AzureFirewallNatRule{
// 								{
// 									Name: to.Ptr("DNAT-HTTPS-traffic"),
// 									Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
// 									DestinationAddresses: []*string{
// 										to.Ptr("1.2.3.4")},
// 										DestinationPorts: []*string{
// 											to.Ptr("443")},
// 											Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 												to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 												SourceAddresses: []*string{
// 													to.Ptr("*")},
// 													TranslatedAddress: to.Ptr("1.2.3.5"),
// 													TranslatedPort: to.Ptr("8443"),
// 												},
// 												{
// 													Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
// 													Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
// 													DestinationAddresses: []*string{
// 														to.Ptr("1.2.3.4")},
// 														DestinationPorts: []*string{
// 															to.Ptr("80")},
// 															Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																SourceAddresses: []*string{
// 																	to.Ptr("*")},
// 																	TranslatedFqdn: to.Ptr("internalhttpserver"),
// 																	TranslatedPort: to.Ptr("880"),
// 															}},
// 														},
// 												}},
// 												NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
// 													{
// 														ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
// 														Name: to.Ptr("netrulecoll"),
// 														Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
// 															Action: &armnetwork.AzureFirewallRCAction{
// 																Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
// 															},
// 															Priority: to.Ptr[int32](112),
// 															Rules: []*armnetwork.AzureFirewallNetworkRule{
// 																{
// 																	Name: to.Ptr("L4-traffic"),
// 																	Description: to.Ptr("Block traffic based on source IPs and ports"),
// 																	DestinationAddresses: []*string{
// 																		to.Ptr("*")},
// 																		DestinationPorts: []*string{
// 																			to.Ptr("443-444"),
// 																			to.Ptr("8443")},
// 																			Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																				to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																				SourceAddresses: []*string{
// 																					to.Ptr("192.168.1.1-192.168.1.12"),
// 																					to.Ptr("10.1.4.12-10.1.4.255")},
// 																				},
// 																				{
// 																					Name: to.Ptr("L4-traffic-with-FQDN"),
// 																					Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
// 																					DestinationFqdns: []*string{
// 																						to.Ptr("www.amazon.com")},
// 																						DestinationPorts: []*string{
// 																							to.Ptr("443-444"),
// 																							to.Ptr("8443")},
// 																							Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
// 																								to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
// 																								SourceAddresses: []*string{
// 																									to.Ptr("10.2.4.12-10.2.4.255")},
// 																							}},
// 																						},
// 																				}},
// 																				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 																				SKU: &armnetwork.AzureFirewallSKU{
// 																					Name: to.Ptr(armnetwork.AzureFirewallSKUNameAZFWVnet),
// 																					Tier: to.Ptr(armnetwork.AzureFirewallSKUTierStandard),
// 																				},
// 																				ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
// 																			},
// 																			Zones: []*string{
// 																				to.Ptr("1"),
// 																				to.Ptr("2"),
// 																				to.Ptr("3")},
// 																			}

func (*AzureFirewallsClient) NewListAllPager 

func (client *AzureFirewallsClient) NewListAllPager(options *AzureFirewallsClientListAllOptions) *runtime.Pager[AzureFirewallsClientListAllResponse]

NewListAllPager - Gets all the Azure Firewalls in a subscription.

Generated from API version 2024-03-01

  • options - AzureFirewallsClientListAllOptions contains the optional parameters for the AzureFirewallsClient.NewListAllPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAzureFirewallsClient().NewListAllPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AzureFirewallListResult = armnetwork.AzureFirewallListResult{
	// 	Value: []*armnetwork.AzureFirewall{
	// 		{
	// 			Name: to.Ptr("azurefirewall"),
	// 			Type: to.Ptr("Microsoft.Network/azureFirewalls"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
	// 			Location: to.Ptr("West US"),
	// 			Tags: map[string]*string{
	// 				"key1": to.Ptr("value1"),
	// 			},
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.AzureFirewallPropertiesFormat{
	// 				AdditionalProperties: map[string]*string{
	// 					"key1": to.Ptr("value1"),
	// 					"key2": to.Ptr("value2"),
	// 				},
	// 				ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
	// 						Name: to.Ptr("apprulecoll"),
	// 						Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
	// 							Action: &armnetwork.AzureFirewallRCAction{
	// 								Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
	// 							},
	// 							Priority: to.Ptr[int32](110),
	// 							Rules: []*armnetwork.AzureFirewallApplicationRule{
	// 								{
	// 									Name: to.Ptr("rule1"),
	// 									Description: to.Ptr("Deny inbound rule"),
	// 									Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
	// 										{
	// 											Port: to.Ptr[int32](443),
	// 											ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
	// 									}},
	// 									SourceAddresses: []*string{
	// 										to.Ptr("216.58.216.164"),
	// 										to.Ptr("10.0.0.0/24")},
	// 										TargetFqdns: []*string{
	// 											to.Ptr("www.test.com")},
	// 									}},
	// 								},
	// 						}},
	// 						IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
	// 							{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
	// 								Name: to.Ptr("azureFirewallIpConfiguration"),
	// 								Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 								Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
	// 									PrivateIPAddress: to.Ptr("10.0.0.0"),
	// 									ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 									PublicIPAddress: &armnetwork.SubResource{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
	// 									},
	// 									Subnet: &armnetwork.SubResource{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
	// 									},
	// 								},
	// 						}},
	// 						IPGroups: []*armnetwork.AzureFirewallIPGroups{
	// 						},
	// 						ManagementIPConfiguration: &armnetwork.AzureFirewallIPConfiguration{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallMgmtIpConfiguration"),
	// 							Name: to.Ptr("azureFirewallMgmtIpConfiguration"),
	// 							Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 							Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
	// 								ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 								PublicIPAddress: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/managementPipName"),
	// 								},
	// 								Subnet: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallManagementSubnet"),
	// 								},
	// 							},
	// 						},
	// 						NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
	// 							{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
	// 								Name: to.Ptr("natrulecoll"),
	// 								Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
	// 									Action: &armnetwork.AzureFirewallNatRCAction{
	// 										Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
	// 									},
	// 									Priority: to.Ptr[int32](112),
	// 									Rules: []*armnetwork.AzureFirewallNatRule{
	// 										{
	// 											Name: to.Ptr("DNAT-HTTPS-traffic"),
	// 											Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
	// 											DestinationAddresses: []*string{
	// 												to.Ptr("1.2.3.4")},
	// 												DestinationPorts: []*string{
	// 													to.Ptr("443")},
	// 													Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 														to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 														SourceAddresses: []*string{
	// 															to.Ptr("*")},
	// 															TranslatedAddress: to.Ptr("1.2.3.5"),
	// 															TranslatedPort: to.Ptr("8443"),
	// 														},
	// 														{
	// 															Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
	// 															Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
	// 															DestinationAddresses: []*string{
	// 																to.Ptr("1.2.3.4")},
	// 																DestinationPorts: []*string{
	// 																	to.Ptr("80")},
	// 																	Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 																		to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 																		SourceAddresses: []*string{
	// 																			to.Ptr("*")},
	// 																			TranslatedFqdn: to.Ptr("internalhttpserver"),
	// 																			TranslatedPort: to.Ptr("880"),
	// 																	}},
	// 																},
	// 														}},
	// 														NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
	// 															{
	// 																ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
	// 																Name: to.Ptr("netrulecoll"),
	// 																Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
	// 																	Action: &armnetwork.AzureFirewallRCAction{
	// 																		Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
	// 																	},
	// 																	Priority: to.Ptr[int32](112),
	// 																	Rules: []*armnetwork.AzureFirewallNetworkRule{
	// 																		{
	// 																			Name: to.Ptr("L4-traffic"),
	// 																			Description: to.Ptr("Block traffic based on source IPs and ports"),
	// 																			DestinationAddresses: []*string{
	// 																				to.Ptr("*")},
	// 																				DestinationPorts: []*string{
	// 																					to.Ptr("443-444"),
	// 																					to.Ptr("8443")},
	// 																					Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 																						to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 																						SourceAddresses: []*string{
	// 																							to.Ptr("192.168.1.1-192.168.1.12"),
	// 																							to.Ptr("10.1.4.12-10.1.4.255")},
	// 																						},
	// 																						{
	// 																							Name: to.Ptr("L4-traffic-with-FQDN"),
	// 																							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
	// 																							DestinationFqdns: []*string{
	// 																								to.Ptr("www.amazon.com")},
	// 																								DestinationPorts: []*string{
	// 																									to.Ptr("443-444"),
	// 																									to.Ptr("8443")},
	// 																									Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 																										to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 																										SourceAddresses: []*string{
	// 																											to.Ptr("10.2.4.12-10.2.4.255")},
	// 																									}},
	// 																								},
	// 																						}},
	// 																						ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 																						ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	// 																					},
	// 																					Zones: []*string{
	// 																					},
	// 																			}},
	// 																		}
}

func (*AzureFirewallsClient) NewListPager 

func (client *AzureFirewallsClient) NewListPager(resourceGroupName string, options *AzureFirewallsClientListOptions) *runtime.Pager[AzureFirewallsClientListResponse]

NewListPager - Lists all Azure Firewalls in a resource group.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • options - AzureFirewallsClientListOptions contains the optional parameters for the AzureFirewallsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/AzureFirewallListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAzureFirewallsClient().NewListPager("rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AzureFirewallListResult = armnetwork.AzureFirewallListResult{
	// 	Value: []*armnetwork.AzureFirewall{
	// 		{
	// 			Name: to.Ptr("azurefirewall"),
	// 			Type: to.Ptr("Microsoft.Network/azureFirewalls"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall"),
	// 			Location: to.Ptr("West US"),
	// 			Tags: map[string]*string{
	// 				"key1": to.Ptr("value1"),
	// 			},
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.AzureFirewallPropertiesFormat{
	// 				AdditionalProperties: map[string]*string{
	// 					"key1": to.Ptr("value1"),
	// 					"key2": to.Ptr("value2"),
	// 				},
	// 				ApplicationRuleCollections: []*armnetwork.AzureFirewallApplicationRuleCollection{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/applicationRuleCollections/apprulecoll"),
	// 						Name: to.Ptr("apprulecoll"),
	// 						Properties: &armnetwork.AzureFirewallApplicationRuleCollectionPropertiesFormat{
	// 							Action: &armnetwork.AzureFirewallRCAction{
	// 								Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
	// 							},
	// 							Priority: to.Ptr[int32](110),
	// 							Rules: []*armnetwork.AzureFirewallApplicationRule{
	// 								{
	// 									Name: to.Ptr("rule1"),
	// 									Description: to.Ptr("Deny inbound rule"),
	// 									Protocols: []*armnetwork.AzureFirewallApplicationRuleProtocol{
	// 										{
	// 											Port: to.Ptr[int32](443),
	// 											ProtocolType: to.Ptr(armnetwork.AzureFirewallApplicationRuleProtocolTypeHTTPS),
	// 									}},
	// 									SourceAddresses: []*string{
	// 										to.Ptr("216.58.216.164"),
	// 										to.Ptr("10.0.0.0/24")},
	// 										TargetFqdns: []*string{
	// 											to.Ptr("www.test.com")},
	// 									}},
	// 								},
	// 						}},
	// 						IPConfigurations: []*armnetwork.AzureFirewallIPConfiguration{
	// 							{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallIpConfiguration"),
	// 								Name: to.Ptr("azureFirewallIpConfiguration"),
	// 								Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 								Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
	// 									PrivateIPAddress: to.Ptr("10.0.0.0"),
	// 									ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 									PublicIPAddress: &armnetwork.SubResource{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
	// 									},
	// 									Subnet: &armnetwork.SubResource{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallSubnet"),
	// 									},
	// 								},
	// 						}},
	// 						IPGroups: []*armnetwork.AzureFirewallIPGroups{
	// 						},
	// 						ManagementIPConfiguration: &armnetwork.AzureFirewallIPConfiguration{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/ipConfigurations/azureFirewallMgmtIpConfiguration"),
	// 							Name: to.Ptr("azureFirewallMgmtIpConfiguration"),
	// 							Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 							Properties: &armnetwork.AzureFirewallIPConfigurationPropertiesFormat{
	// 								ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 								PublicIPAddress: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/managementPipName"),
	// 								},
	// 								Subnet: &armnetwork.SubResource{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureFirewallManagementSubnet"),
	// 								},
	// 							},
	// 						},
	// 						NatRuleCollections: []*armnetwork.AzureFirewallNatRuleCollection{
	// 							{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/natRuleCollections/natrulecoll"),
	// 								Name: to.Ptr("natrulecoll"),
	// 								Properties: &armnetwork.AzureFirewallNatRuleCollectionProperties{
	// 									Action: &armnetwork.AzureFirewallNatRCAction{
	// 										Type: to.Ptr(armnetwork.AzureFirewallNatRCActionTypeDnat),
	// 									},
	// 									Priority: to.Ptr[int32](112),
	// 									Rules: []*armnetwork.AzureFirewallNatRule{
	// 										{
	// 											Name: to.Ptr("DNAT-HTTPS-traffic"),
	// 											Description: to.Ptr("D-NAT all outbound web traffic for inspection"),
	// 											DestinationAddresses: []*string{
	// 												to.Ptr("1.2.3.4")},
	// 												DestinationPorts: []*string{
	// 													to.Ptr("443")},
	// 													Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 														to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 														SourceAddresses: []*string{
	// 															to.Ptr("*")},
	// 															TranslatedAddress: to.Ptr("1.2.3.5"),
	// 															TranslatedPort: to.Ptr("8443"),
	// 														},
	// 														{
	// 															Name: to.Ptr("DNAT-HTTP-traffic-With-FQDN"),
	// 															Description: to.Ptr("D-NAT all inbound web traffic for inspection"),
	// 															DestinationAddresses: []*string{
	// 																to.Ptr("1.2.3.4")},
	// 																DestinationPorts: []*string{
	// 																	to.Ptr("80")},
	// 																	Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 																		to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 																		SourceAddresses: []*string{
	// 																			to.Ptr("*")},
	// 																			TranslatedFqdn: to.Ptr("internalhttpserver"),
	// 																			TranslatedPort: to.Ptr("880"),
	// 																	}},
	// 																},
	// 														}},
	// 														NetworkRuleCollections: []*armnetwork.AzureFirewallNetworkRuleCollection{
	// 															{
	// 																ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/azureFirewalls/azurefirewall/networkRuleCollections/netrulecoll"),
	// 																Name: to.Ptr("netrulecoll"),
	// 																Properties: &armnetwork.AzureFirewallNetworkRuleCollectionPropertiesFormat{
	// 																	Action: &armnetwork.AzureFirewallRCAction{
	// 																		Type: to.Ptr(armnetwork.AzureFirewallRCActionTypeDeny),
	// 																	},
	// 																	Priority: to.Ptr[int32](112),
	// 																	Rules: []*armnetwork.AzureFirewallNetworkRule{
	// 																		{
	// 																			Name: to.Ptr("L4-traffic"),
	// 																			Description: to.Ptr("Block traffic based on source IPs and ports"),
	// 																			DestinationAddresses: []*string{
	// 																				to.Ptr("*")},
	// 																				DestinationPorts: []*string{
	// 																					to.Ptr("443-444"),
	// 																					to.Ptr("8443")},
	// 																					Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 																						to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 																						SourceAddresses: []*string{
	// 																							to.Ptr("192.168.1.1-192.168.1.12"),
	// 																							to.Ptr("10.1.4.12-10.1.4.255")},
	// 																						},
	// 																						{
	// 																							Name: to.Ptr("L4-traffic-with-FQDN"),
	// 																							Description: to.Ptr("Block traffic based on source IPs and ports to amazon"),
	// 																							DestinationFqdns: []*string{
	// 																								to.Ptr("www.amazon.com")},
	// 																								DestinationPorts: []*string{
	// 																									to.Ptr("443-444"),
	// 																									to.Ptr("8443")},
	// 																									Protocols: []*armnetwork.AzureFirewallNetworkRuleProtocol{
	// 																										to.Ptr(armnetwork.AzureFirewallNetworkRuleProtocolTCP)},
	// 																										SourceAddresses: []*string{
	// 																											to.Ptr("10.2.4.12-10.2.4.255")},
	// 																									}},
	// 																								},
	// 																						}},
	// 																						ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 																						ThreatIntelMode: to.Ptr(armnetwork.AzureFirewallThreatIntelModeAlert),
	// 																					},
	// 																					Zones: []*string{
	// 																					},
	// 																			}},
	// 																		}
}

type AzureFirewallsClientBeginCreateOrUpdateOptions 

type AzureFirewallsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AzureFirewallsClientBeginCreateOrUpdateOptions contains the optional parameters for the AzureFirewallsClient.BeginCreateOrUpdate method.

type AzureFirewallsClientBeginDeleteOptions 

type AzureFirewallsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AzureFirewallsClientBeginDeleteOptions contains the optional parameters for the AzureFirewallsClient.BeginDelete method.

type AzureFirewallsClientBeginListLearnedPrefixesOptions 

type AzureFirewallsClientBeginListLearnedPrefixesOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AzureFirewallsClientBeginListLearnedPrefixesOptions contains the optional parameters for the AzureFirewallsClient.BeginListLearnedPrefixes method.

type AzureFirewallsClientBeginPacketCaptureOptions 

type AzureFirewallsClientBeginPacketCaptureOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AzureFirewallsClientBeginPacketCaptureOptions contains the optional parameters for the AzureFirewallsClient.BeginPacketCapture method.

type AzureFirewallsClientBeginUpdateTagsOptions 

type AzureFirewallsClientBeginUpdateTagsOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AzureFirewallsClientBeginUpdateTagsOptions contains the optional parameters for the AzureFirewallsClient.BeginUpdateTags method.

type AzureFirewallsClientCreateOrUpdateResponse 

type AzureFirewallsClientCreateOrUpdateResponse struct {
	// Azure Firewall resource.
	AzureFirewall
}

AzureFirewallsClientCreateOrUpdateResponse contains the response from method AzureFirewallsClient.BeginCreateOrUpdate.

type AzureFirewallsClientDeleteResponse 

type AzureFirewallsClientDeleteResponse struct {
}

AzureFirewallsClientDeleteResponse contains the response from method AzureFirewallsClient.BeginDelete.

type AzureFirewallsClientGetOptions 

type AzureFirewallsClientGetOptions struct {
}

AzureFirewallsClientGetOptions contains the optional parameters for the AzureFirewallsClient.Get method.

type AzureFirewallsClientGetResponse 

type AzureFirewallsClientGetResponse struct {
	// Azure Firewall resource.
	AzureFirewall
}

AzureFirewallsClientGetResponse contains the response from method AzureFirewallsClient.Get.

type AzureFirewallsClientListAllOptions 

type AzureFirewallsClientListAllOptions struct {
}

AzureFirewallsClientListAllOptions contains the optional parameters for the AzureFirewallsClient.NewListAllPager method.

type AzureFirewallsClientListAllResponse 

type AzureFirewallsClientListAllResponse struct {
	// Response for ListAzureFirewalls API service call.
	AzureFirewallListResult
}

AzureFirewallsClientListAllResponse contains the response from method AzureFirewallsClient.NewListAllPager.

type AzureFirewallsClientListLearnedPrefixesResponse 

type AzureFirewallsClientListLearnedPrefixesResponse struct {
	// List of SNAT IP Prefixes learnt by firewall to not SNAT
	IPPrefixesList
}

AzureFirewallsClientListLearnedPrefixesResponse contains the response from method AzureFirewallsClient.BeginListLearnedPrefixes.

type AzureFirewallsClientListOptions 

type AzureFirewallsClientListOptions struct {
}

AzureFirewallsClientListOptions contains the optional parameters for the AzureFirewallsClient.NewListPager method.

type AzureFirewallsClientListResponse 

type AzureFirewallsClientListResponse struct {
	// Response for ListAzureFirewalls API service call.
	AzureFirewallListResult
}

AzureFirewallsClientListResponse contains the response from method AzureFirewallsClient.NewListPager.

type AzureFirewallsClientPacketCaptureResponse 

type AzureFirewallsClientPacketCaptureResponse struct {
}

AzureFirewallsClientPacketCaptureResponse contains the response from method AzureFirewallsClient.BeginPacketCapture.

type AzureFirewallsClientUpdateTagsResponse 

type AzureFirewallsClientUpdateTagsResponse struct {
	// Azure Firewall resource.
	AzureFirewall
}

AzureFirewallsClientUpdateTagsResponse contains the response from method AzureFirewallsClient.BeginUpdateTags.

type AzureReachabilityReport 

type AzureReachabilityReport struct {
	// REQUIRED; The aggregation level of Azure reachability report. Can be Country, State or City.
	AggregationLevel *string

	// REQUIRED; Parameters that define a geographic location.
	ProviderLocation *AzureReachabilityReportLocation

	// REQUIRED; List of Azure reachability report items.
	ReachabilityReport []*AzureReachabilityReportItem
}

AzureReachabilityReport - Azure reachability report details.

func (AzureReachabilityReport) MarshalJSON 

func (a AzureReachabilityReport) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureReachabilityReport.

func (*AzureReachabilityReport) UnmarshalJSON 

func (a *AzureReachabilityReport) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureReachabilityReport.

type AzureReachabilityReportItem 

type AzureReachabilityReportItem struct {
	// The Azure region.
	AzureLocation *string

	// List of latency details for each of the time series.
	Latencies []*AzureReachabilityReportLatencyInfo

	// The Internet service provider.
	Provider *string
}

AzureReachabilityReportItem - Azure reachability report details for a given provider location.

func (AzureReachabilityReportItem) MarshalJSON 

func (a AzureReachabilityReportItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureReachabilityReportItem.

func (*AzureReachabilityReportItem) UnmarshalJSON 

func (a *AzureReachabilityReportItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureReachabilityReportItem.

type AzureReachabilityReportLatencyInfo 

type AzureReachabilityReportLatencyInfo struct {
	// The relative latency score between 1 and 100, higher values indicating a faster connection.
	Score *int32

	// The time stamp.
	TimeStamp *time.Time
}

AzureReachabilityReportLatencyInfo - Details on latency for a time series.

func (AzureReachabilityReportLatencyInfo) MarshalJSON 

func (a AzureReachabilityReportLatencyInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureReachabilityReportLatencyInfo.

func (*AzureReachabilityReportLatencyInfo) UnmarshalJSON 

func (a *AzureReachabilityReportLatencyInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureReachabilityReportLatencyInfo.

type AzureReachabilityReportLocation 

type AzureReachabilityReportLocation struct {
	// REQUIRED; The name of the country.
	Country *string

	// The name of the city or town.
	City *string

	// The name of the state.
	State *string
}

AzureReachabilityReportLocation - Parameters that define a geographic location.

func (AzureReachabilityReportLocation) MarshalJSON 

func (a AzureReachabilityReportLocation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureReachabilityReportLocation.

func (*AzureReachabilityReportLocation) UnmarshalJSON 

func (a *AzureReachabilityReportLocation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureReachabilityReportLocation.

type AzureReachabilityReportParameters 

type AzureReachabilityReportParameters struct {
	// REQUIRED; The end time for the Azure reachability report.
	EndTime *time.Time

	// REQUIRED; Parameters that define a geographic location.
	ProviderLocation *AzureReachabilityReportLocation

	// REQUIRED; The start time for the Azure reachability report.
	StartTime *time.Time

	// Optional Azure regions to scope the query to.
	AzureLocations []*string

	// List of Internet service providers.
	Providers []*string
}

AzureReachabilityReportParameters - Geographic and time constraints for Azure reachability report.

func (AzureReachabilityReportParameters) MarshalJSON 

func (a AzureReachabilityReportParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureReachabilityReportParameters.

func (*AzureReachabilityReportParameters) UnmarshalJSON 

func (a *AzureReachabilityReportParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureReachabilityReportParameters.

type AzureWebCategory 

type AzureWebCategory struct {
	// Resource ID.
	ID *string

	// Properties of the Azure Web Category.
	Properties *AzureWebCategoryPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

AzureWebCategory - Azure Web Category Resource.

func (AzureWebCategory) MarshalJSON 

func (a AzureWebCategory) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureWebCategory.

func (*AzureWebCategory) UnmarshalJSON 

func (a *AzureWebCategory) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureWebCategory.

type AzureWebCategoryListResult 

type AzureWebCategoryListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of Azure Web Categories for a given Subscription.
	Value []*AzureWebCategory
}

AzureWebCategoryListResult - Response for ListAzureWebCategories API service call.

func (AzureWebCategoryListResult) MarshalJSON 

func (a AzureWebCategoryListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureWebCategoryListResult.

func (*AzureWebCategoryListResult) UnmarshalJSON 

func (a *AzureWebCategoryListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureWebCategoryListResult.

type AzureWebCategoryPropertiesFormat 

type AzureWebCategoryPropertiesFormat struct {
	// READ-ONLY; The name of the group that the category belongs to.
	Group *string
}

AzureWebCategoryPropertiesFormat - Azure Web Category Properties.

func (AzureWebCategoryPropertiesFormat) MarshalJSON 

func (a AzureWebCategoryPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureWebCategoryPropertiesFormat.

func (*AzureWebCategoryPropertiesFormat) UnmarshalJSON 

func (a *AzureWebCategoryPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureWebCategoryPropertiesFormat.

type BGPCommunity 

type BGPCommunity struct {
	// The name of the bgp community. e.g. Skype.
	CommunityName *string

	// The prefixes that the bgp community contains.
	CommunityPrefixes []*string

	// The value of the bgp community. For more information: https://docs.microsoft.com/en-us/azure/expressroute/expressroute-routing.
	CommunityValue *string

	// Customer is authorized to use bgp community or not.
	IsAuthorizedToUse *bool

	// The service group of the bgp community contains.
	ServiceGroup *string

	// The region which the service support. e.g. For O365, region is Global.
	ServiceSupportedRegion *string
}

BGPCommunity - Contains bgp community information offered in Service Community resources.

func (BGPCommunity) MarshalJSON 

func (b BGPCommunity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BGPCommunity.

func (*BGPCommunity) UnmarshalJSON 

func (b *BGPCommunity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BGPCommunity.

type BackendAddressInboundNatRulePortMappings 

type BackendAddressInboundNatRulePortMappings struct {
	// Collection of inbound NAT rule port mappings.
	InboundNatRulePortMappings []*InboundNatRulePortMapping
}

BackendAddressInboundNatRulePortMappings - The response for a QueryInboundNatRulePortMapping API.

func (BackendAddressInboundNatRulePortMappings) MarshalJSON 

func (b BackendAddressInboundNatRulePortMappings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackendAddressInboundNatRulePortMappings.

func (*BackendAddressInboundNatRulePortMappings) UnmarshalJSON 

func (b *BackendAddressInboundNatRulePortMappings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BackendAddressInboundNatRulePortMappings.

type BackendAddressPool 

type BackendAddressPool struct {
	// Resource ID.
	ID *string

	// The name of the resource that is unique within the set of backend address pools used by the load balancer. This name can
	// be used to access the resource.
	Name *string

	// Properties of load balancer backend address pool.
	Properties *BackendAddressPoolPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Type of the resource.
	Type *string
}

BackendAddressPool - Pool of backend IP addresses.

func (BackendAddressPool) MarshalJSON 

func (b BackendAddressPool) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackendAddressPool.

func (*BackendAddressPool) UnmarshalJSON 

func (b *BackendAddressPool) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BackendAddressPool.

type BackendAddressPoolPropertiesFormat 

type BackendAddressPoolPropertiesFormat struct {
	// Amount of seconds Load Balancer waits for before sending RESET to client and backend address.
	DrainPeriodInSeconds *int32

	// An array of backend addresses.
	LoadBalancerBackendAddresses []*LoadBalancerBackendAddress

	// The location of the backend address pool.
	Location *string

	// Backend address synchronous mode for the backend pool
	SyncMode *SyncMode

	// An array of gateway load balancer tunnel interfaces.
	TunnelInterfaces []*GatewayLoadBalancerTunnelInterface

	// A reference to a virtual network.
	VirtualNetwork *SubResource

	// READ-ONLY; An array of references to IP addresses defined in network interfaces.
	BackendIPConfigurations []*InterfaceIPConfiguration

	// READ-ONLY; An array of references to inbound NAT rules that use this backend address pool.
	InboundNatRules []*SubResource

	// READ-ONLY; An array of references to load balancing rules that use this backend address pool.
	LoadBalancingRules []*SubResource

	// READ-ONLY; A reference to an outbound rule that uses this backend address pool.
	OutboundRule *SubResource

	// READ-ONLY; An array of references to outbound rules that use this backend address pool.
	OutboundRules []*SubResource

	// READ-ONLY; The provisioning state of the backend address pool resource.
	ProvisioningState *ProvisioningState
}

BackendAddressPoolPropertiesFormat - Properties of the backend address pool.

func (BackendAddressPoolPropertiesFormat) MarshalJSON 

func (b BackendAddressPoolPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackendAddressPoolPropertiesFormat.

func (*BackendAddressPoolPropertiesFormat) UnmarshalJSON 

func (b *BackendAddressPoolPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BackendAddressPoolPropertiesFormat.

type BaseAdminRule 

type BaseAdminRule struct {
	// REQUIRED; Whether the rule is custom or default.
	Kind *AdminRuleKind

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; The system metadata related to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type.
	Type *string
}

BaseAdminRule - Network base admin rule.

func (*BaseAdminRule) GetBaseAdminRule 

func (b *BaseAdminRule) GetBaseAdminRule() *BaseAdminRule

GetBaseAdminRule implements the BaseAdminRuleClassification interface for type BaseAdminRule.

func (BaseAdminRule) MarshalJSON 

func (b BaseAdminRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BaseAdminRule.

func (*BaseAdminRule) UnmarshalJSON 

func (b *BaseAdminRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BaseAdminRule.

type BaseAdminRuleClassification 

type BaseAdminRuleClassification interface {
	// GetBaseAdminRule returns the BaseAdminRule content of the underlying type.
	GetBaseAdminRule() *BaseAdminRule
}

BaseAdminRuleClassification provides polymorphic access to related types. Call the interface's GetBaseAdminRule() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AdminRule, *BaseAdminRule, *DefaultAdminRule

type BastionActiveSession 

type BastionActiveSession struct {
	// READ-ONLY; The protocol used to connect to the target.
	Protocol *BastionConnectProtocol

	// READ-ONLY; The type of the resource.
	ResourceType *string

	// READ-ONLY; Duration in mins the session has been active.
	SessionDurationInMins *float32

	// READ-ONLY; A unique id for the session.
	SessionID *string

	// READ-ONLY; The time when the session started.
	StartTime any

	// READ-ONLY; The host name of the target.
	TargetHostName *string

	// READ-ONLY; The IP Address of the target.
	TargetIPAddress *string

	// READ-ONLY; The resource group of the target.
	TargetResourceGroup *string

	// READ-ONLY; The resource id of the target.
	TargetResourceID *string

	// READ-ONLY; The subscription id for the target virtual machine.
	TargetSubscriptionID *string

	// READ-ONLY; The user name who is active on this session.
	UserName *string
}

BastionActiveSession - The session detail for a target.

func (BastionActiveSession) MarshalJSON 

func (b BastionActiveSession) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionActiveSession.

func (*BastionActiveSession) UnmarshalJSON 

func (b *BastionActiveSession) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionActiveSession.

type BastionActiveSessionListResult 

type BastionActiveSessionListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// List of active sessions on the bastion.
	Value []*BastionActiveSession
}

BastionActiveSessionListResult - Response for GetActiveSessions.

func (BastionActiveSessionListResult) MarshalJSON 

func (b BastionActiveSessionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionActiveSessionListResult.

func (*BastionActiveSessionListResult) UnmarshalJSON 

func (b *BastionActiveSessionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionActiveSessionListResult.

type BastionConnectProtocol 

type BastionConnectProtocol string

BastionConnectProtocol - The protocol used to connect to the target. 

const (
	BastionConnectProtocolRDP BastionConnectProtocol = "RDP"
	BastionConnectProtocolSSH BastionConnectProtocol = "SSH"
)

func PossibleBastionConnectProtocolValues 

func PossibleBastionConnectProtocolValues() []BastionConnectProtocol

PossibleBastionConnectProtocolValues returns the possible values for the BastionConnectProtocol const type.

type BastionHost 

type BastionHost struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Represents the bastion host resource.
	Properties *BastionHostPropertiesFormat

	// The sku of this Bastion Host.
	SKU *SKU

	// Resource tags.
	Tags map[string]*string

	// A list of availability zones denoting where the resource needs to come from.
	Zones []*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

BastionHost - Bastion Host resource.

func (BastionHost) MarshalJSON 

func (b BastionHost) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionHost.

func (*BastionHost) UnmarshalJSON 

func (b *BastionHost) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionHost.

type BastionHostIPConfiguration 

type BastionHostIPConfiguration struct {
	// Resource ID.
	ID *string

	// Name of the resource that is unique within a resource group. This name can be used to access the resource.
	Name *string

	// Represents the ip configuration associated with the resource.
	Properties *BastionHostIPConfigurationPropertiesFormat

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Ip configuration type.
	Type *string
}

BastionHostIPConfiguration - IP configuration of an Bastion Host.

func (BastionHostIPConfiguration) MarshalJSON 

func (b BastionHostIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionHostIPConfiguration.

func (*BastionHostIPConfiguration) UnmarshalJSON 

func (b *BastionHostIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionHostIPConfiguration.

type BastionHostIPConfigurationPropertiesFormat 

type BastionHostIPConfigurationPropertiesFormat struct {
	// REQUIRED; Reference of the PublicIP resource.
	PublicIPAddress *SubResource

	// REQUIRED; Reference of the subnet resource.
	Subnet *SubResource

	// Private IP allocation method.
	PrivateIPAllocationMethod *IPAllocationMethod

	// READ-ONLY; The provisioning state of the bastion host IP configuration resource.
	ProvisioningState *ProvisioningState
}

BastionHostIPConfigurationPropertiesFormat - Properties of IP configuration of an Bastion Host.

func (BastionHostIPConfigurationPropertiesFormat) MarshalJSON 

func (b BastionHostIPConfigurationPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionHostIPConfigurationPropertiesFormat.

func (*BastionHostIPConfigurationPropertiesFormat) UnmarshalJSON 

func (b *BastionHostIPConfigurationPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionHostIPConfigurationPropertiesFormat.

type BastionHostListResult 

type BastionHostListResult struct {
	// URL to get the next set of results.
	NextLink *string

	// List of Bastion Hosts in a resource group.
	Value []*BastionHost
}

BastionHostListResult - Response for ListBastionHosts API service call.

func (BastionHostListResult) MarshalJSON 

func (b BastionHostListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionHostListResult.

func (*BastionHostListResult) UnmarshalJSON 

func (b *BastionHostListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionHostListResult.

type BastionHostPropertiesFormat 

type BastionHostPropertiesFormat struct {
	// FQDN for the endpoint on which bastion host is accessible.
	DNSName *string

	// Enable/Disable Copy/Paste feature of the Bastion Host resource.
	DisableCopyPaste *bool

	// Enable/Disable File Copy feature of the Bastion Host resource.
	EnableFileCopy *bool

	// Enable/Disable IP Connect feature of the Bastion Host resource.
	EnableIPConnect *bool

	// Enable/Disable Kerberos feature of the Bastion Host resource.
	EnableKerberos *bool

	// Enable/Disable Session Recording feature of the Bastion Host resource.
	EnableSessionRecording *bool

	// Enable/Disable Shareable Link of the Bastion Host resource.
	EnableShareableLink *bool

	// Enable/Disable Tunneling feature of the Bastion Host resource.
	EnableTunneling *bool

	// IP configuration of the Bastion Host resource.
	IPConfigurations []*BastionHostIPConfiguration
	NetworkACLs      *BastionHostPropertiesFormatNetworkACLs

	// The scale units for the Bastion Host resource.
	ScaleUnits *int32

	// Reference to an existing virtual network required for Developer Bastion Host only.
	VirtualNetwork *SubResource

	// READ-ONLY; The provisioning state of the bastion host resource.
	ProvisioningState *ProvisioningState
}

BastionHostPropertiesFormat - Properties of the Bastion Host.

func (BastionHostPropertiesFormat) MarshalJSON 

func (b BastionHostPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionHostPropertiesFormat.

func (*BastionHostPropertiesFormat) UnmarshalJSON 

func (b *BastionHostPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionHostPropertiesFormat.

type BastionHostPropertiesFormatNetworkACLs 

type BastionHostPropertiesFormatNetworkACLs struct {
	// Sets the IP ACL rules for Developer Bastion Host.
	IPRules []*IPRule
}

func (BastionHostPropertiesFormatNetworkACLs) MarshalJSON 

func (b BastionHostPropertiesFormatNetworkACLs) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionHostPropertiesFormatNetworkACLs.

func (*BastionHostPropertiesFormatNetworkACLs) UnmarshalJSON 

func (b *BastionHostPropertiesFormatNetworkACLs) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionHostPropertiesFormatNetworkACLs.

type BastionHostSKUName 

type BastionHostSKUName string

BastionHostSKUName - The name of the sku of this Bastion Host. 

const (
	BastionHostSKUNameBasic     BastionHostSKUName = "Basic"
	BastionHostSKUNameDeveloper BastionHostSKUName = "Developer"
	BastionHostSKUNamePremium   BastionHostSKUName = "Premium"
	BastionHostSKUNameStandard  BastionHostSKUName = "Standard"
)

func PossibleBastionHostSKUNameValues 

func PossibleBastionHostSKUNameValues() []BastionHostSKUName

PossibleBastionHostSKUNameValues returns the possible values for the BastionHostSKUName const type.

type BastionHostsClient 

type BastionHostsClient struct {
	// contains filtered or unexported fields
}

BastionHostsClient contains the methods for the BastionHosts group. Don't use this type directly, use NewBastionHostsClient() instead.

func NewBastionHostsClient 

func NewBastionHostsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BastionHostsClient, error)

NewBastionHostsClient creates a new instance of BastionHostsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BastionHostsClient) BeginCreateOrUpdate 

func (client *BastionHostsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, bastionHostName string, parameters BastionHost, options *BastionHostsClientBeginCreateOrUpdateOptions) (*runtime.Poller[BastionHostsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the specified Bastion Host. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • bastionHostName - The name of the Bastion Host.
  • parameters - Parameters supplied to the create or update Bastion Host operation.
  • options - BastionHostsClientBeginCreateOrUpdateOptions contains the optional parameters for the BastionHostsClient.BeginCreateOrUpdate method.
Example (CreateBastionHost)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostPut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBastionHostsClient().BeginCreateOrUpdate(ctx, "rg1", "bastionhosttenant", armnetwork.BastionHost{
	Properties: &armnetwork.BastionHostPropertiesFormat{
		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
			{
				Name: to.Ptr("bastionHostIpConfiguration"),
				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
					},
				},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhost"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant'"),
// 	Location: to.Ptr("West US"),
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DisableCopyPaste: to.Ptr(false),
// 		DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
// 		EnableIPConnect: to.Ptr(false),
// 		EnableKerberos: to.Ptr(false),
// 		EnableSessionRecording: to.Ptr(false),
// 		EnableShareableLink: to.Ptr(false),
// 		EnableTunneling: to.Ptr(false),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
// 				Name: to.Ptr("bastionHostIpConfiguration"),
// 				Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
// 				Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 					},
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
// 					},
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ScaleUnits: to.Ptr[int32](2),
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
// 	},
// }
Example (CreateBastionHostWithZones)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostPutWithZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBastionHostsClient().BeginCreateOrUpdate(ctx, "rg1", "bastionhosttenant", armnetwork.BastionHost{
	Properties: &armnetwork.BastionHostPropertiesFormat{
		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
			{
				Name: to.Ptr("bastionHostIpConfiguration"),
				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
					PublicIPAddress: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
					},
					Subnet: &armnetwork.SubResource{
						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
					},
				},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhost"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant'"),
// 	Location: to.Ptr("West US"),
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DisableCopyPaste: to.Ptr(false),
// 		DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
// 		EnableIPConnect: to.Ptr(false),
// 		EnableKerberos: to.Ptr(false),
// 		EnableSessionRecording: to.Ptr(false),
// 		EnableShareableLink: to.Ptr(false),
// 		EnableTunneling: to.Ptr(false),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
// 				Name: to.Ptr("bastionHostIpConfiguration"),
// 				Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
// 				Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 					},
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
// 					},
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ScaleUnits: to.Ptr[int32](2),
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
// 	},
// }
Example (CreateDeveloperBastionHost)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostDeveloperPut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBastionHostsClient().BeginCreateOrUpdate(ctx, "rg2", "bastionhostdeveloper", armnetwork.BastionHost{
	Properties: &armnetwork.BastionHostPropertiesFormat{
		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{},
		NetworkACLs: &armnetwork.BastionHostPropertiesFormatNetworkACLs{
			IPRules: []*armnetwork.IPRule{
				{
					AddressPrefix: to.Ptr("1.1.1.1/16"),
				}},
		},
		VirtualNetwork: &armnetwork.SubResource{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/vnet2"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhostdeveloper"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/bastionHosts/bastionhostdeveloper'"),
// 	Location: to.Ptr("West US"),
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DNSName: to.Ptr("omnibrain.uswest.bastionglobal.azure.com"),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 		},
// 		NetworkACLs: &armnetwork.BastionHostPropertiesFormatNetworkACLs{
// 			IPRules: []*armnetwork.IPRule{
// 				{
// 					AddressPrefix: to.Ptr("1.1.1.1/16"),
// 			}},
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		VirtualNetwork: &armnetwork.SubResource{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/vnet2"),
// 		},
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameDeveloper),
// 	},
// }

func (*BastionHostsClient) BeginDelete 

func (client *BastionHostsClient) BeginDelete(ctx context.Context, resourceGroupName string, bastionHostName string, options *BastionHostsClientBeginDeleteOptions) (*runtime.Poller[BastionHostsClientDeleteResponse], error)

BeginDelete - Deletes the specified Bastion Host. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • bastionHostName - The name of the Bastion Host.
  • options - BastionHostsClientBeginDeleteOptions contains the optional parameters for the BastionHostsClient.BeginDelete method.
Example (DeleteBastionHost)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBastionHostsClient().BeginDelete(ctx, "rg1", "bastionhosttenant", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
Example (DeleteDeveloperBastionHost)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostDeveloperDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBastionHostsClient().BeginDelete(ctx, "rg2", "bastionhostdeveloper", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*BastionHostsClient) BeginUpdateTags 

func (client *BastionHostsClient) BeginUpdateTags(ctx context.Context, resourceGroupName string, bastionHostName string, parameters TagsObject, options *BastionHostsClientBeginUpdateTagsOptions) (*runtime.Poller[BastionHostsClientUpdateTagsResponse], error)

BeginUpdateTags - Updates Tags for BastionHost resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • bastionHostName - The name of the Bastion Host.
  • parameters - Parameters supplied to update BastionHost tags.
  • options - BastionHostsClientBeginUpdateTagsOptions contains the optional parameters for the BastionHostsClient.BeginUpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostPatch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBastionHostsClient().BeginUpdateTags(ctx, "rg1", "bastionhosttenant", armnetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhosttenant"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant'"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DisableCopyPaste: to.Ptr(false),
// 		DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
// 		EnableIPConnect: to.Ptr(false),
// 		EnableKerberos: to.Ptr(false),
// 		EnableSessionRecording: to.Ptr(false),
// 		EnableShareableLink: to.Ptr(false),
// 		EnableTunneling: to.Ptr(false),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
// 				Name: to.Ptr("bastionHostIpConfiguration"),
// 				Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
// 				Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 					},
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
// 					},
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ScaleUnits: to.Ptr[int32](2),
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
// 	},
// }

func (*BastionHostsClient) Get 

func (client *BastionHostsClient) Get(ctx context.Context, resourceGroupName string, bastionHostName string, options *BastionHostsClientGetOptions) (BastionHostsClientGetResponse, error)

Get - Gets the specified Bastion Host. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • bastionHostName - The name of the Bastion Host.
  • options - BastionHostsClientGetOptions contains the optional parameters for the BastionHostsClient.Get method.
Example (GetBastionHost)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewBastionHostsClient().Get(ctx, "rg1", "bastionhosttenant'", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhost'"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant'"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DisableCopyPaste: to.Ptr(false),
// 		DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
// 		EnableIPConnect: to.Ptr(false),
// 		EnableKerberos: to.Ptr(false),
// 		EnableSessionRecording: to.Ptr(false),
// 		EnableShareableLink: to.Ptr(false),
// 		EnableTunneling: to.Ptr(false),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
// 				Name: to.Ptr("bastionHostIpConfiguration"),
// 				Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
// 				Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 					},
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
// 					},
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ScaleUnits: to.Ptr[int32](2),
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
// 	},
// 	Zones: []*string{
// 	},
// }
Example (GetBastionHostWithZones)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostGetWithZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewBastionHostsClient().Get(ctx, "rg1", "bastionhosttenant'", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhost'"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant'"),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("value1"),
// 	},
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DisableCopyPaste: to.Ptr(false),
// 		DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
// 		EnableIPConnect: to.Ptr(false),
// 		EnableKerberos: to.Ptr(false),
// 		EnableSessionRecording: to.Ptr(false),
// 		EnableShareableLink: to.Ptr(false),
// 		EnableTunneling: to.Ptr(false),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
// 				Name: to.Ptr("bastionHostIpConfiguration"),
// 				Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
// 				Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 				Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
// 					PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 					PublicIPAddress: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
// 					},
// 					Subnet: &armnetwork.SubResource{
// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/BastionHostSubnet"),
// 					},
// 				},
// 		}},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		ScaleUnits: to.Ptr[int32](2),
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
// 	},
// 	Zones: []*string{
// 		to.Ptr("1"),
// 		to.Ptr("2")},
// 	}
Example (GetDeveloperBastionHost)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostDeveloperGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewBastionHostsClient().Get(ctx, "rg1", "bastionhostdeveloper'", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BastionHost = armnetwork.BastionHost{
// 	Name: to.Ptr("bastionhostdeveloper'"),
// 	Type: to.Ptr("Microsoft.Network/bastionHosts"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/bastionHosts/bastionhostdeveloper'"),
// 	Location: to.Ptr("West US"),
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.BastionHostPropertiesFormat{
// 		DNSName: to.Ptr("omnibrain.uswest.bastionglobal.azure.com"),
// 		IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
// 		},
// 		NetworkACLs: &armnetwork.BastionHostPropertiesFormatNetworkACLs{
// 			IPRules: []*armnetwork.IPRule{
// 				{
// 					AddressPrefix: to.Ptr("1.1.1.1/16"),
// 			}},
// 		},
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 		VirtualNetwork: &armnetwork.SubResource{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/vnet2"),
// 		},
// 	},
// 	SKU: &armnetwork.SKU{
// 		Name: to.Ptr(armnetwork.BastionHostSKUNameDeveloper),
// 	},
// }

func (*BastionHostsClient) NewListByResourceGroupPager 

func (client *BastionHostsClient) NewListByResourceGroupPager(resourceGroupName string, options *BastionHostsClientListByResourceGroupOptions) *runtime.Pager[BastionHostsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists all Bastion Hosts in a resource group.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group.
  • options - BastionHostsClientListByResourceGroupOptions contains the optional parameters for the BastionHostsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewBastionHostsClient().NewListByResourceGroupPager("rg1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.BastionHostListResult = armnetwork.BastionHostListResult{
	// 	Value: []*armnetwork.BastionHost{
	// 		{
	// 			Name: to.Ptr("bastionhosttenant"),
	// 			Type: to.Ptr("Microsoft.Network/bastionHosts"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant"),
	// 			Location: to.Ptr("West US"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.BastionHostPropertiesFormat{
	// 				DisableCopyPaste: to.Ptr(false),
	// 				DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
	// 				EnableIPConnect: to.Ptr(false),
	// 				EnableKerberos: to.Ptr(false),
	// 				EnableSessionRecording: to.Ptr(false),
	// 				EnableShareableLink: to.Ptr(false),
	// 				EnableTunneling: to.Ptr(false),
	// 				IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
	// 						Name: to.Ptr("bastionHostIpConfiguration"),
	// 						Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
	// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 						Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
	// 							PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicIPAddress: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
	// 							},
	// 							Subnet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet/subnets/AzureBastionSubnet"),
	// 							},
	// 						},
	// 				}},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ScaleUnits: to.Ptr[int32](2),
	// 			},
	// 			SKU: &armnetwork.SKU{
	// 				Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
	// 			},
	// 			Zones: []*string{
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bastionhost2"),
	// 			Type: to.Ptr("Microsoft.Network/bastionHosts"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhost2"),
	// 			Location: to.Ptr("West US"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.BastionHostPropertiesFormat{
	// 				DisableCopyPaste: to.Ptr(false),
	// 				DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
	// 				EnableIPConnect: to.Ptr(false),
	// 				EnableKerberos: to.Ptr(false),
	// 				EnableSessionRecording: to.Ptr(true),
	// 				EnableShareableLink: to.Ptr(false),
	// 				EnableTunneling: to.Ptr(false),
	// 				IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhost2/bastionHostIpConfigurations/IpConf"),
	// 						Name: to.Ptr("bastionHostIpConfiguration"),
	// 						Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
	// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 						Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
	// 							PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicIPAddress: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName2"),
	// 							},
	// 							Subnet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2/subnets/AzureBastionSubnet"),
	// 							},
	// 						},
	// 				}},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ScaleUnits: to.Ptr[int32](2),
	// 			},
	// 			SKU: &armnetwork.SKU{
	// 				Name: to.Ptr(armnetwork.BastionHostSKUNamePremium),
	// 			},
	// 			Zones: []*string{
	// 			},
	// 	}},
	// }
}

func (*BastionHostsClient) NewListPager 

func (client *BastionHostsClient) NewListPager(options *BastionHostsClientListOptions) *runtime.Pager[BastionHostsClientListResponse]

NewListPager - Lists all Bastion Hosts in a subscription.

Generated from API version 2024-03-01

  • options - BastionHostsClientListOptions contains the optional parameters for the BastionHostsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/BastionHostListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewBastionHostsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.BastionHostListResult = armnetwork.BastionHostListResult{
	// 	Value: []*armnetwork.BastionHost{
	// 		{
	// 			Name: to.Ptr("bastionhosttenant"),
	// 			Type: to.Ptr("Microsoft.Network/bastionHosts"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant"),
	// 			Location: to.Ptr("West US"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.BastionHostPropertiesFormat{
	// 				DisableCopyPaste: to.Ptr(false),
	// 				DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
	// 				EnableIPConnect: to.Ptr(false),
	// 				EnableKerberos: to.Ptr(false),
	// 				EnableSessionRecording: to.Ptr(false),
	// 				EnableShareableLink: to.Ptr(false),
	// 				EnableTunneling: to.Ptr(false),
	// 				IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhosttenant/bastionHostIpConfigurations/bastionHostIpConfiguration"),
	// 						Name: to.Ptr("bastionHostIpConfiguration"),
	// 						Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
	// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 						Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
	// 							PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicIPAddress: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName"),
	// 							},
	// 							Subnet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet/subnets/AzureBastionSubnet"),
	// 							},
	// 						},
	// 				}},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ScaleUnits: to.Ptr[int32](2),
	// 			},
	// 			SKU: &armnetwork.SKU{
	// 				Name: to.Ptr(armnetwork.BastionHostSKUNameStandard),
	// 			},
	// 			Zones: []*string{
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bastionhostdeveloper"),
	// 			Type: to.Ptr("Microsoft.Network/bastionHosts"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/bastionHosts/bastionhostdeveloper"),
	// 			Location: to.Ptr("West US"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.BastionHostPropertiesFormat{
	// 				DNSName: to.Ptr("omnibrain.uswest.bastionglobal.azure.com"),
	// 				IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
	// 				},
	// 				NetworkACLs: &armnetwork.BastionHostPropertiesFormatNetworkACLs{
	// 					IPRules: []*armnetwork.IPRule{
	// 						{
	// 							AddressPrefix: to.Ptr("1.1.1.1/16"),
	// 					}},
	// 				},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				VirtualNetwork: &armnetwork.SubResource{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/vnet2"),
	// 				},
	// 			},
	// 			SKU: &armnetwork.SKU{
	// 				Name: to.Ptr(armnetwork.BastionHostSKUNameDeveloper),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bastionhost3"),
	// 			Type: to.Ptr("Microsoft.Network/bastionHosts"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhost3"),
	// 			Location: to.Ptr("West US"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.BastionHostPropertiesFormat{
	// 				DisableCopyPaste: to.Ptr(false),
	// 				DNSName: to.Ptr("bst-9d89d361-100e-4c01-b92d-466548c476dc.bastion.azure.com"),
	// 				EnableIPConnect: to.Ptr(false),
	// 				EnableKerberos: to.Ptr(false),
	// 				EnableSessionRecording: to.Ptr(true),
	// 				EnableShareableLink: to.Ptr(false),
	// 				EnableTunneling: to.Ptr(false),
	// 				IPConfigurations: []*armnetwork.BastionHostIPConfiguration{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/bastionHosts/bastionhost3/bastionHostIpConfigurations/IpConf"),
	// 						Name: to.Ptr("bastionHostIpConfiguration"),
	// 						Type: to.Ptr("Microsoft.Network/bastionHosts/bastionHostIpConfigurations"),
	// 						Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 						Properties: &armnetwork.BastionHostIPConfigurationPropertiesFormat{
	// 							PrivateIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodDynamic),
	// 							ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 							PublicIPAddress: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/pipName3"),
	// 							},
	// 							Subnet: &armnetwork.SubResource{
	// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet3/subnets/AzureBastionSubnet"),
	// 							},
	// 						},
	// 				}},
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 				ScaleUnits: to.Ptr[int32](2),
	// 			},
	// 			SKU: &armnetwork.SKU{
	// 				Name: to.Ptr(armnetwork.BastionHostSKUNamePremium),
	// 			},
	// 			Zones: []*string{
	// 			},
	// 	}},
	// }
}

type BastionHostsClientBeginCreateOrUpdateOptions 

type BastionHostsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

BastionHostsClientBeginCreateOrUpdateOptions contains the optional parameters for the BastionHostsClient.BeginCreateOrUpdate method.

type BastionHostsClientBeginDeleteOptions 

type BastionHostsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

BastionHostsClientBeginDeleteOptions contains the optional parameters for the BastionHostsClient.BeginDelete method.

type BastionHostsClientBeginUpdateTagsOptions 

type BastionHostsClientBeginUpdateTagsOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

BastionHostsClientBeginUpdateTagsOptions contains the optional parameters for the BastionHostsClient.BeginUpdateTags method.

type BastionHostsClientCreateOrUpdateResponse 

type BastionHostsClientCreateOrUpdateResponse struct {
	// Bastion Host resource.
	BastionHost
}

BastionHostsClientCreateOrUpdateResponse contains the response from method BastionHostsClient.BeginCreateOrUpdate.

type BastionHostsClientDeleteResponse 

type BastionHostsClientDeleteResponse struct {
}

BastionHostsClientDeleteResponse contains the response from method BastionHostsClient.BeginDelete.

type BastionHostsClientGetOptions 

type BastionHostsClientGetOptions struct {
}

BastionHostsClientGetOptions contains the optional parameters for the BastionHostsClient.Get method.

type BastionHostsClientGetResponse 

type BastionHostsClientGetResponse struct {
	// Bastion Host resource.
	BastionHost
}

BastionHostsClientGetResponse contains the response from method BastionHostsClient.Get.

type BastionHostsClientListByResourceGroupOptions 

type BastionHostsClientListByResourceGroupOptions struct {
}

BastionHostsClientListByResourceGroupOptions contains the optional parameters for the BastionHostsClient.NewListByResourceGroupPager method.

type BastionHostsClientListByResourceGroupResponse 

type BastionHostsClientListByResourceGroupResponse struct {
	// Response for ListBastionHosts API service call.
	BastionHostListResult
}

BastionHostsClientListByResourceGroupResponse contains the response from method BastionHostsClient.NewListByResourceGroupPager.

type BastionHostsClientListOptions 

type BastionHostsClientListOptions struct {
}

BastionHostsClientListOptions contains the optional parameters for the BastionHostsClient.NewListPager method.

type BastionHostsClientListResponse 

type BastionHostsClientListResponse struct {
	// Response for ListBastionHosts API service call.
	BastionHostListResult
}

BastionHostsClientListResponse contains the response from method BastionHostsClient.NewListPager.

type BastionHostsClientUpdateTagsResponse 

type BastionHostsClientUpdateTagsResponse struct {
	// Bastion Host resource.
	BastionHost
}

BastionHostsClientUpdateTagsResponse contains the response from method BastionHostsClient.BeginUpdateTags.

type BastionSessionDeleteResult 

type BastionSessionDeleteResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// List of sessions with their corresponding state.
	Value []*BastionSessionState
}

BastionSessionDeleteResult - Response for DisconnectActiveSessions.

func (BastionSessionDeleteResult) MarshalJSON 

func (b BastionSessionDeleteResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionSessionDeleteResult.

func (*BastionSessionDeleteResult) UnmarshalJSON 

func (b *BastionSessionDeleteResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionSessionDeleteResult.

type BastionSessionState 

type BastionSessionState struct {
	// READ-ONLY; Used for extra information.
	Message *string

	// READ-ONLY; A unique id for the session.
	SessionID *string

	// READ-ONLY; The state of the session. Disconnected/Failed/NotFound.
	State *string
}

BastionSessionState - The session state detail for a target.

func (BastionSessionState) MarshalJSON 

func (b BastionSessionState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionSessionState.

func (*BastionSessionState) UnmarshalJSON 

func (b *BastionSessionState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionSessionState. 

type BastionShareableLink struct {
	// REQUIRED; Reference of the virtual machine resource.
	VM *VM

	// READ-ONLY; The unique Bastion Shareable Link to the virtual machine.
	Bsl *string

	// READ-ONLY; The time when the link was created.
	CreatedAt *string

	// READ-ONLY; Optional field indicating the warning or error message related to the vm in case of partial failure.
	Message *string
}

BastionShareableLink - Bastion Shareable Link.

func (BastionShareableLink) MarshalJSON 

func (b BastionShareableLink) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionShareableLink.

func (*BastionShareableLink) UnmarshalJSON 

func (b *BastionShareableLink) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionShareableLink.

type BastionShareableLinkListRequest 

type BastionShareableLinkListRequest struct {
	// List of VM references.
	VMs []*BastionShareableLink
}

BastionShareableLinkListRequest - Post request for Create/Delete/Get Bastion Shareable Link endpoints.

func (BastionShareableLinkListRequest) MarshalJSON 

func (b BastionShareableLinkListRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionShareableLinkListRequest.

func (*BastionShareableLinkListRequest) UnmarshalJSON 

func (b *BastionShareableLinkListRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionShareableLinkListRequest.

type BastionShareableLinkListResult 

type BastionShareableLinkListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// List of Bastion Shareable Links for the request.
	Value []*BastionShareableLink
}

BastionShareableLinkListResult - Response for all the Bastion Shareable Link endpoints.

func (BastionShareableLinkListResult) MarshalJSON 

func (b BastionShareableLinkListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionShareableLinkListResult.

func (*BastionShareableLinkListResult) UnmarshalJSON 

func (b *BastionShareableLinkListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionShareableLinkListResult.

type BastionShareableLinkTokenListRequest 

type BastionShareableLinkTokenListRequest struct {
	// List of Bastion Shareable Link Token.
	Tokens []*string
}

BastionShareableLinkTokenListRequest - Post request for Delete Bastion Shareable Link By Token endpoint.

func (BastionShareableLinkTokenListRequest) MarshalJSON 

func (b BastionShareableLinkTokenListRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BastionShareableLinkTokenListRequest.

func (*BastionShareableLinkTokenListRequest) UnmarshalJSON 

func (b *BastionShareableLinkTokenListRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BastionShareableLinkTokenListRequest.

type BgpConnection 

type BgpConnection struct {
	// Resource ID.
	ID *string

	// Name of the connection.
	Name *string

	// The properties of the Bgp connections.
	Properties *BgpConnectionProperties

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Connection type.
	Type *string
}

BgpConnection - Virtual Appliance Site resource.

func (BgpConnection) MarshalJSON 

func (b BgpConnection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpConnection.

func (*BgpConnection) UnmarshalJSON 

func (b *BgpConnection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpConnection.

type BgpConnectionProperties 

type BgpConnectionProperties struct {
	// The reference to the HubVirtualNetworkConnection resource.
	HubVirtualNetworkConnection *SubResource

	// Peer ASN.
	PeerAsn *int64

	// Peer IP.
	PeerIP *string

	// READ-ONLY; The current state of the VirtualHub to Peer.
	ConnectionState *HubBgpConnectionStatus

	// READ-ONLY; The provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

BgpConnectionProperties - Properties of the bgp connection.

func (BgpConnectionProperties) MarshalJSON 

func (b BgpConnectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpConnectionProperties.

func (*BgpConnectionProperties) UnmarshalJSON 

func (b *BgpConnectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpConnectionProperties.

type BgpPeerState 

type BgpPeerState string

BgpPeerState - The BGP peer state. 

const (
	BgpPeerStateConnected  BgpPeerState = "Connected"
	BgpPeerStateConnecting BgpPeerState = "Connecting"
	BgpPeerStateIdle       BgpPeerState = "Idle"
	BgpPeerStateStopped    BgpPeerState = "Stopped"
	BgpPeerStateUnknown    BgpPeerState = "Unknown"
)

func PossibleBgpPeerStateValues 

func PossibleBgpPeerStateValues() []BgpPeerState

PossibleBgpPeerStateValues returns the possible values for the BgpPeerState const type.

type BgpPeerStatus 

type BgpPeerStatus struct {
	// READ-ONLY; The autonomous system number of the remote BGP peer.
	Asn *int64

	// READ-ONLY; For how long the peering has been up.
	ConnectedDuration *string

	// READ-ONLY; The virtual network gateway's local address.
	LocalAddress *string

	// READ-ONLY; The number of BGP messages received.
	MessagesReceived *int64

	// READ-ONLY; The number of BGP messages sent.
	MessagesSent *int64

	// READ-ONLY; The remote BGP peer.
	Neighbor *string

	// READ-ONLY; The number of routes learned from this peer.
	RoutesReceived *int64

	// READ-ONLY; The BGP peer state.
	State *BgpPeerState
}

BgpPeerStatus - BGP peer status details.

func (BgpPeerStatus) MarshalJSON 

func (b BgpPeerStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpPeerStatus.

func (*BgpPeerStatus) UnmarshalJSON 

func (b *BgpPeerStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpPeerStatus.

type BgpPeerStatusListResult 

type BgpPeerStatusListResult struct {
	// List of BGP peers.
	Value []*BgpPeerStatus
}

BgpPeerStatusListResult - Response for list BGP peer status API service call.

func (BgpPeerStatusListResult) MarshalJSON 

func (b BgpPeerStatusListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpPeerStatusListResult.

func (*BgpPeerStatusListResult) UnmarshalJSON 

func (b *BgpPeerStatusListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpPeerStatusListResult.

type BgpServiceCommunitiesClient 

type BgpServiceCommunitiesClient struct {
	// contains filtered or unexported fields
}

BgpServiceCommunitiesClient contains the methods for the BgpServiceCommunities group. Don't use this type directly, use NewBgpServiceCommunitiesClient() instead.

func NewBgpServiceCommunitiesClient 

func NewBgpServiceCommunitiesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BgpServiceCommunitiesClient, error)

NewBgpServiceCommunitiesClient creates a new instance of BgpServiceCommunitiesClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BgpServiceCommunitiesClient) NewListPager 

func (client *BgpServiceCommunitiesClient) NewListPager(options *BgpServiceCommunitiesClientListOptions) *runtime.Pager[BgpServiceCommunitiesClientListResponse]

NewListPager - Gets all the available bgp service communities.

Generated from API version 2024-03-01

  • options - BgpServiceCommunitiesClientListOptions contains the optional parameters for the BgpServiceCommunitiesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ServiceCommunityList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewBgpServiceCommunitiesClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.BgpServiceCommunityListResult = armnetwork.BgpServiceCommunityListResult{
	// 	Value: []*armnetwork.BgpServiceCommunity{
	// 		{
	// 			Name: to.Ptr("skype"),
	// 			Type: to.Ptr("Microsoft.Network/bgpServiceCommunities"),
	// 			ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/bgpServiceCommunities/skype"),
	// 			Properties: &armnetwork.BgpServiceCommunityPropertiesFormat{
	// 				BgpCommunities: []*armnetwork.BGPCommunity{
	// 					{
	// 						CommunityName: to.Ptr("Skype For Business Online"),
	// 						CommunityPrefixes: []*string{
	// 							to.Ptr("13.67.56.225/32"),
	// 							to.Ptr("13.67.186.105/32")},
	// 							CommunityValue: to.Ptr("12076:5030"),
	// 							IsAuthorizedToUse: to.Ptr(true),
	// 							ServiceGroup: to.Ptr("O365"),
	// 							ServiceSupportedRegion: to.Ptr("Global"),
	// 					}},
	// 					ServiceName: to.Ptr("skype"),
	// 				},
	// 			},
	// 			{
	// 				Name: to.Ptr("exchange"),
	// 				Type: to.Ptr("Microsoft.Network/bgpServiceCommunities"),
	// 				ID: to.Ptr("/subscriptions/subid/providers/Microsoft.Network/bgpServiceCommunities/exchange"),
	// 				Properties: &armnetwork.BgpServiceCommunityPropertiesFormat{
	// 					BgpCommunities: []*armnetwork.BGPCommunity{
	// 						{
	// 							CommunityName: to.Ptr("Exchange Online"),
	// 							CommunityPrefixes: []*string{
	// 								to.Ptr("13.67.56.225/32"),
	// 								to.Ptr("13.67.186.105/32")},
	// 								CommunityValue: to.Ptr("12076:5040"),
	// 								IsAuthorizedToUse: to.Ptr(true),
	// 								ServiceGroup: to.Ptr("O365"),
	// 								ServiceSupportedRegion: to.Ptr("Global"),
	// 						}},
	// 						ServiceName: to.Ptr("exchange"),
	// 					},
	// 			}},
	// 		}
}

type BgpServiceCommunitiesClientListOptions 

type BgpServiceCommunitiesClientListOptions struct {
}

BgpServiceCommunitiesClientListOptions contains the optional parameters for the BgpServiceCommunitiesClient.NewListPager method.

type BgpServiceCommunitiesClientListResponse 

type BgpServiceCommunitiesClientListResponse struct {
	// Response for the ListServiceCommunity API service call.
	BgpServiceCommunityListResult
}

BgpServiceCommunitiesClientListResponse contains the response from method BgpServiceCommunitiesClient.NewListPager.

type BgpServiceCommunity 

type BgpServiceCommunity struct {
	// Resource ID.
	ID *string

	// Resource location.
	Location *string

	// Properties of the BGP service community.
	Properties *BgpServiceCommunityPropertiesFormat

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

BgpServiceCommunity - Service Community Properties.

func (BgpServiceCommunity) MarshalJSON 

func (b BgpServiceCommunity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpServiceCommunity.

func (*BgpServiceCommunity) UnmarshalJSON 

func (b *BgpServiceCommunity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpServiceCommunity.

type BgpServiceCommunityListResult 

type BgpServiceCommunityListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// A list of service community resources.
	Value []*BgpServiceCommunity
}

BgpServiceCommunityListResult - Response for the ListServiceCommunity API service call.

func (BgpServiceCommunityListResult) MarshalJSON 

func (b BgpServiceCommunityListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpServiceCommunityListResult.

func (*BgpServiceCommunityListResult) UnmarshalJSON 

func (b *BgpServiceCommunityListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpServiceCommunityListResult.

type BgpServiceCommunityPropertiesFormat 

type BgpServiceCommunityPropertiesFormat struct {
	// A list of bgp communities.
	BgpCommunities []*BGPCommunity

	// The name of the bgp community. e.g. Skype.
	ServiceName *string
}

BgpServiceCommunityPropertiesFormat - Properties of Service Community.

func (BgpServiceCommunityPropertiesFormat) MarshalJSON 

func (b BgpServiceCommunityPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpServiceCommunityPropertiesFormat.

func (*BgpServiceCommunityPropertiesFormat) UnmarshalJSON 

func (b *BgpServiceCommunityPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpServiceCommunityPropertiesFormat.

type BgpSettings 

type BgpSettings struct {
	// The BGP speaker's ASN.
	Asn *int64

	// The BGP peering address and BGP identifier of this BGP speaker.
	BgpPeeringAddress *string

	// BGP peering address with IP configuration ID for virtual network gateway.
	BgpPeeringAddresses []*IPConfigurationBgpPeeringAddress

	// The weight added to routes learned from this BGP speaker.
	PeerWeight *int32
}

BgpSettings - BGP settings details.

func (BgpSettings) MarshalJSON 

func (b BgpSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpSettings.

func (*BgpSettings) UnmarshalJSON 

func (b *BgpSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpSettings.

type BreakOutCategoryPolicies 

type BreakOutCategoryPolicies struct {
	// Flag to control breakout of o365 allow category.
	Allow *bool

	// Flag to control breakout of o365 default category.
	Default *bool

	// Flag to control breakout of o365 optimize category.
	Optimize *bool
}

BreakOutCategoryPolicies - Network Virtual Appliance Sku Properties.

func (BreakOutCategoryPolicies) MarshalJSON 

func (b BreakOutCategoryPolicies) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BreakOutCategoryPolicies.

func (*BreakOutCategoryPolicies) UnmarshalJSON 

func (b *BreakOutCategoryPolicies) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BreakOutCategoryPolicies.

type CheckPrivateLinkServiceVisibilityRequest 

type CheckPrivateLinkServiceVisibilityRequest struct {
	// The alias of the private link service.
	PrivateLinkServiceAlias *string
}

CheckPrivateLinkServiceVisibilityRequest - Request body of the CheckPrivateLinkServiceVisibility API service call.

func (CheckPrivateLinkServiceVisibilityRequest) MarshalJSON 

func (c CheckPrivateLinkServiceVisibilityRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckPrivateLinkServiceVisibilityRequest.

func (*CheckPrivateLinkServiceVisibilityRequest) UnmarshalJSON 

func (c *CheckPrivateLinkServiceVisibilityRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckPrivateLinkServiceVisibilityRequest.

type ChildResource 

type ChildResource struct {
	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ChildResource - Proxy resource representation.

func (ChildResource) MarshalJSON 

func (c ChildResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ChildResource.

func (*ChildResource) UnmarshalJSON 

func (c *ChildResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ChildResource.

type CircuitConnectionStatus 

type CircuitConnectionStatus string

CircuitConnectionStatus - Express Route Circuit connection state. 

const (
	CircuitConnectionStatusConnected    CircuitConnectionStatus = "Connected"
	CircuitConnectionStatusConnecting   CircuitConnectionStatus = "Connecting"
	CircuitConnectionStatusDisconnected CircuitConnectionStatus = "Disconnected"
)

func PossibleCircuitConnectionStatusValues 

func PossibleCircuitConnectionStatusValues() []CircuitConnectionStatus

PossibleCircuitConnectionStatusValues returns the possible values for the CircuitConnectionStatus const type.

type ClientFactory 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAdminRuleCollectionsClient 

func (c *ClientFactory) NewAdminRuleCollectionsClient() *AdminRuleCollectionsClient

NewAdminRuleCollectionsClient creates a new instance of AdminRuleCollectionsClient.

func (*ClientFactory) NewAdminRulesClient 

func (c *ClientFactory) NewAdminRulesClient() *AdminRulesClient

NewAdminRulesClient creates a new instance of AdminRulesClient.

func (*ClientFactory) NewApplicationGatewayPrivateEndpointConnectionsClient 

func (c *ClientFactory) NewApplicationGatewayPrivateEndpointConnectionsClient() *ApplicationGatewayPrivateEndpointConnectionsClient

NewApplicationGatewayPrivateEndpointConnectionsClient creates a new instance of ApplicationGatewayPrivateEndpointConnectionsClient.

func (*ClientFactory) NewApplicationGatewayPrivateLinkResourcesClient 

func (c *ClientFactory) NewApplicationGatewayPrivateLinkResourcesClient() *ApplicationGatewayPrivateLinkResourcesClient

NewApplicationGatewayPrivateLinkResourcesClient creates a new instance of ApplicationGatewayPrivateLinkResourcesClient.

func (*ClientFactory) NewApplicationGatewayWafDynamicManifestsClient 

func (c *ClientFactory) NewApplicationGatewayWafDynamicManifestsClient() *ApplicationGatewayWafDynamicManifestsClient

NewApplicationGatewayWafDynamicManifestsClient creates a new instance of ApplicationGatewayWafDynamicManifestsClient.

func (*ClientFactory) NewApplicationGatewayWafDynamicManifestsDefaultClient 

func (c *ClientFactory) NewApplicationGatewayWafDynamicManifestsDefaultClient() *ApplicationGatewayWafDynamicManifestsDefaultClient

NewApplicationGatewayWafDynamicManifestsDefaultClient creates a new instance of ApplicationGatewayWafDynamicManifestsDefaultClient.

func (*ClientFactory) NewApplicationGatewaysClient 

func (c *ClientFactory) NewApplicationGatewaysClient() *ApplicationGatewaysClient

NewApplicationGatewaysClient creates a new instance of ApplicationGatewaysClient.

func (*ClientFactory) NewApplicationSecurityGroupsClient 

func (c *ClientFactory) NewApplicationSecurityGroupsClient() *ApplicationSecurityGroupsClient

NewApplicationSecurityGroupsClient creates a new instance of ApplicationSecurityGroupsClient.

func (*ClientFactory) NewAvailableDelegationsClient 

func (c *ClientFactory) NewAvailableDelegationsClient() *AvailableDelegationsClient

NewAvailableDelegationsClient creates a new instance of AvailableDelegationsClient.

func (*ClientFactory) NewAvailableEndpointServicesClient 

func (c *ClientFactory) NewAvailableEndpointServicesClient() *AvailableEndpointServicesClient

NewAvailableEndpointServicesClient creates a new instance of AvailableEndpointServicesClient.

func (*ClientFactory) NewAvailablePrivateEndpointTypesClient 

func (c *ClientFactory) NewAvailablePrivateEndpointTypesClient() *AvailablePrivateEndpointTypesClient

NewAvailablePrivateEndpointTypesClient creates a new instance of AvailablePrivateEndpointTypesClient.

func (*ClientFactory) NewAvailableResourceGroupDelegationsClient 

func (c *ClientFactory) NewAvailableResourceGroupDelegationsClient() *AvailableResourceGroupDelegationsClient

NewAvailableResourceGroupDelegationsClient creates a new instance of AvailableResourceGroupDelegationsClient.

func (*ClientFactory) NewAvailableServiceAliasesClient 

func (c *ClientFactory) NewAvailableServiceAliasesClient() *AvailableServiceAliasesClient

NewAvailableServiceAliasesClient creates a new instance of AvailableServiceAliasesClient.

func (*ClientFactory) NewAzureFirewallFqdnTagsClient 

func (c *ClientFactory) NewAzureFirewallFqdnTagsClient() *AzureFirewallFqdnTagsClient

NewAzureFirewallFqdnTagsClient creates a new instance of AzureFirewallFqdnTagsClient.

func (*ClientFactory) NewAzureFirewallsClient 

func (c *ClientFactory) NewAzureFirewallsClient() *AzureFirewallsClient

NewAzureFirewallsClient creates a new instance of AzureFirewallsClient.

func (*ClientFactory) NewBastionHostsClient 

func (c *ClientFactory) NewBastionHostsClient() *BastionHostsClient

NewBastionHostsClient creates a new instance of BastionHostsClient.

func (*ClientFactory) NewBgpServiceCommunitiesClient 

func (c *ClientFactory) NewBgpServiceCommunitiesClient() *BgpServiceCommunitiesClient

NewBgpServiceCommunitiesClient creates a new instance of BgpServiceCommunitiesClient.

func (*ClientFactory) NewConfigurationPolicyGroupsClient 

func (c *ClientFactory) NewConfigurationPolicyGroupsClient() *ConfigurationPolicyGroupsClient

NewConfigurationPolicyGroupsClient creates a new instance of ConfigurationPolicyGroupsClient.

func (*ClientFactory) NewConnectionMonitorsClient 

func (c *ClientFactory) NewConnectionMonitorsClient() *ConnectionMonitorsClient

NewConnectionMonitorsClient creates a new instance of ConnectionMonitorsClient.

func (*ClientFactory) NewConnectivityConfigurationsClient 

func (c *ClientFactory) NewConnectivityConfigurationsClient() *ConnectivityConfigurationsClient

NewConnectivityConfigurationsClient creates a new instance of ConnectivityConfigurationsClient.

func (*ClientFactory) NewCustomIPPrefixesClient 

func (c *ClientFactory) NewCustomIPPrefixesClient() *CustomIPPrefixesClient

NewCustomIPPrefixesClient creates a new instance of CustomIPPrefixesClient.

func (*ClientFactory) NewDdosCustomPoliciesClient 

func (c *ClientFactory) NewDdosCustomPoliciesClient() *DdosCustomPoliciesClient

NewDdosCustomPoliciesClient creates a new instance of DdosCustomPoliciesClient.

func (*ClientFactory) NewDdosProtectionPlansClient 

func (c *ClientFactory) NewDdosProtectionPlansClient() *DdosProtectionPlansClient

NewDdosProtectionPlansClient creates a new instance of DdosProtectionPlansClient.

func (*ClientFactory) NewDefaultSecurityRulesClient 

func (c *ClientFactory) NewDefaultSecurityRulesClient() *DefaultSecurityRulesClient

NewDefaultSecurityRulesClient creates a new instance of DefaultSecurityRulesClient.

func (*ClientFactory) NewDscpConfigurationClient 

func (c *ClientFactory) NewDscpConfigurationClient() *DscpConfigurationClient

NewDscpConfigurationClient creates a new instance of DscpConfigurationClient.

func (*ClientFactory) NewExpressRouteCircuitAuthorizationsClient 

func (c *ClientFactory) NewExpressRouteCircuitAuthorizationsClient() *ExpressRouteCircuitAuthorizationsClient

NewExpressRouteCircuitAuthorizationsClient creates a new instance of ExpressRouteCircuitAuthorizationsClient.

func (*ClientFactory) NewExpressRouteCircuitConnectionsClient 

func (c *ClientFactory) NewExpressRouteCircuitConnectionsClient() *ExpressRouteCircuitConnectionsClient

NewExpressRouteCircuitConnectionsClient creates a new instance of ExpressRouteCircuitConnectionsClient.

func (*ClientFactory) NewExpressRouteCircuitPeeringsClient 

func (c *ClientFactory) NewExpressRouteCircuitPeeringsClient() *ExpressRouteCircuitPeeringsClient

NewExpressRouteCircuitPeeringsClient creates a new instance of ExpressRouteCircuitPeeringsClient.

func (*ClientFactory) NewExpressRouteCircuitsClient 

func (c *ClientFactory) NewExpressRouteCircuitsClient() *ExpressRouteCircuitsClient

NewExpressRouteCircuitsClient creates a new instance of ExpressRouteCircuitsClient.

func (*ClientFactory) NewExpressRouteConnectionsClient 

func (c *ClientFactory) NewExpressRouteConnectionsClient() *ExpressRouteConnectionsClient

NewExpressRouteConnectionsClient creates a new instance of ExpressRouteConnectionsClient.

func (*ClientFactory) NewExpressRouteCrossConnectionPeeringsClient 

func (c *ClientFactory) NewExpressRouteCrossConnectionPeeringsClient() *ExpressRouteCrossConnectionPeeringsClient

NewExpressRouteCrossConnectionPeeringsClient creates a new instance of ExpressRouteCrossConnectionPeeringsClient.

func (*ClientFactory) NewExpressRouteCrossConnectionsClient 

func (c *ClientFactory) NewExpressRouteCrossConnectionsClient() *ExpressRouteCrossConnectionsClient

NewExpressRouteCrossConnectionsClient creates a new instance of ExpressRouteCrossConnectionsClient.

func (*ClientFactory) NewExpressRouteGatewaysClient 

func (c *ClientFactory) NewExpressRouteGatewaysClient() *ExpressRouteGatewaysClient

NewExpressRouteGatewaysClient creates a new instance of ExpressRouteGatewaysClient.

func (*ClientFactory) NewExpressRouteLinksClient 

func (c *ClientFactory) NewExpressRouteLinksClient() *ExpressRouteLinksClient

NewExpressRouteLinksClient creates a new instance of ExpressRouteLinksClient.

func (*ClientFactory) NewExpressRoutePortAuthorizationsClient 

func (c *ClientFactory) NewExpressRoutePortAuthorizationsClient() *ExpressRoutePortAuthorizationsClient

NewExpressRoutePortAuthorizationsClient creates a new instance of ExpressRoutePortAuthorizationsClient.

func (*ClientFactory) NewExpressRoutePortsClient 

func (c *ClientFactory) NewExpressRoutePortsClient() *ExpressRoutePortsClient

NewExpressRoutePortsClient creates a new instance of ExpressRoutePortsClient.

func (*ClientFactory) NewExpressRoutePortsLocationsClient 

func (c *ClientFactory) NewExpressRoutePortsLocationsClient() *ExpressRoutePortsLocationsClient

NewExpressRoutePortsLocationsClient creates a new instance of ExpressRoutePortsLocationsClient.

func (*ClientFactory) NewExpressRouteProviderPortsLocationClient 

func (c *ClientFactory) NewExpressRouteProviderPortsLocationClient() *ExpressRouteProviderPortsLocationClient

NewExpressRouteProviderPortsLocationClient creates a new instance of ExpressRouteProviderPortsLocationClient.

func (*ClientFactory) NewExpressRouteServiceProvidersClient 

func (c *ClientFactory) NewExpressRouteServiceProvidersClient() *ExpressRouteServiceProvidersClient

NewExpressRouteServiceProvidersClient creates a new instance of ExpressRouteServiceProvidersClient.

func (*ClientFactory) NewFirewallPoliciesClient 

func (c *ClientFactory) NewFirewallPoliciesClient() *FirewallPoliciesClient

NewFirewallPoliciesClient creates a new instance of FirewallPoliciesClient.

func (*ClientFactory) NewFirewallPolicyDeploymentsClient 

func (c *ClientFactory) NewFirewallPolicyDeploymentsClient() *FirewallPolicyDeploymentsClient

NewFirewallPolicyDeploymentsClient creates a new instance of FirewallPolicyDeploymentsClient.

func (*ClientFactory) NewFirewallPolicyDraftsClient 

func (c *ClientFactory) NewFirewallPolicyDraftsClient() *FirewallPolicyDraftsClient

NewFirewallPolicyDraftsClient creates a new instance of FirewallPolicyDraftsClient.

func (*ClientFactory) NewFirewallPolicyIdpsSignaturesClient 

func (c *ClientFactory) NewFirewallPolicyIdpsSignaturesClient() *FirewallPolicyIdpsSignaturesClient

NewFirewallPolicyIdpsSignaturesClient creates a new instance of FirewallPolicyIdpsSignaturesClient.

func (*ClientFactory) NewFirewallPolicyIdpsSignaturesFilterValuesClient 

func (c *ClientFactory) NewFirewallPolicyIdpsSignaturesFilterValuesClient() *FirewallPolicyIdpsSignaturesFilterValuesClient

NewFirewallPolicyIdpsSignaturesFilterValuesClient creates a new instance of FirewallPolicyIdpsSignaturesFilterValuesClient.

func (*ClientFactory) NewFirewallPolicyIdpsSignaturesOverridesClient 

func (c *ClientFactory) NewFirewallPolicyIdpsSignaturesOverridesClient() *FirewallPolicyIdpsSignaturesOverridesClient

NewFirewallPolicyIdpsSignaturesOverridesClient creates a new instance of FirewallPolicyIdpsSignaturesOverridesClient.

func (*ClientFactory) NewFirewallPolicyRuleCollectionGroupDraftsClient 

func (c *ClientFactory) NewFirewallPolicyRuleCollectionGroupDraftsClient() *FirewallPolicyRuleCollectionGroupDraftsClient

NewFirewallPolicyRuleCollectionGroupDraftsClient creates a new instance of FirewallPolicyRuleCollectionGroupDraftsClient.

func (*ClientFactory) NewFirewallPolicyRuleCollectionGroupsClient 

func (c *ClientFactory) NewFirewallPolicyRuleCollectionGroupsClient() *FirewallPolicyRuleCollectionGroupsClient

NewFirewallPolicyRuleCollectionGroupsClient creates a new instance of FirewallPolicyRuleCollectionGroupsClient.

func (*ClientFactory) NewFlowLogsClient 

func (c *ClientFactory) NewFlowLogsClient() *FlowLogsClient

NewFlowLogsClient creates a new instance of FlowLogsClient.

func (*ClientFactory) NewGroupsClient 

func (c *ClientFactory) NewGroupsClient() *GroupsClient

NewGroupsClient creates a new instance of GroupsClient.

func (*ClientFactory) NewHubRouteTablesClient 

func (c *ClientFactory) NewHubRouteTablesClient() *HubRouteTablesClient

NewHubRouteTablesClient creates a new instance of HubRouteTablesClient.

func (*ClientFactory) NewHubVirtualNetworkConnectionsClient 

func (c *ClientFactory) NewHubVirtualNetworkConnectionsClient() *HubVirtualNetworkConnectionsClient

NewHubVirtualNetworkConnectionsClient creates a new instance of HubVirtualNetworkConnectionsClient.

func (*ClientFactory) NewIPAllocationsClient 

func (c *ClientFactory) NewIPAllocationsClient() *IPAllocationsClient

NewIPAllocationsClient creates a new instance of IPAllocationsClient.

func (*ClientFactory) NewIPGroupsClient 

func (c *ClientFactory) NewIPGroupsClient() *IPGroupsClient

NewIPGroupsClient creates a new instance of IPGroupsClient.

func (*ClientFactory) NewInboundNatRulesClient 

func (c *ClientFactory) NewInboundNatRulesClient() *InboundNatRulesClient

NewInboundNatRulesClient creates a new instance of InboundNatRulesClient.

func (*ClientFactory) NewInboundSecurityRuleClient 

func (c *ClientFactory) NewInboundSecurityRuleClient() *InboundSecurityRuleClient

NewInboundSecurityRuleClient creates a new instance of InboundSecurityRuleClient.

func (*ClientFactory) NewInterfaceIPConfigurationsClient 

func (c *ClientFactory) NewInterfaceIPConfigurationsClient() *InterfaceIPConfigurationsClient

NewInterfaceIPConfigurationsClient creates a new instance of InterfaceIPConfigurationsClient.

func (*ClientFactory) NewInterfaceLoadBalancersClient 

func (c *ClientFactory) NewInterfaceLoadBalancersClient() *InterfaceLoadBalancersClient

NewInterfaceLoadBalancersClient creates a new instance of InterfaceLoadBalancersClient.

func (*ClientFactory) NewInterfaceTapConfigurationsClient 

func (c *ClientFactory) NewInterfaceTapConfigurationsClient() *InterfaceTapConfigurationsClient

NewInterfaceTapConfigurationsClient creates a new instance of InterfaceTapConfigurationsClient.

func (*ClientFactory) NewInterfacesClient 

func (c *ClientFactory) NewInterfacesClient() *InterfacesClient

NewInterfacesClient creates a new instance of InterfacesClient.

func (*ClientFactory) NewLoadBalancerBackendAddressPoolsClient 

func (c *ClientFactory) NewLoadBalancerBackendAddressPoolsClient() *LoadBalancerBackendAddressPoolsClient

NewLoadBalancerBackendAddressPoolsClient creates a new instance of LoadBalancerBackendAddressPoolsClient.

func (*ClientFactory) NewLoadBalancerFrontendIPConfigurationsClient 

func (c *ClientFactory) NewLoadBalancerFrontendIPConfigurationsClient() *LoadBalancerFrontendIPConfigurationsClient

NewLoadBalancerFrontendIPConfigurationsClient creates a new instance of LoadBalancerFrontendIPConfigurationsClient.

func (*ClientFactory) NewLoadBalancerLoadBalancingRulesClient 

func (c *ClientFactory) NewLoadBalancerLoadBalancingRulesClient() *LoadBalancerLoadBalancingRulesClient

NewLoadBalancerLoadBalancingRulesClient creates a new instance of LoadBalancerLoadBalancingRulesClient.

func (*ClientFactory) NewLoadBalancerNetworkInterfacesClient 

func (c *ClientFactory) NewLoadBalancerNetworkInterfacesClient() *LoadBalancerNetworkInterfacesClient

NewLoadBalancerNetworkInterfacesClient creates a new instance of LoadBalancerNetworkInterfacesClient.

func (*ClientFactory) NewLoadBalancerOutboundRulesClient 

func (c *ClientFactory) NewLoadBalancerOutboundRulesClient() *LoadBalancerOutboundRulesClient

NewLoadBalancerOutboundRulesClient creates a new instance of LoadBalancerOutboundRulesClient.

func (*ClientFactory) NewLoadBalancerProbesClient 

func (c *ClientFactory) NewLoadBalancerProbesClient() *LoadBalancerProbesClient

NewLoadBalancerProbesClient creates a new instance of LoadBalancerProbesClient.

func (*ClientFactory) NewLoadBalancersClient 

func (c *ClientFactory) NewLoadBalancersClient() *LoadBalancersClient

NewLoadBalancersClient creates a new instance of LoadBalancersClient.

func (*ClientFactory) NewLocalNetworkGatewaysClient 

func (c *ClientFactory) NewLocalNetworkGatewaysClient() *LocalNetworkGatewaysClient

NewLocalNetworkGatewaysClient creates a new instance of LocalNetworkGatewaysClient.

func (*ClientFactory) NewManagementClient 

func (c *ClientFactory) NewManagementClient() *ManagementClient

NewManagementClient creates a new instance of ManagementClient.

func (*ClientFactory) NewManagementGroupNetworkManagerConnectionsClient 

func (c *ClientFactory) NewManagementGroupNetworkManagerConnectionsClient() *ManagementGroupNetworkManagerConnectionsClient

NewManagementGroupNetworkManagerConnectionsClient creates a new instance of ManagementGroupNetworkManagerConnectionsClient.

func (*ClientFactory) NewManagerCommitsClient 

func (c *ClientFactory) NewManagerCommitsClient() *ManagerCommitsClient

NewManagerCommitsClient creates a new instance of ManagerCommitsClient.

func (*ClientFactory) NewManagerDeploymentStatusClient 

func (c *ClientFactory) NewManagerDeploymentStatusClient() *ManagerDeploymentStatusClient

NewManagerDeploymentStatusClient creates a new instance of ManagerDeploymentStatusClient.

func (*ClientFactory) NewManagerRoutingConfigurationsClient 

func (c *ClientFactory) NewManagerRoutingConfigurationsClient() *ManagerRoutingConfigurationsClient

NewManagerRoutingConfigurationsClient creates a new instance of ManagerRoutingConfigurationsClient.

func (*ClientFactory) NewManagersClient 

func (c *ClientFactory) NewManagersClient() *ManagersClient

NewManagersClient creates a new instance of ManagersClient.

func (*ClientFactory) NewNatGatewaysClient 

func (c *ClientFactory) NewNatGatewaysClient() *NatGatewaysClient

NewNatGatewaysClient creates a new instance of NatGatewaysClient.

func (*ClientFactory) NewNatRulesClient 

func (c *ClientFactory) NewNatRulesClient() *NatRulesClient

NewNatRulesClient creates a new instance of NatRulesClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewP2SVPNGatewaysClient 

func (c *ClientFactory) NewP2SVPNGatewaysClient() *P2SVPNGatewaysClient

NewP2SVPNGatewaysClient creates a new instance of P2SVPNGatewaysClient.

func (*ClientFactory) NewPacketCapturesClient 

func (c *ClientFactory) NewPacketCapturesClient() *PacketCapturesClient

NewPacketCapturesClient creates a new instance of PacketCapturesClient.

func (*ClientFactory) NewPeerExpressRouteCircuitConnectionsClient 

func (c *ClientFactory) NewPeerExpressRouteCircuitConnectionsClient() *PeerExpressRouteCircuitConnectionsClient

NewPeerExpressRouteCircuitConnectionsClient creates a new instance of PeerExpressRouteCircuitConnectionsClient.

func (*ClientFactory) NewPrivateDNSZoneGroupsClient 

func (c *ClientFactory) NewPrivateDNSZoneGroupsClient() *PrivateDNSZoneGroupsClient

NewPrivateDNSZoneGroupsClient creates a new instance of PrivateDNSZoneGroupsClient.

func (*ClientFactory) NewPrivateEndpointsClient 

func (c *ClientFactory) NewPrivateEndpointsClient() *PrivateEndpointsClient

NewPrivateEndpointsClient creates a new instance of PrivateEndpointsClient.

func (*ClientFactory) NewPrivateLinkServicesClient 

func (c *ClientFactory) NewPrivateLinkServicesClient() *PrivateLinkServicesClient

NewPrivateLinkServicesClient creates a new instance of PrivateLinkServicesClient.

func (*ClientFactory) NewProfilesClient 

func (c *ClientFactory) NewProfilesClient() *ProfilesClient

NewProfilesClient creates a new instance of ProfilesClient.

func (*ClientFactory) NewPublicIPAddressesClient 

func (c *ClientFactory) NewPublicIPAddressesClient() *PublicIPAddressesClient

NewPublicIPAddressesClient creates a new instance of PublicIPAddressesClient.

func (*ClientFactory) NewPublicIPPrefixesClient 

func (c *ClientFactory) NewPublicIPPrefixesClient() *PublicIPPrefixesClient

NewPublicIPPrefixesClient creates a new instance of PublicIPPrefixesClient.

func (*ClientFactory) NewResourceNavigationLinksClient 

func (c *ClientFactory) NewResourceNavigationLinksClient() *ResourceNavigationLinksClient

NewResourceNavigationLinksClient creates a new instance of ResourceNavigationLinksClient.

func (*ClientFactory) NewRouteFilterRulesClient 

func (c *ClientFactory) NewRouteFilterRulesClient() *RouteFilterRulesClient

NewRouteFilterRulesClient creates a new instance of RouteFilterRulesClient.

func (*ClientFactory) NewRouteFiltersClient 

func (c *ClientFactory) NewRouteFiltersClient() *RouteFiltersClient

NewRouteFiltersClient creates a new instance of RouteFiltersClient.

func (*ClientFactory) NewRouteMapsClient 

func (c *ClientFactory) NewRouteMapsClient() *RouteMapsClient

NewRouteMapsClient creates a new instance of RouteMapsClient.

func (*ClientFactory) NewRouteTablesClient 

func (c *ClientFactory) NewRouteTablesClient() *RouteTablesClient

NewRouteTablesClient creates a new instance of RouteTablesClient.

func (*ClientFactory) NewRoutesClient 

func (c *ClientFactory) NewRoutesClient() *RoutesClient

NewRoutesClient creates a new instance of RoutesClient.

func (*ClientFactory) NewRoutingIntentClient 

func (c *ClientFactory) NewRoutingIntentClient() *RoutingIntentClient

NewRoutingIntentClient creates a new instance of RoutingIntentClient.

func (*ClientFactory) NewRoutingRuleCollectionsClient 

func (c *ClientFactory) NewRoutingRuleCollectionsClient() *RoutingRuleCollectionsClient

NewRoutingRuleCollectionsClient creates a new instance of RoutingRuleCollectionsClient.

func (*ClientFactory) NewRoutingRulesClient 

func (c *ClientFactory) NewRoutingRulesClient() *RoutingRulesClient

NewRoutingRulesClient creates a new instance of RoutingRulesClient.

func (*ClientFactory) NewScopeConnectionsClient 

func (c *ClientFactory) NewScopeConnectionsClient() *ScopeConnectionsClient

NewScopeConnectionsClient creates a new instance of ScopeConnectionsClient.

func (*ClientFactory) NewSecurityAdminConfigurationsClient 

func (c *ClientFactory) NewSecurityAdminConfigurationsClient() *SecurityAdminConfigurationsClient

NewSecurityAdminConfigurationsClient creates a new instance of SecurityAdminConfigurationsClient.

func (*ClientFactory) NewSecurityGroupsClient 

func (c *ClientFactory) NewSecurityGroupsClient() *SecurityGroupsClient

NewSecurityGroupsClient creates a new instance of SecurityGroupsClient.

func (*ClientFactory) NewSecurityPartnerProvidersClient 

func (c *ClientFactory) NewSecurityPartnerProvidersClient() *SecurityPartnerProvidersClient

NewSecurityPartnerProvidersClient creates a new instance of SecurityPartnerProvidersClient.

func (*ClientFactory) NewSecurityRulesClient 

func (c *ClientFactory) NewSecurityRulesClient() *SecurityRulesClient

NewSecurityRulesClient creates a new instance of SecurityRulesClient.

func (*ClientFactory) NewSecurityUserConfigurationsClient 

func (c *ClientFactory) NewSecurityUserConfigurationsClient() *SecurityUserConfigurationsClient

NewSecurityUserConfigurationsClient creates a new instance of SecurityUserConfigurationsClient.

func (*ClientFactory) NewSecurityUserRuleCollectionsClient 

func (c *ClientFactory) NewSecurityUserRuleCollectionsClient() *SecurityUserRuleCollectionsClient

NewSecurityUserRuleCollectionsClient creates a new instance of SecurityUserRuleCollectionsClient.

func (*ClientFactory) NewSecurityUserRulesClient 

func (c *ClientFactory) NewSecurityUserRulesClient() *SecurityUserRulesClient

NewSecurityUserRulesClient creates a new instance of SecurityUserRulesClient.

func (*ClientFactory) NewServiceAssociationLinksClient 

func (c *ClientFactory) NewServiceAssociationLinksClient() *ServiceAssociationLinksClient

NewServiceAssociationLinksClient creates a new instance of ServiceAssociationLinksClient.

func (*ClientFactory) NewServiceEndpointPoliciesClient 

func (c *ClientFactory) NewServiceEndpointPoliciesClient() *ServiceEndpointPoliciesClient

NewServiceEndpointPoliciesClient creates a new instance of ServiceEndpointPoliciesClient.

func (*ClientFactory) NewServiceEndpointPolicyDefinitionsClient 

func (c *ClientFactory) NewServiceEndpointPolicyDefinitionsClient() *ServiceEndpointPolicyDefinitionsClient

NewServiceEndpointPolicyDefinitionsClient creates a new instance of ServiceEndpointPolicyDefinitionsClient.

func (*ClientFactory) NewServiceTagInformationClient 

func (c *ClientFactory) NewServiceTagInformationClient() *ServiceTagInformationClient

NewServiceTagInformationClient creates a new instance of ServiceTagInformationClient.

func (*ClientFactory) NewServiceTagsClient 

func (c *ClientFactory) NewServiceTagsClient() *ServiceTagsClient

NewServiceTagsClient creates a new instance of ServiceTagsClient.

func (*ClientFactory) NewStaticMembersClient 

func (c *ClientFactory) NewStaticMembersClient() *StaticMembersClient

NewStaticMembersClient creates a new instance of StaticMembersClient.

func (*ClientFactory) NewSubnetsClient 

func (c *ClientFactory) NewSubnetsClient() *SubnetsClient

NewSubnetsClient creates a new instance of SubnetsClient.

func (*ClientFactory) NewSubscriptionNetworkManagerConnectionsClient 

func (c *ClientFactory) NewSubscriptionNetworkManagerConnectionsClient() *SubscriptionNetworkManagerConnectionsClient

NewSubscriptionNetworkManagerConnectionsClient creates a new instance of SubscriptionNetworkManagerConnectionsClient.

func (*ClientFactory) NewUsagesClient 

func (c *ClientFactory) NewUsagesClient() *UsagesClient

NewUsagesClient creates a new instance of UsagesClient.

func (*ClientFactory) NewVPNConnectionsClient 

func (c *ClientFactory) NewVPNConnectionsClient() *VPNConnectionsClient

NewVPNConnectionsClient creates a new instance of VPNConnectionsClient.

func (*ClientFactory) NewVPNGatewaysClient 

func (c *ClientFactory) NewVPNGatewaysClient() *VPNGatewaysClient

NewVPNGatewaysClient creates a new instance of VPNGatewaysClient.

func (*ClientFactory) NewVPNLinkConnectionsClient 

func (c *ClientFactory) NewVPNLinkConnectionsClient() *VPNLinkConnectionsClient

NewVPNLinkConnectionsClient creates a new instance of VPNLinkConnectionsClient.

func (*ClientFactory) NewVPNServerConfigurationsAssociatedWithVirtualWanClient 

func (c *ClientFactory) NewVPNServerConfigurationsAssociatedWithVirtualWanClient() *VPNServerConfigurationsAssociatedWithVirtualWanClient

NewVPNServerConfigurationsAssociatedWithVirtualWanClient creates a new instance of VPNServerConfigurationsAssociatedWithVirtualWanClient.

func (*ClientFactory) NewVPNServerConfigurationsClient 

func (c *ClientFactory) NewVPNServerConfigurationsClient() *VPNServerConfigurationsClient

NewVPNServerConfigurationsClient creates a new instance of VPNServerConfigurationsClient.

func (*ClientFactory) NewVPNSiteLinkConnectionsClient 

func (c *ClientFactory) NewVPNSiteLinkConnectionsClient() *VPNSiteLinkConnectionsClient

NewVPNSiteLinkConnectionsClient creates a new instance of VPNSiteLinkConnectionsClient.

func (*ClientFactory) NewVPNSiteLinksClient 

func (c *ClientFactory) NewVPNSiteLinksClient() *VPNSiteLinksClient

NewVPNSiteLinksClient creates a new instance of VPNSiteLinksClient.

func (*ClientFactory) NewVPNSitesClient 

func (c *ClientFactory) NewVPNSitesClient() *VPNSitesClient

NewVPNSitesClient creates a new instance of VPNSitesClient.

func (*ClientFactory) NewVPNSitesConfigurationClient 

func (c *ClientFactory) NewVPNSitesConfigurationClient() *VPNSitesConfigurationClient

NewVPNSitesConfigurationClient creates a new instance of VPNSitesConfigurationClient.

func (*ClientFactory) NewVipSwapClient 

func (c *ClientFactory) NewVipSwapClient() *VipSwapClient

NewVipSwapClient creates a new instance of VipSwapClient.

func (*ClientFactory) NewVirtualApplianceConnectionsClient 

func (c *ClientFactory) NewVirtualApplianceConnectionsClient() *VirtualApplianceConnectionsClient

NewVirtualApplianceConnectionsClient creates a new instance of VirtualApplianceConnectionsClient.

func (*ClientFactory) NewVirtualApplianceSKUsClient 

func (c *ClientFactory) NewVirtualApplianceSKUsClient() *VirtualApplianceSKUsClient

NewVirtualApplianceSKUsClient creates a new instance of VirtualApplianceSKUsClient.

func (*ClientFactory) NewVirtualApplianceSitesClient 

func (c *ClientFactory) NewVirtualApplianceSitesClient() *VirtualApplianceSitesClient

NewVirtualApplianceSitesClient creates a new instance of VirtualApplianceSitesClient.

func (*ClientFactory) NewVirtualAppliancesClient 

func (c *ClientFactory) NewVirtualAppliancesClient() *VirtualAppliancesClient

NewVirtualAppliancesClient creates a new instance of VirtualAppliancesClient.

func (*ClientFactory) NewVirtualHubBgpConnectionClient 

func (c *ClientFactory) NewVirtualHubBgpConnectionClient() *VirtualHubBgpConnectionClient

NewVirtualHubBgpConnectionClient creates a new instance of VirtualHubBgpConnectionClient.

func (*ClientFactory) NewVirtualHubBgpConnectionsClient 

func (c *ClientFactory) NewVirtualHubBgpConnectionsClient() *VirtualHubBgpConnectionsClient

NewVirtualHubBgpConnectionsClient creates a new instance of VirtualHubBgpConnectionsClient.

func (*ClientFactory) NewVirtualHubIPConfigurationClient 

func (c *ClientFactory) NewVirtualHubIPConfigurationClient() *VirtualHubIPConfigurationClient

NewVirtualHubIPConfigurationClient creates a new instance of VirtualHubIPConfigurationClient.

func (*ClientFactory) NewVirtualHubRouteTableV2SClient 

func (c *ClientFactory) NewVirtualHubRouteTableV2SClient() *VirtualHubRouteTableV2SClient

NewVirtualHubRouteTableV2SClient creates a new instance of VirtualHubRouteTableV2SClient.

func (*ClientFactory) NewVirtualHubsClient 

func (c *ClientFactory) NewVirtualHubsClient() *VirtualHubsClient

NewVirtualHubsClient creates a new instance of VirtualHubsClient.

func (*ClientFactory) NewVirtualNetworkGatewayConnectionsClient 

func (c *ClientFactory) NewVirtualNetworkGatewayConnectionsClient() *VirtualNetworkGatewayConnectionsClient

NewVirtualNetworkGatewayConnectionsClient creates a new instance of VirtualNetworkGatewayConnectionsClient.

func (*ClientFactory) NewVirtualNetworkGatewayNatRulesClient 

func (c *ClientFactory) NewVirtualNetworkGatewayNatRulesClient() *VirtualNetworkGatewayNatRulesClient

NewVirtualNetworkGatewayNatRulesClient creates a new instance of VirtualNetworkGatewayNatRulesClient.

func (*ClientFactory) NewVirtualNetworkGatewaysClient 

func (c *ClientFactory) NewVirtualNetworkGatewaysClient() *VirtualNetworkGatewaysClient

NewVirtualNetworkGatewaysClient creates a new instance of VirtualNetworkGatewaysClient.

func (*ClientFactory) NewVirtualNetworkPeeringsClient 

func (c *ClientFactory) NewVirtualNetworkPeeringsClient() *VirtualNetworkPeeringsClient

NewVirtualNetworkPeeringsClient creates a new instance of VirtualNetworkPeeringsClient.

func (*ClientFactory) NewVirtualNetworkTapsClient 

func (c *ClientFactory) NewVirtualNetworkTapsClient() *VirtualNetworkTapsClient

NewVirtualNetworkTapsClient creates a new instance of VirtualNetworkTapsClient.

func (*ClientFactory) NewVirtualNetworksClient 

func (c *ClientFactory) NewVirtualNetworksClient() *VirtualNetworksClient

NewVirtualNetworksClient creates a new instance of VirtualNetworksClient.

func (*ClientFactory) NewVirtualRouterPeeringsClient 

func (c *ClientFactory) NewVirtualRouterPeeringsClient() *VirtualRouterPeeringsClient

NewVirtualRouterPeeringsClient creates a new instance of VirtualRouterPeeringsClient.

func (*ClientFactory) NewVirtualRoutersClient 

func (c *ClientFactory) NewVirtualRoutersClient() *VirtualRoutersClient

NewVirtualRoutersClient creates a new instance of VirtualRoutersClient.

func (*ClientFactory) NewVirtualWansClient 

func (c *ClientFactory) NewVirtualWansClient() *VirtualWansClient

NewVirtualWansClient creates a new instance of VirtualWansClient.

func (*ClientFactory) NewWatchersClient 

func (c *ClientFactory) NewWatchersClient() *WatchersClient

NewWatchersClient creates a new instance of WatchersClient.

func (*ClientFactory) NewWebApplicationFirewallPoliciesClient 

func (c *ClientFactory) NewWebApplicationFirewallPoliciesClient() *WebApplicationFirewallPoliciesClient

NewWebApplicationFirewallPoliciesClient creates a new instance of WebApplicationFirewallPoliciesClient.

func (*ClientFactory) NewWebCategoriesClient 

func (c *ClientFactory) NewWebCategoriesClient() *WebCategoriesClient

NewWebCategoriesClient creates a new instance of WebCategoriesClient.

type CommissionedState 

type CommissionedState string

CommissionedState - The commissioned state of the Custom IP Prefix. 

const (
	CommissionedStateCommissioned                    CommissionedState = "Commissioned"
	CommissionedStateCommissionedNoInternetAdvertise CommissionedState = "CommissionedNoInternetAdvertise"
	CommissionedStateCommissioning                   CommissionedState = "Commissioning"
	CommissionedStateDecommissioning                 CommissionedState = "Decommissioning"
	CommissionedStateDeprovisioned                   CommissionedState = "Deprovisioned"
	CommissionedStateDeprovisioning                  CommissionedState = "Deprovisioning"
	CommissionedStateProvisioned                     CommissionedState = "Provisioned"
	CommissionedStateProvisioning                    CommissionedState = "Provisioning"
)

func PossibleCommissionedStateValues 

func PossibleCommissionedStateValues() []CommissionedState

PossibleCommissionedStateValues returns the possible values for the CommissionedState const type.

type Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties 

type Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties struct {
	// READ-ONLY; The client id of user assigned identity.
	ClientID *string

	// READ-ONLY; The principal id of user assigned identity.
	PrincipalID *string
}

func (Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties) MarshalJSON 

func (c Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties.

func (*Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties) UnmarshalJSON 

func (c *Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties.

type ConfigurationDiagnosticParameters 

type ConfigurationDiagnosticParameters struct {
	// REQUIRED; List of network configuration diagnostic profiles.
	Profiles []*ConfigurationDiagnosticProfile

	// REQUIRED; The ID of the target resource to perform network configuration diagnostic. Valid options are VM, NetworkInterface,
	// VMSS/NetworkInterface and Application Gateway.
	TargetResourceID *string

	// Verbosity level.
	VerbosityLevel *VerbosityLevel
}

ConfigurationDiagnosticParameters - Parameters to get network configuration diagnostic.

func (ConfigurationDiagnosticParameters) MarshalJSON 

func (c ConfigurationDiagnosticParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationDiagnosticParameters.

func (*ConfigurationDiagnosticParameters) UnmarshalJSON 

func (c *ConfigurationDiagnosticParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationDiagnosticParameters.

type ConfigurationDiagnosticProfile 

type ConfigurationDiagnosticProfile struct {
	// REQUIRED; Traffic destination. Accepted values are: '*', IP Address/CIDR, Service Tag.
	Destination *string

	// REQUIRED; Traffic destination port. Accepted values are '*' and a single port in the range (0 - 65535).
	DestinationPort *string

	// REQUIRED; The direction of the traffic.
	Direction *Direction

	// REQUIRED; Protocol to be verified on. Accepted values are '*', TCP, UDP.
	Protocol *string

	// REQUIRED; Traffic source. Accepted values are '*', IP Address/CIDR, Service Tag.
	Source *string
}

ConfigurationDiagnosticProfile - Parameters to compare with network configuration.

func (ConfigurationDiagnosticProfile) MarshalJSON 

func (c ConfigurationDiagnosticProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationDiagnosticProfile.

func (*ConfigurationDiagnosticProfile) UnmarshalJSON 

func (c *ConfigurationDiagnosticProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationDiagnosticProfile.

type ConfigurationDiagnosticResponse 

type ConfigurationDiagnosticResponse struct {
	// READ-ONLY; List of network configuration diagnostic results.
	Results []*ConfigurationDiagnosticResult
}

ConfigurationDiagnosticResponse - Results of network configuration diagnostic on the target resource.

func (ConfigurationDiagnosticResponse) MarshalJSON 

func (c ConfigurationDiagnosticResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationDiagnosticResponse.

func (*ConfigurationDiagnosticResponse) UnmarshalJSON 

func (c *ConfigurationDiagnosticResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationDiagnosticResponse.

type ConfigurationDiagnosticResult 

type ConfigurationDiagnosticResult struct {
	// Network security group result.
	NetworkSecurityGroupResult *SecurityGroupResult

	// Network configuration diagnostic profile.
	Profile *ConfigurationDiagnosticProfile
}

ConfigurationDiagnosticResult - Network configuration diagnostic result corresponded to provided traffic query.

func (ConfigurationDiagnosticResult) MarshalJSON 

func (c ConfigurationDiagnosticResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationDiagnosticResult.

func (*ConfigurationDiagnosticResult) UnmarshalJSON 

func (c *ConfigurationDiagnosticResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationDiagnosticResult.

type ConfigurationGroup 

type ConfigurationGroup struct {
	// Network group ID.
	ID *string

	// The network configuration group properties
	Properties *GroupProperties
}

ConfigurationGroup - The network configuration group resource

func (ConfigurationGroup) MarshalJSON 

func (c ConfigurationGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationGroup.

func (*ConfigurationGroup) UnmarshalJSON 

func (c *ConfigurationGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationGroup.

type ConfigurationPolicyGroupsClient 

type ConfigurationPolicyGroupsClient struct {
	// contains filtered or unexported fields
}

ConfigurationPolicyGroupsClient contains the methods for the ConfigurationPolicyGroups group. Don't use this type directly, use NewConfigurationPolicyGroupsClient() instead.

func NewConfigurationPolicyGroupsClient 

func NewConfigurationPolicyGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ConfigurationPolicyGroupsClient, error)

NewConfigurationPolicyGroupsClient creates a new instance of ConfigurationPolicyGroupsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ConfigurationPolicyGroupsClient) BeginCreateOrUpdate 

func (client *ConfigurationPolicyGroupsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, vpnServerConfigurationName string, configurationPolicyGroupName string, vpnServerConfigurationPolicyGroupParameters VPNServerConfigurationPolicyGroup, options *ConfigurationPolicyGroupsClientBeginCreateOrUpdateOptions) (*runtime.Poller[ConfigurationPolicyGroupsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates a ConfigurationPolicyGroup if it doesn't exist else updates the existing one. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The resource group name of the ConfigurationPolicyGroup.
  • vpnServerConfigurationName - The name of the VpnServerConfiguration.
  • configurationPolicyGroupName - The name of the ConfigurationPolicyGroup.
  • vpnServerConfigurationPolicyGroupParameters - Parameters supplied to create or update a VpnServerConfiguration PolicyGroup.
  • options - ConfigurationPolicyGroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ConfigurationPolicyGroupPut.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConfigurationPolicyGroupsClient().BeginCreateOrUpdate(ctx, "rg1", "vpnServerConfiguration1", "policyGroup1", armnetwork.VPNServerConfigurationPolicyGroup{
	Properties: &armnetwork.VPNServerConfigurationPolicyGroupProperties{
		IsDefault: to.Ptr(true),
		PolicyMembers: []*armnetwork.VPNServerConfigurationPolicyGroupMember{
			{
				Name:           to.Ptr("policy1"),
				AttributeType:  to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeRadiusAzureGroupID),
				AttributeValue: to.Ptr("6ad1bd08"),
			},
			{
				Name:           to.Ptr("policy2"),
				AttributeType:  to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeCertificateGroupID),
				AttributeValue: to.Ptr("red.com"),
			}},
		Priority: to.Ptr[int32](0),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VPNServerConfigurationPolicyGroup = armnetwork.VPNServerConfigurationPolicyGroup{
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/vpnServerConfigurations/vpnServerConfiguration1/vpnServerConfigurationPolicyGroups/policyGroup1"),
// 	Name: to.Ptr("policyGroup1"),
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.VPNServerConfigurationPolicyGroupProperties{
// 		IsDefault: to.Ptr(true),
// 		P2SConnectionConfigurations: []*armnetwork.SubResource{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/p2sVpnGateways/p2sVpnGateway1/p2sConnectionConfigurations/P2SConnectionConfig1"),
// 		}},
// 		PolicyMembers: []*armnetwork.VPNServerConfigurationPolicyGroupMember{
// 			{
// 				Name: to.Ptr("policy1"),
// 				AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeRadiusAzureGroupID),
// 				AttributeValue: to.Ptr("6ad1bd08"),
// 			},
// 			{
// 				Name: to.Ptr("policy2"),
// 				AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeCertificateGroupID),
// 				AttributeValue: to.Ptr("red.com"),
// 		}},
// 		Priority: to.Ptr[int32](0),
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 	},
// }

func (*ConfigurationPolicyGroupsClient) BeginDelete 

func (client *ConfigurationPolicyGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, vpnServerConfigurationName string, configurationPolicyGroupName string, options *ConfigurationPolicyGroupsClientBeginDeleteOptions) (*runtime.Poller[ConfigurationPolicyGroupsClientDeleteResponse], error)

BeginDelete - Deletes a ConfigurationPolicyGroup. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The resource group name of the ConfigurationPolicyGroup.
  • vpnServerConfigurationName - The name of the VpnServerConfiguration.
  • configurationPolicyGroupName - The name of the ConfigurationPolicyGroup.
  • options - ConfigurationPolicyGroupsClientBeginDeleteOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ConfigurationPolicyGroupDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConfigurationPolicyGroupsClient().BeginDelete(ctx, "rg1", "vpnServerConfiguration1", "policyGroup1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ConfigurationPolicyGroupsClient) Get 

func (client *ConfigurationPolicyGroupsClient) Get(ctx context.Context, resourceGroupName string, vpnServerConfigurationName string, configurationPolicyGroupName string, options *ConfigurationPolicyGroupsClientGetOptions) (ConfigurationPolicyGroupsClientGetResponse, error)

Get - Retrieves the details of a ConfigurationPolicyGroup. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The resource group name of the VpnServerConfiguration.
  • vpnServerConfigurationName - The name of the VpnServerConfiguration.
  • configurationPolicyGroupName - The name of the ConfigurationPolicyGroup being retrieved.
  • options - ConfigurationPolicyGroupsClientGetOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ConfigurationPolicyGroupGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConfigurationPolicyGroupsClient().Get(ctx, "rg1", "vpnServerConfiguration1", "policyGroup1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VPNServerConfigurationPolicyGroup = armnetwork.VPNServerConfigurationPolicyGroup{
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/vpnServerConfigurations/vpnServerConfiguration1/vpnServerConfigurationPolicyGroups/policyGroup1"),
// 	Name: to.Ptr("policyGroup1"),
// 	Type: to.Ptr("Microsoft.Network/vpnServerConfigurations/configurationPolicyGroups"),
// 	Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
// 	Properties: &armnetwork.VPNServerConfigurationPolicyGroupProperties{
// 		IsDefault: to.Ptr(true),
// 		P2SConnectionConfigurations: []*armnetwork.SubResource{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/p2sVpnGateways/p2sVpnGateway1/p2sConnectionConfigurations/P2SConnectionConfig1"),
// 		}},
// 		PolicyMembers: []*armnetwork.VPNServerConfigurationPolicyGroupMember{
// 			{
// 				Name: to.Ptr("policy1"),
// 				AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeRadiusAzureGroupID),
// 				AttributeValue: to.Ptr("6ad1bd08"),
// 			},
// 			{
// 				Name: to.Ptr("policy2"),
// 				AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeCertificateGroupID),
// 				AttributeValue: to.Ptr("red.com"),
// 		}},
// 		Priority: to.Ptr[int32](0),
// 		ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 	},
// }

func (*ConfigurationPolicyGroupsClient) NewListByVPNServerConfigurationPager 

func (client *ConfigurationPolicyGroupsClient) NewListByVPNServerConfigurationPager(resourceGroupName string, vpnServerConfigurationName string, options *ConfigurationPolicyGroupsClientListByVPNServerConfigurationOptions) *runtime.Pager[ConfigurationPolicyGroupsClientListByVPNServerConfigurationResponse]

NewListByVPNServerConfigurationPager - Lists all the configurationPolicyGroups in a resource group for a vpnServerConfiguration.

Generated from API version 2024-03-01

  • resourceGroupName - The resource group name of the VpnServerConfiguration.
  • vpnServerConfigurationName - The name of the VpnServerConfiguration.
  • options - ConfigurationPolicyGroupsClientListByVPNServerConfigurationOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.NewListByVPNServerConfigurationPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/ConfigurationPolicyGroupListByVpnServerConfiguration.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewConfigurationPolicyGroupsClient().NewListByVPNServerConfigurationPager("rg1", "vpnServerConfiguration1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ListVPNServerConfigurationPolicyGroupsResult = armnetwork.ListVPNServerConfigurationPolicyGroupsResult{
	// 	Value: []*armnetwork.VPNServerConfigurationPolicyGroup{
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/vpnServerConfigurations/vpnServerConfiguration1/vpnServerConfigurationPolicyGroups/policyGroup1"),
	// 			Name: to.Ptr("policyGroup1"),
	// 			Type: to.Ptr("Microsoft.Network/vpnServerConfigurations/configurationPolicyGroups"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.VPNServerConfigurationPolicyGroupProperties{
	// 				IsDefault: to.Ptr(true),
	// 				P2SConnectionConfigurations: []*armnetwork.SubResource{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/p2sVpnGateways/p2sVpnGateway1/p2sConnectionConfigurations/P2SConnectionConfig1"),
	// 				}},
	// 				PolicyMembers: []*armnetwork.VPNServerConfigurationPolicyGroupMember{
	// 					{
	// 						Name: to.Ptr("policy1"),
	// 						AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeRadiusAzureGroupID),
	// 						AttributeValue: to.Ptr("6ad1bd08"),
	// 					},
	// 					{
	// 						Name: to.Ptr("policy2"),
	// 						AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeCertificateGroupID),
	// 						AttributeValue: to.Ptr("red.com"),
	// 				}},
	// 				Priority: to.Ptr[int32](0),
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 			},
	// 		},
	// 		{
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/vpnServerConfigurations/vpnServerConfiguration1/vpnServerConfigurationPolicyGroups/policyGroup2"),
	// 			Name: to.Ptr("policyGroup2"),
	// 			Etag: to.Ptr("w/\\00000000-0000-0000-0000-000000000000\\"),
	// 			Properties: &armnetwork.VPNServerConfigurationPolicyGroupProperties{
	// 				IsDefault: to.Ptr(true),
	// 				PolicyMembers: []*armnetwork.VPNServerConfigurationPolicyGroupMember{
	// 					{
	// 						Name: to.Ptr("policy1"),
	// 						AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeRadiusAzureGroupID),
	// 						AttributeValue: to.Ptr("6ad1bd08"),
	// 					},
	// 					{
	// 						Name: to.Ptr("policy2"),
	// 						AttributeType: to.Ptr(armnetwork.VPNPolicyMemberAttributeTypeCertificateGroupID),
	// 						AttributeValue: to.Ptr("red.com"),
	// 				}},
	// 				Priority: to.Ptr[int32](0),
	// 				ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

type ConfigurationPolicyGroupsClientBeginCreateOrUpdateOptions 

type ConfigurationPolicyGroupsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConfigurationPolicyGroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.BeginCreateOrUpdate method.

type ConfigurationPolicyGroupsClientBeginDeleteOptions 

type ConfigurationPolicyGroupsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConfigurationPolicyGroupsClientBeginDeleteOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.BeginDelete method.

type ConfigurationPolicyGroupsClientCreateOrUpdateResponse 

type ConfigurationPolicyGroupsClientCreateOrUpdateResponse struct {
	// VpnServerConfigurationPolicyGroup Resource.
	VPNServerConfigurationPolicyGroup
}

ConfigurationPolicyGroupsClientCreateOrUpdateResponse contains the response from method ConfigurationPolicyGroupsClient.BeginCreateOrUpdate.

type ConfigurationPolicyGroupsClientDeleteResponse 

type ConfigurationPolicyGroupsClientDeleteResponse struct {
}

ConfigurationPolicyGroupsClientDeleteResponse contains the response from method ConfigurationPolicyGroupsClient.BeginDelete.

type ConfigurationPolicyGroupsClientGetOptions 

type ConfigurationPolicyGroupsClientGetOptions struct {
}

ConfigurationPolicyGroupsClientGetOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.Get method.

type ConfigurationPolicyGroupsClientGetResponse 

type ConfigurationPolicyGroupsClientGetResponse struct {
	// VpnServerConfigurationPolicyGroup Resource.
	VPNServerConfigurationPolicyGroup
}

ConfigurationPolicyGroupsClientGetResponse contains the response from method ConfigurationPolicyGroupsClient.Get.

type ConfigurationPolicyGroupsClientListByVPNServerConfigurationOptions 

type ConfigurationPolicyGroupsClientListByVPNServerConfigurationOptions struct {
}

ConfigurationPolicyGroupsClientListByVPNServerConfigurationOptions contains the optional parameters for the ConfigurationPolicyGroupsClient.NewListByVPNServerConfigurationPager method.

type ConfigurationPolicyGroupsClientListByVPNServerConfigurationResponse 

type ConfigurationPolicyGroupsClientListByVPNServerConfigurationResponse struct {
	// Result of the request to list VpnServerConfigurationPolicyGroups. It contains a list of VpnServerConfigurationPolicyGroups
	// and a URL nextLink to get the next set of results.
	ListVPNServerConfigurationPolicyGroupsResult
}

ConfigurationPolicyGroupsClientListByVPNServerConfigurationResponse contains the response from method ConfigurationPolicyGroupsClient.NewListByVPNServerConfigurationPager.

type ConfigurationType 

type ConfigurationType string

ConfigurationType - Configuration Deployment Type. 

const (
	ConfigurationTypeConnectivity  ConfigurationType = "Connectivity"
	ConfigurationTypeRouting       ConfigurationType = "Routing"
	ConfigurationTypeSecurityAdmin ConfigurationType = "SecurityAdmin"
	ConfigurationTypeSecurityUser  ConfigurationType = "SecurityUser"
)

func PossibleConfigurationTypeValues 

func PossibleConfigurationTypeValues() []ConfigurationType

PossibleConfigurationTypeValues returns the possible values for the ConfigurationType const type.

type ConnectionMonitor 

type ConnectionMonitor struct {
	// REQUIRED; Properties of the connection monitor.
	Properties *ConnectionMonitorParameters

	// Connection monitor location.
	Location *string

	// Connection monitor tags.
	Tags map[string]*string
}

ConnectionMonitor - Parameters that define the operation to create a connection monitor.

func (ConnectionMonitor) MarshalJSON 

func (c ConnectionMonitor) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitor.

func (*ConnectionMonitor) UnmarshalJSON 

func (c *ConnectionMonitor) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitor.

type ConnectionMonitorDestination 

type ConnectionMonitorDestination struct {
	// Address of the connection monitor destination (IP or domain name).
	Address *string

	// The destination port used by connection monitor.
	Port *int32

	// The ID of the resource used as the destination by connection monitor.
	ResourceID *string
}

ConnectionMonitorDestination - Describes the destination of connection monitor.

func (ConnectionMonitorDestination) MarshalJSON 

func (c ConnectionMonitorDestination) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorDestination.

func (*ConnectionMonitorDestination) UnmarshalJSON 

func (c *ConnectionMonitorDestination) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorDestination.

type ConnectionMonitorEndpoint 

type ConnectionMonitorEndpoint struct {
	// REQUIRED; The name of the connection monitor endpoint.
	Name *string

	// Address of the connection monitor endpoint. Supported for AzureVM, ExternalAddress, ArcMachine, MMAWorkspaceMachine endpoint
	// type.
	Address *string

	// Test coverage for the endpoint.
	CoverageLevel *CoverageLevel

	// Filter field is getting deprecated and should not be used. Instead use Include/Exclude scope fields for it.
	Filter *ConnectionMonitorEndpointFilter

	// Location details is optional and only being used for 'AzureArcNetwork' type endpoints, which contains region details.
	LocationDetails *ConnectionMonitorEndpointLocationDetails

	// Resource ID of the connection monitor endpoint are supported for AzureVM, AzureVMSS, AzureVNet, AzureSubnet, MMAWorkspaceMachine,
	// MMAWorkspaceNetwork, AzureArcVM endpoint type.
	ResourceID *string

	// Endpoint scope defines which target resource to monitor in case of compound resource endpoints like VMSS, AzureSubnet,
	// AzureVNet, MMAWorkspaceNetwork, AzureArcNetwork.
	Scope *ConnectionMonitorEndpointScope

	// Subscription ID for connection monitor endpoint. It's an optional parameter which is being used for 'AzureArcNetwork' type
	// endpoint.
	SubscriptionID *string

	// The endpoint type.
	Type *EndpointType
}

ConnectionMonitorEndpoint - Describes the connection monitor endpoint.

func (ConnectionMonitorEndpoint) MarshalJSON 

func (c ConnectionMonitorEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorEndpoint.

func (*ConnectionMonitorEndpoint) UnmarshalJSON 

func (c *ConnectionMonitorEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorEndpoint.

type ConnectionMonitorEndpointFilter 

type ConnectionMonitorEndpointFilter struct {
	// List of items in the filter.
	Items []*ConnectionMonitorEndpointFilterItem

	// The behavior of the endpoint filter. Currently only 'Include' is supported.
	Type *ConnectionMonitorEndpointFilterType
}

ConnectionMonitorEndpointFilter - Describes the connection monitor endpoint filter.

func (ConnectionMonitorEndpointFilter) MarshalJSON 

func (c ConnectionMonitorEndpointFilter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorEndpointFilter.

func (*ConnectionMonitorEndpointFilter) UnmarshalJSON 

func (c *ConnectionMonitorEndpointFilter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorEndpointFilter.

type ConnectionMonitorEndpointFilterItem 

type ConnectionMonitorEndpointFilterItem struct {
	// The address of the filter item.
	Address *string

	// The type of item included in the filter. Currently only 'AgentAddress' is supported.
	Type *ConnectionMonitorEndpointFilterItemType
}

ConnectionMonitorEndpointFilterItem - Describes the connection monitor endpoint filter item.

func (ConnectionMonitorEndpointFilterItem) MarshalJSON 

func (c ConnectionMonitorEndpointFilterItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorEndpointFilterItem.

func (*ConnectionMonitorEndpointFilterItem) UnmarshalJSON 

func (c *ConnectionMonitorEndpointFilterItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorEndpointFilterItem.

type ConnectionMonitorEndpointFilterItemType 

type ConnectionMonitorEndpointFilterItemType string

ConnectionMonitorEndpointFilterItemType - The type of item included in the filter. Currently only 'AgentAddress' is supported. 

const (
	ConnectionMonitorEndpointFilterItemTypeAgentAddress ConnectionMonitorEndpointFilterItemType = "AgentAddress"
)

func PossibleConnectionMonitorEndpointFilterItemTypeValues 

func PossibleConnectionMonitorEndpointFilterItemTypeValues() []ConnectionMonitorEndpointFilterItemType

PossibleConnectionMonitorEndpointFilterItemTypeValues returns the possible values for the ConnectionMonitorEndpointFilterItemType const type.

type ConnectionMonitorEndpointFilterType 

type ConnectionMonitorEndpointFilterType string

ConnectionMonitorEndpointFilterType - The behavior of the endpoint filter. Currently only 'Include' is supported. 

const (
	ConnectionMonitorEndpointFilterTypeInclude ConnectionMonitorEndpointFilterType = "Include"
)

func PossibleConnectionMonitorEndpointFilterTypeValues 

func PossibleConnectionMonitorEndpointFilterTypeValues() []ConnectionMonitorEndpointFilterType

PossibleConnectionMonitorEndpointFilterTypeValues returns the possible values for the ConnectionMonitorEndpointFilterType const type.

type ConnectionMonitorEndpointLocationDetails 

type ConnectionMonitorEndpointLocationDetails struct {
	// Region for connection monitor endpoint.
	Region *string
}

ConnectionMonitorEndpointLocationDetails - Connection monitor endpoint location details only being used for 'AzureArcNetwork' type endpoints, which contains the region details.

func (ConnectionMonitorEndpointLocationDetails) MarshalJSON 

func (c ConnectionMonitorEndpointLocationDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorEndpointLocationDetails.

func (*ConnectionMonitorEndpointLocationDetails) UnmarshalJSON 

func (c *ConnectionMonitorEndpointLocationDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorEndpointLocationDetails.

type ConnectionMonitorEndpointScope 

type ConnectionMonitorEndpointScope struct {
	// List of items which needs to be excluded from the endpoint scope.
	Exclude []*ConnectionMonitorEndpointScopeItem

	// List of items which needs to be included to the endpoint scope.
	Include []*ConnectionMonitorEndpointScopeItem
}

ConnectionMonitorEndpointScope - Describes the connection monitor endpoint scope.

func (ConnectionMonitorEndpointScope) MarshalJSON 

func (c ConnectionMonitorEndpointScope) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorEndpointScope.

func (*ConnectionMonitorEndpointScope) UnmarshalJSON 

func (c *ConnectionMonitorEndpointScope) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorEndpointScope.

type ConnectionMonitorEndpointScopeItem 

type ConnectionMonitorEndpointScopeItem struct {
	// The address of the endpoint item. Supported types are IPv4/IPv6 subnet mask or IPv4/IPv6 IP address.
	Address *string
}

ConnectionMonitorEndpointScopeItem - Describes the connection monitor endpoint scope item.

func (ConnectionMonitorEndpointScopeItem) MarshalJSON 

func (c ConnectionMonitorEndpointScopeItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorEndpointScopeItem.

func (*ConnectionMonitorEndpointScopeItem) UnmarshalJSON 

func (c *ConnectionMonitorEndpointScopeItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorEndpointScopeItem.

type ConnectionMonitorHTTPConfiguration 

type ConnectionMonitorHTTPConfiguration struct {
	// The HTTP method to use.
	Method *HTTPConfigurationMethod

	// The path component of the URI. For instance, "/dir1/dir2".
	Path *string

	// The port to connect to.
	Port *int32

	// Value indicating whether HTTPS is preferred over HTTP in cases where the choice is not explicit.
	PreferHTTPS *bool

	// The HTTP headers to transmit with the request.
	RequestHeaders []*HTTPHeader

	// HTTP status codes to consider successful. For instance, "2xx,301-304,418".
	ValidStatusCodeRanges []*string
}

ConnectionMonitorHTTPConfiguration - Describes the HTTP configuration.

func (ConnectionMonitorHTTPConfiguration) MarshalJSON 

func (c ConnectionMonitorHTTPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorHTTPConfiguration.

func (*ConnectionMonitorHTTPConfiguration) UnmarshalJSON 

func (c *ConnectionMonitorHTTPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorHTTPConfiguration.

type ConnectionMonitorIcmpConfiguration 

type ConnectionMonitorIcmpConfiguration struct {
	// Value indicating whether path evaluation with trace route should be disabled.
	DisableTraceRoute *bool
}

ConnectionMonitorIcmpConfiguration - Describes the ICMP configuration.

func (ConnectionMonitorIcmpConfiguration) MarshalJSON 

func (c ConnectionMonitorIcmpConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorIcmpConfiguration.

func (*ConnectionMonitorIcmpConfiguration) UnmarshalJSON 

func (c *ConnectionMonitorIcmpConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorIcmpConfiguration.

type ConnectionMonitorListResult 

type ConnectionMonitorListResult struct {
	// Information about connection monitors.
	Value []*ConnectionMonitorResult
}

ConnectionMonitorListResult - List of connection monitors.

func (ConnectionMonitorListResult) MarshalJSON 

func (c ConnectionMonitorListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorListResult.

func (*ConnectionMonitorListResult) UnmarshalJSON 

func (c *ConnectionMonitorListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorListResult.

type ConnectionMonitorOutput 

type ConnectionMonitorOutput struct {
	// Connection monitor output destination type. Currently, only "Workspace" is supported.
	Type *OutputType

	// Describes the settings for producing output into a log analytics workspace.
	WorkspaceSettings *ConnectionMonitorWorkspaceSettings
}

ConnectionMonitorOutput - Describes a connection monitor output destination.

func (ConnectionMonitorOutput) MarshalJSON 

func (c ConnectionMonitorOutput) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorOutput.

func (*ConnectionMonitorOutput) UnmarshalJSON 

func (c *ConnectionMonitorOutput) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorOutput.

type ConnectionMonitorParameters 

type ConnectionMonitorParameters struct {
	// Determines if the connection monitor will start automatically once created.
	AutoStart *bool

	// Describes the destination of connection monitor.
	Destination *ConnectionMonitorDestination

	// List of connection monitor endpoints.
	Endpoints []*ConnectionMonitorEndpoint

	// Monitoring interval in seconds.
	MonitoringIntervalInSeconds *int32

	// Optional notes to be associated with the connection monitor.
	Notes *string

	// List of connection monitor outputs.
	Outputs []*ConnectionMonitorOutput

	// Describes the source of connection monitor.
	Source *ConnectionMonitorSource

	// List of connection monitor test configurations.
	TestConfigurations []*ConnectionMonitorTestConfiguration

	// List of connection monitor test groups.
	TestGroups []*ConnectionMonitorTestGroup
}

ConnectionMonitorParameters - Parameters that define the operation to create a connection monitor.

func (ConnectionMonitorParameters) MarshalJSON 

func (c ConnectionMonitorParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorParameters.

func (*ConnectionMonitorParameters) UnmarshalJSON 

func (c *ConnectionMonitorParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorParameters.

type ConnectionMonitorQueryResult 

type ConnectionMonitorQueryResult struct {
	// Status of connection monitor source.
	SourceStatus *ConnectionMonitorSourceStatus

	// Information about connection states.
	States []*ConnectionStateSnapshot
}

ConnectionMonitorQueryResult - List of connection states snapshots.

func (ConnectionMonitorQueryResult) MarshalJSON 

func (c ConnectionMonitorQueryResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorQueryResult.

func (*ConnectionMonitorQueryResult) UnmarshalJSON 

func (c *ConnectionMonitorQueryResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorQueryResult.

type ConnectionMonitorResult 

type ConnectionMonitorResult struct {
	// Connection monitor location.
	Location *string

	// Properties of the connection monitor result.
	Properties *ConnectionMonitorResultProperties

	// Connection monitor tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

	// READ-ONLY; ID of the connection monitor.
	ID *string

	// READ-ONLY; Name of the connection monitor.
	Name *string

	// READ-ONLY; Connection monitor type.
	Type *string
}

ConnectionMonitorResult - Information about the connection monitor.

func (ConnectionMonitorResult) MarshalJSON 

func (c ConnectionMonitorResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorResult.

func (*ConnectionMonitorResult) UnmarshalJSON 

func (c *ConnectionMonitorResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorResult.

type ConnectionMonitorResultProperties 

type ConnectionMonitorResultProperties struct {
	// Determines if the connection monitor will start automatically once created.
	AutoStart *bool

	// Describes the destination of connection monitor.
	Destination *ConnectionMonitorDestination

	// List of connection monitor endpoints.
	Endpoints []*ConnectionMonitorEndpoint

	// Monitoring interval in seconds.
	MonitoringIntervalInSeconds *int32

	// Optional notes to be associated with the connection monitor.
	Notes *string

	// List of connection monitor outputs.
	Outputs []*ConnectionMonitorOutput

	// Describes the source of connection monitor.
	Source *ConnectionMonitorSource

	// List of connection monitor test configurations.
	TestConfigurations []*ConnectionMonitorTestConfiguration

	// List of connection monitor test groups.
	TestGroups []*ConnectionMonitorTestGroup

	// READ-ONLY; Type of connection monitor.
	ConnectionMonitorType *ConnectionMonitorType

	// READ-ONLY; The monitoring status of the connection monitor.
	MonitoringStatus *string

	// READ-ONLY; The provisioning state of the connection monitor.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The date and time when the connection monitor was started.
	StartTime *time.Time
}

ConnectionMonitorResultProperties - Describes the properties of a connection monitor.

func (ConnectionMonitorResultProperties) MarshalJSON 

func (c ConnectionMonitorResultProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorResultProperties.

func (*ConnectionMonitorResultProperties) UnmarshalJSON 

func (c *ConnectionMonitorResultProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorResultProperties.

type ConnectionMonitorSource 

type ConnectionMonitorSource struct {
	// REQUIRED; The ID of the resource used as the source by connection monitor.
	ResourceID *string

	// The source port used by connection monitor.
	Port *int32
}

ConnectionMonitorSource - Describes the source of connection monitor.

func (ConnectionMonitorSource) MarshalJSON 

func (c ConnectionMonitorSource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorSource.

func (*ConnectionMonitorSource) UnmarshalJSON 

func (c *ConnectionMonitorSource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorSource.

type ConnectionMonitorSourceStatus 

type ConnectionMonitorSourceStatus string

ConnectionMonitorSourceStatus - Status of connection monitor source. 

const (
	ConnectionMonitorSourceStatusActive   ConnectionMonitorSourceStatus = "Active"
	ConnectionMonitorSourceStatusInactive ConnectionMonitorSourceStatus = "Inactive"
	ConnectionMonitorSourceStatusUnknown  ConnectionMonitorSourceStatus = "Unknown"
)

func PossibleConnectionMonitorSourceStatusValues 

func PossibleConnectionMonitorSourceStatusValues() []ConnectionMonitorSourceStatus

PossibleConnectionMonitorSourceStatusValues returns the possible values for the ConnectionMonitorSourceStatus const type.

type ConnectionMonitorSuccessThreshold 

type ConnectionMonitorSuccessThreshold struct {
	// The maximum percentage of failed checks permitted for a test to evaluate as successful.
	ChecksFailedPercent *int32

	// The maximum round-trip time in milliseconds permitted for a test to evaluate as successful.
	RoundTripTimeMs *float32
}

ConnectionMonitorSuccessThreshold - Describes the threshold for declaring a test successful.

func (ConnectionMonitorSuccessThreshold) MarshalJSON 

func (c ConnectionMonitorSuccessThreshold) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorSuccessThreshold.

func (*ConnectionMonitorSuccessThreshold) UnmarshalJSON 

func (c *ConnectionMonitorSuccessThreshold) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorSuccessThreshold.

type ConnectionMonitorTCPConfiguration 

type ConnectionMonitorTCPConfiguration struct {
	// Destination port behavior.
	DestinationPortBehavior *DestinationPortBehavior

	// Value indicating whether path evaluation with trace route should be disabled.
	DisableTraceRoute *bool

	// The port to connect to.
	Port *int32
}

ConnectionMonitorTCPConfiguration - Describes the TCP configuration.

func (ConnectionMonitorTCPConfiguration) MarshalJSON 

func (c ConnectionMonitorTCPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorTCPConfiguration.

func (*ConnectionMonitorTCPConfiguration) UnmarshalJSON 

func (c *ConnectionMonitorTCPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorTCPConfiguration.

type ConnectionMonitorTestConfiguration 

type ConnectionMonitorTestConfiguration struct {
	// REQUIRED; The name of the connection monitor test configuration.
	Name *string

	// REQUIRED; The protocol to use in test evaluation.
	Protocol *ConnectionMonitorTestConfigurationProtocol

	// The parameters used to perform test evaluation over HTTP.
	HTTPConfiguration *ConnectionMonitorHTTPConfiguration

	// The parameters used to perform test evaluation over ICMP.
	IcmpConfiguration *ConnectionMonitorIcmpConfiguration

	// The preferred IP version to use in test evaluation. The connection monitor may choose to use a different version depending
	// on other parameters.
	PreferredIPVersion *PreferredIPVersion

	// The threshold for declaring a test successful.
	SuccessThreshold *ConnectionMonitorSuccessThreshold

	// The parameters used to perform test evaluation over TCP.
	TCPConfiguration *ConnectionMonitorTCPConfiguration

	// The frequency of test evaluation, in seconds.
	TestFrequencySec *int32
}

ConnectionMonitorTestConfiguration - Describes a connection monitor test configuration.

func (ConnectionMonitorTestConfiguration) MarshalJSON 

func (c ConnectionMonitorTestConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorTestConfiguration.

func (*ConnectionMonitorTestConfiguration) UnmarshalJSON 

func (c *ConnectionMonitorTestConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorTestConfiguration.

type ConnectionMonitorTestConfigurationProtocol 

type ConnectionMonitorTestConfigurationProtocol string

ConnectionMonitorTestConfigurationProtocol - The protocol to use in test evaluation. 

const (
	ConnectionMonitorTestConfigurationProtocolHTTP ConnectionMonitorTestConfigurationProtocol = "Http"
	ConnectionMonitorTestConfigurationProtocolIcmp ConnectionMonitorTestConfigurationProtocol = "Icmp"
	ConnectionMonitorTestConfigurationProtocolTCP  ConnectionMonitorTestConfigurationProtocol = "Tcp"
)

func PossibleConnectionMonitorTestConfigurationProtocolValues 

func PossibleConnectionMonitorTestConfigurationProtocolValues() []ConnectionMonitorTestConfigurationProtocol

PossibleConnectionMonitorTestConfigurationProtocolValues returns the possible values for the ConnectionMonitorTestConfigurationProtocol const type.

type ConnectionMonitorTestGroup 

type ConnectionMonitorTestGroup struct {
	// REQUIRED; List of destination endpoint names.
	Destinations []*string

	// REQUIRED; The name of the connection monitor test group.
	Name *string

	// REQUIRED; List of source endpoint names.
	Sources []*string

	// REQUIRED; List of test configuration names.
	TestConfigurations []*string

	// Value indicating whether test group is disabled.
	Disable *bool
}

ConnectionMonitorTestGroup - Describes the connection monitor test group.

func (ConnectionMonitorTestGroup) MarshalJSON 

func (c ConnectionMonitorTestGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorTestGroup.

func (*ConnectionMonitorTestGroup) UnmarshalJSON 

func (c *ConnectionMonitorTestGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorTestGroup.

type ConnectionMonitorType 

type ConnectionMonitorType string

ConnectionMonitorType - Type of connection monitor. 

const (
	ConnectionMonitorTypeMultiEndpoint           ConnectionMonitorType = "MultiEndpoint"
	ConnectionMonitorTypeSingleSourceDestination ConnectionMonitorType = "SingleSourceDestination"
)

func PossibleConnectionMonitorTypeValues 

func PossibleConnectionMonitorTypeValues() []ConnectionMonitorType

PossibleConnectionMonitorTypeValues returns the possible values for the ConnectionMonitorType const type.

type ConnectionMonitorWorkspaceSettings 

type ConnectionMonitorWorkspaceSettings struct {
	// Log analytics workspace resource ID.
	WorkspaceResourceID *string
}

ConnectionMonitorWorkspaceSettings - Describes the settings for producing output into a log analytics workspace.

func (ConnectionMonitorWorkspaceSettings) MarshalJSON 

func (c ConnectionMonitorWorkspaceSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectionMonitorWorkspaceSettings.

func (*ConnectionMonitorWorkspaceSettings) UnmarshalJSON 

func (c *ConnectionMonitorWorkspaceSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionMonitorWorkspaceSettings.

type ConnectionMonitorsClient 

type ConnectionMonitorsClient struct {
	// contains filtered or unexported fields
}

ConnectionMonitorsClient contains the methods for the ConnectionMonitors group. Don't use this type directly, use NewConnectionMonitorsClient() instead.

func NewConnectionMonitorsClient 

func NewConnectionMonitorsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ConnectionMonitorsClient, error)

NewConnectionMonitorsClient creates a new instance of ConnectionMonitorsClient with the specified values.

  • subscriptionID - The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ConnectionMonitorsClient) BeginCreateOrUpdate 

func (client *ConnectionMonitorsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, parameters ConnectionMonitor, options *ConnectionMonitorsClientBeginCreateOrUpdateOptions) (*runtime.Poller[ConnectionMonitorsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update a connection monitor. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • connectionMonitorName - The name of the connection monitor.
  • parameters - Parameters that define the operation to create a connection monitor.
  • options - ConnectionMonitorsClientBeginCreateOrUpdateOptions contains the optional parameters for the ConnectionMonitorsClient.BeginCreateOrUpdate method.
Example (CreateConnectionMonitorV1)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginCreateOrUpdate(ctx, "rg1", "nw1", "cm1", armnetwork.ConnectionMonitor{
	Location: to.Ptr("eastus"),
	Properties: &armnetwork.ConnectionMonitorParameters{
		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
			{
				Name:       to.Ptr("source"),
				ResourceID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/ct1"),
			},
			{
				Name:    to.Ptr("destination"),
				Address: to.Ptr("bing.com"),
			}},
		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
			{
				Name: to.Ptr("tcp"),
				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
					Port: to.Ptr[int32](80),
				},
				TestFrequencySec: to.Ptr[int32](60),
				Protocol:         to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
			}},
		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
			{
				Name: to.Ptr("tg"),
				Destinations: []*string{
					to.Ptr("destination")},
				Sources: []*string{
					to.Ptr("source")},
				TestConfigurations: []*string{
					to.Ptr("tcp")},
			}},
	},
}, &armnetwork.ConnectionMonitorsClientBeginCreateOrUpdateOptions{Migrate: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConnectionMonitorResult = armnetwork.ConnectionMonitorResult{
// 	Name: to.Ptr("cm1"),
// 	Type: to.Ptr("Microsoft.Network/networkWatchers/connectionMonitors"),
// 	Etag: to.Ptr("W/\"e7497f26-5f09-4559-900b-fe98f3dedb6f\""),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/networkWatchers/nw1/connectionMonitors/cm1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetwork.ConnectionMonitorResultProperties{
// 		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
// 			{
// 				Name: to.Ptr("source"),
// 				ResourceID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/ct1"),
// 			},
// 			{
// 				Name: to.Ptr("destination"),
// 				Address: to.Ptr("bing.com"),
// 		}},
// 		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
// 			{
// 				Name: to.Ptr("tcp"),
// 				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
// 					Port: to.Ptr[int32](80),
// 				},
// 				TestFrequencySec: to.Ptr[int32](60),
// 				Protocol: to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
// 		}},
// 		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
// 			{
// 				Name: to.Ptr("tg"),
// 				Destinations: []*string{
// 					to.Ptr("destination")},
// 					Sources: []*string{
// 						to.Ptr("source")},
// 						TestConfigurations: []*string{
// 							to.Ptr("tcp")},
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 			}
Example (CreateConnectionMonitorV2)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorV2Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginCreateOrUpdate(ctx, "rg1", "nw1", "cm1", armnetwork.ConnectionMonitor{
	Properties: &armnetwork.ConnectionMonitorParameters{
		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
			{
				Name:       to.Ptr("vm1"),
				ResourceID: to.Ptr("/subscriptions/96e68903-0a56-4819-9987-8d08ad6a1f99/resourceGroups/NwRgIrinaCentralUSEUAP/providers/Microsoft.Compute/virtualMachines/vm1"),
			},
			{
				Name: to.Ptr("CanaryWorkspaceVamshi"),
				Filter: &armnetwork.ConnectionMonitorEndpointFilter{
					Type: to.Ptr(armnetwork.ConnectionMonitorEndpointFilterTypeInclude),
					Items: []*armnetwork.ConnectionMonitorEndpointFilterItem{
						{
							Type:    to.Ptr(armnetwork.ConnectionMonitorEndpointFilterItemTypeAgentAddress),
							Address: to.Ptr("npmuser"),
						}},
				},
				ResourceID: to.Ptr("/subscriptions/96e68903-0a56-4819-9987-8d08ad6a1f99/resourceGroups/vasamudrRG/providers/Microsoft.OperationalInsights/workspaces/vasamudrWorkspace"),
			},
			{
				Name:    to.Ptr("bing"),
				Address: to.Ptr("bing.com"),
			},
			{
				Name:    to.Ptr("google"),
				Address: to.Ptr("google.com"),
			}},
		Outputs: []*armnetwork.ConnectionMonitorOutput{},
		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
			{
				Name: to.Ptr("testConfig1"),
				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
					DisableTraceRoute: to.Ptr(false),
					Port:              to.Ptr[int32](80),
				},
				TestFrequencySec: to.Ptr[int32](60),
				Protocol:         to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
			}},
		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
			{
				Name: to.Ptr("test1"),
				Destinations: []*string{
					to.Ptr("bing"),
					to.Ptr("google")},
				Disable: to.Ptr(false),
				Sources: []*string{
					to.Ptr("vm1"),
					to.Ptr("CanaryWorkspaceVamshi")},
				TestConfigurations: []*string{
					to.Ptr("testConfig1")},
			}},
	},
}, &armnetwork.ConnectionMonitorsClientBeginCreateOrUpdateOptions{Migrate: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConnectionMonitorResult = armnetwork.ConnectionMonitorResult{
// 	Name: to.Ptr("cm1"),
// 	Type: to.Ptr("Microsoft.Network/networkWatchers/connectionMonitors"),
// 	Etag: to.Ptr("W/\"e7497f26-5f09-4559-900b-fe98f3dedb6f\""),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/networkWatchers/nw1/connectionMonitors/cm1"),
// 	Location: to.Ptr("centraluseuap"),
// 	Properties: &armnetwork.ConnectionMonitorResultProperties{
// 		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
// 			{
// 				Name: to.Ptr("vm1"),
// 				ResourceID: to.Ptr("/subscriptions/96e68903-0a56-4819-9987-8d08ad6a1f99/resourceGroups/NwRgIrinaCentralUSEUAP/providers/Microsoft.Compute/virtualMachines/vm1"),
// 			},
// 			{
// 				Name: to.Ptr("CanaryWorkspaceVamshi"),
// 				Filter: &armnetwork.ConnectionMonitorEndpointFilter{
// 					Type: to.Ptr(armnetwork.ConnectionMonitorEndpointFilterTypeInclude),
// 					Items: []*armnetwork.ConnectionMonitorEndpointFilterItem{
// 						{
// 							Type: to.Ptr(armnetwork.ConnectionMonitorEndpointFilterItemTypeAgentAddress),
// 							Address: to.Ptr("npmuser"),
// 					}},
// 				},
// 				ResourceID: to.Ptr("/subscriptions/96e68903-0a56-4819-9987-8d08ad6a1f99/resourceGroups/vasamudrRG/providers/Microsoft.OperationalInsights/workspaces/vasamudrWorkspace"),
// 			},
// 			{
// 				Name: to.Ptr("bing"),
// 				Address: to.Ptr("bing.com"),
// 			},
// 			{
// 				Name: to.Ptr("google"),
// 				Address: to.Ptr("google.com"),
// 		}},
// 		Outputs: []*armnetwork.ConnectionMonitorOutput{
// 		},
// 		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
// 			{
// 				Name: to.Ptr("testConfig1"),
// 				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
// 					DisableTraceRoute: to.Ptr(false),
// 					Port: to.Ptr[int32](80),
// 				},
// 				TestFrequencySec: to.Ptr[int32](60),
// 				Protocol: to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
// 		}},
// 		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
// 			{
// 				Name: to.Ptr("test1"),
// 				Destinations: []*string{
// 					to.Ptr("bing"),
// 					to.Ptr("google")},
// 					Disable: to.Ptr(false),
// 					Sources: []*string{
// 						to.Ptr("vm1"),
// 						to.Ptr("CanaryWorkspaceVamshi")},
// 						TestConfigurations: []*string{
// 							to.Ptr("testConfig1")},
// 					}},
// 				},
// 			}
Example (CreateConnectionMonitorWithArcNetwork)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorCreateWithArcNetwork.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginCreateOrUpdate(ctx, "rg1", "nw1", "cm1", armnetwork.ConnectionMonitor{
	Properties: &armnetwork.ConnectionMonitorParameters{
		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
			{
				Name:       to.Ptr("vm1"),
				Type:       to.Ptr(armnetwork.EndpointTypeAzureVM),
				ResourceID: to.Ptr("/subscriptions/9cece3e3-0f7d-47ca-af0e-9772773f90b7/resourceGroups/testRG/providers/Microsoft.Compute/virtualMachines/TESTVM"),
			},
			{
				Name:    to.Ptr("bing"),
				Type:    to.Ptr(armnetwork.EndpointTypeExternalAddress),
				Address: to.Ptr("bing.com"),
			},
			{
				Name:    to.Ptr("google"),
				Type:    to.Ptr(armnetwork.EndpointTypeExternalAddress),
				Address: to.Ptr("google.com"),
			},
			{
				Name: to.Ptr("ArcBasedNetwork"),
				Type: to.Ptr(armnetwork.EndpointTypeAzureArcNetwork),
				LocationDetails: &armnetwork.ConnectionMonitorEndpointLocationDetails{
					Region: to.Ptr("eastus"),
				},
				Scope: &armnetwork.ConnectionMonitorEndpointScope{
					Include: []*armnetwork.ConnectionMonitorEndpointScopeItem{
						{
							Address: to.Ptr("172.21.128.0/20"),
						}},
				},
				SubscriptionID: to.Ptr("9cece3e3-0f7d-47ca-af0e-9772773f90b7"),
			}},
		Outputs: []*armnetwork.ConnectionMonitorOutput{},
		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
			{
				Name: to.Ptr("testConfig1"),
				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
					DisableTraceRoute: to.Ptr(false),
					Port:              to.Ptr[int32](80),
				},
				TestFrequencySec: to.Ptr[int32](60),
				Protocol:         to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
			}},
		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
			{
				Name: to.Ptr("test1"),
				Destinations: []*string{
					to.Ptr("bing"),
					to.Ptr("google")},
				Disable: to.Ptr(false),
				Sources: []*string{
					to.Ptr("vm1"),
					to.Ptr("ArcBasedNetwork")},
				TestConfigurations: []*string{
					to.Ptr("testConfig1")},
			}},
	},
}, &armnetwork.ConnectionMonitorsClientBeginCreateOrUpdateOptions{Migrate: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConnectionMonitorResult = armnetwork.ConnectionMonitorResult{
// 	Name: to.Ptr("cm1"),
// 	Type: to.Ptr("Microsoft.Network/networkWatchers/connectionMonitors"),
// 	Etag: to.Ptr("W/\"e7497f26-5f09-4559-900b-fe98f3dedb6f\""),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/networkWatchers/nw1/connectionMonitors/cm1"),
// 	Location: to.Ptr("centraluseuap"),
// 	Properties: &armnetwork.ConnectionMonitorResultProperties{
// 		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
// 			{
// 				Name: to.Ptr("vm1"),
// 				ResourceID: to.Ptr("/subscriptions/9cece3e3-0f7d-47ca-af0e-9772773f90b7/resourceGroups/testRG/providers/Microsoft.Compute/virtualMachines/TESTVM"),
// 			},
// 			{
// 				Name: to.Ptr("ArcBasedNetwork"),
// 				Type: to.Ptr(armnetwork.EndpointTypeAzureArcNetwork),
// 				LocationDetails: &armnetwork.ConnectionMonitorEndpointLocationDetails{
// 					Region: to.Ptr("eastus"),
// 				},
// 				Scope: &armnetwork.ConnectionMonitorEndpointScope{
// 					Include: []*armnetwork.ConnectionMonitorEndpointScopeItem{
// 						{
// 							Address: to.Ptr("172.21.128.0/20"),
// 					}},
// 				},
// 				SubscriptionID: to.Ptr("9cece3e3-0f7d-47ca-af0e-9772773f90b7"),
// 			},
// 			{
// 				Name: to.Ptr("bing"),
// 				Address: to.Ptr("bing.com"),
// 			},
// 			{
// 				Name: to.Ptr("google"),
// 				Address: to.Ptr("google.com"),
// 		}},
// 		Outputs: []*armnetwork.ConnectionMonitorOutput{
// 		},
// 		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
// 			{
// 				Name: to.Ptr("testConfig1"),
// 				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
// 					DisableTraceRoute: to.Ptr(false),
// 					Port: to.Ptr[int32](80),
// 				},
// 				TestFrequencySec: to.Ptr[int32](60),
// 				Protocol: to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
// 		}},
// 		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
// 			{
// 				Name: to.Ptr("test1"),
// 				Destinations: []*string{
// 					to.Ptr("bing"),
// 					to.Ptr("google")},
// 					Disable: to.Ptr(false),
// 					Sources: []*string{
// 						to.Ptr("vm1"),
// 						to.Ptr("ArcBasedNetwork")},
// 						TestConfigurations: []*string{
// 							to.Ptr("testConfig1")},
// 					}},
// 				},
// 			}

func (*ConnectionMonitorsClient) BeginDelete 

func (client *ConnectionMonitorsClient) BeginDelete(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, options *ConnectionMonitorsClientBeginDeleteOptions) (*runtime.Poller[ConnectionMonitorsClientDeleteResponse], error)

BeginDelete - Deletes the specified connection monitor. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • connectionMonitorName - The name of the connection monitor.
  • options - ConnectionMonitorsClientBeginDeleteOptions contains the optional parameters for the ConnectionMonitorsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginDelete(ctx, "rg1", "nw1", "cm1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ConnectionMonitorsClient) BeginQuery 

func (client *ConnectionMonitorsClient) BeginQuery(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, options *ConnectionMonitorsClientBeginQueryOptions) (*runtime.Poller[ConnectionMonitorsClientQueryResponse], error)

BeginQuery - Query a snapshot of the most recent connection states. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • connectionMonitorName - The name given to the connection monitor.
  • options - ConnectionMonitorsClientBeginQueryOptions contains the optional parameters for the ConnectionMonitorsClient.BeginQuery method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorQuery.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginQuery(ctx, "rg1", "nw1", "cm1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConnectionMonitorQueryResult = armnetwork.ConnectionMonitorQueryResult{
// 	SourceStatus: to.Ptr(armnetwork.ConnectionMonitorSourceStatusActive),
// 	States: []*armnetwork.ConnectionStateSnapshot{
// 		{
// 			ConnectionState: to.Ptr(armnetwork.ConnectionStateReachable),
// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-01-08T05:12:41.526Z"); return t}()),
// 			EvaluationState: to.Ptr(armnetwork.EvaluationStateCompleted),
// 			Hops: []*armnetwork.ConnectivityHop{
// 				{
// 					Type: to.Ptr("Source"),
// 					Address: to.Ptr("10.1.1.4"),
// 					ID: to.Ptr("7dbbe7aa-60ba-4650-831e-63d775d38e9e"),
// 					Issues: []*armnetwork.ConnectivityIssue{
// 					},
// 					NextHopIDs: []*string{
// 						to.Ptr("75c8d819-b208-4584-a311-1aa45ce753f9")},
// 						ResourceID: to.Ptr("subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/networkInterfaces/nic0/ipConfigurations/ipconfig1"),
// 					},
// 					{
// 						Type: to.Ptr("VirtualNetwork"),
// 						Address: to.Ptr("192.168.100.4"),
// 						ID: to.Ptr("75c8d819-b208-4584-a311-1aa45ce753f9"),
// 						Issues: []*armnetwork.ConnectivityIssue{
// 						},
// 						NextHopIDs: []*string{
// 						},
// 						ResourceID: to.Ptr("subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/networkInterfaces/nic1/ipConfigurations/ipconfig1"),
// 				}},
// 				StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-01-08T03:42:33.338Z"); return t}()),
// 		}},
// 	}

func (*ConnectionMonitorsClient) BeginStart 

func (client *ConnectionMonitorsClient) BeginStart(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, options *ConnectionMonitorsClientBeginStartOptions) (*runtime.Poller[ConnectionMonitorsClientStartResponse], error)

BeginStart - Starts the specified connection monitor. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • connectionMonitorName - The name of the connection monitor.
  • options - ConnectionMonitorsClientBeginStartOptions contains the optional parameters for the ConnectionMonitorsClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorStart.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginStart(ctx, "rg1", "nw1", "cm1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ConnectionMonitorsClient) BeginStop 

func (client *ConnectionMonitorsClient) BeginStop(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, options *ConnectionMonitorsClientBeginStopOptions) (*runtime.Poller[ConnectionMonitorsClientStopResponse], error)

BeginStop - Stops the specified connection monitor. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • connectionMonitorName - The name of the connection monitor.
  • options - ConnectionMonitorsClientBeginStopOptions contains the optional parameters for the ConnectionMonitorsClient.BeginStop method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorStop.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectionMonitorsClient().BeginStop(ctx, "rg1", "nw1", "cm1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

func (*ConnectionMonitorsClient) Get 

func (client *ConnectionMonitorsClient) Get(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, options *ConnectionMonitorsClientGetOptions) (ConnectionMonitorsClientGetResponse, error)

Get - Gets a connection monitor by name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • connectionMonitorName - The name of the connection monitor.
  • options - ConnectionMonitorsClientGetOptions contains the optional parameters for the ConnectionMonitorsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConnectionMonitorsClient().Get(ctx, "rg1", "nw1", "cm1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConnectionMonitorResult = armnetwork.ConnectionMonitorResult{
// 	Name: to.Ptr("cm1"),
// 	Type: to.Ptr("Microsoft.Network/networkWatchers/connectionMonitors"),
// 	Etag: to.Ptr("W/\"00000000-0000-0000-0000-000000000000\""),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/networkWatchers/nw1/connectionMonitors/cm1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetwork.ConnectionMonitorResultProperties{
// 		Endpoints: []*armnetwork.ConnectionMonitorEndpoint{
// 			{
// 				Name: to.Ptr("source"),
// 				ResourceID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/ct1"),
// 			},
// 			{
// 				Name: to.Ptr("destination"),
// 				Address: to.Ptr("bing.com"),
// 		}},
// 		TestConfigurations: []*armnetwork.ConnectionMonitorTestConfiguration{
// 			{
// 				Name: to.Ptr("tcp"),
// 				TCPConfiguration: &armnetwork.ConnectionMonitorTCPConfiguration{
// 					Port: to.Ptr[int32](80),
// 				},
// 				TestFrequencySec: to.Ptr[int32](60),
// 				Protocol: to.Ptr(armnetwork.ConnectionMonitorTestConfigurationProtocolTCP),
// 		}},
// 		TestGroups: []*armnetwork.ConnectionMonitorTestGroup{
// 			{
// 				Name: to.Ptr("tg"),
// 				Destinations: []*string{
// 					to.Ptr("destination")},
// 					Sources: []*string{
// 						to.Ptr("source")},
// 						TestConfigurations: []*string{
// 							to.Ptr("tcp")},
// 					}},
// 					ProvisioningState: to.Ptr(armnetwork.ProvisioningStateSucceeded),
// 				},
// 			}

func (*ConnectionMonitorsClient) NewListPager 

func (client *ConnectionMonitorsClient) NewListPager(resourceGroupName string, networkWatcherName string, options *ConnectionMonitorsClientListOptions) *runtime.Pager[ConnectionMonitorsClientListResponse]

NewListPager - Lists all connection monitors for the specified Network Watcher.

Generated from API version 2024-03-01

  • resourceGroupName - The name of the resource group containing Network Watcher.
  • networkWatcherName - The name of the Network Watcher resource.
  • options - ConnectionMonitorsClientListOptions contains the optional parameters for the ConnectionMonitorsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/4883fa5dbf6f2c9093fac8ce334547e9dfac68fa/specification/network/resource-manager/Microsoft.Network/stable/2024-03-01/examples/NetworkWatcherConnectionMonitorList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := cont