armmanagednetworkfabric

package module
v0.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: 14 Imported by: 0

README

Azure Managednetworkfabric Module for Go

The armmanagednetworkfabric module provides operations for working with Azure Managednetworkfabric.

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 Managednetworkfabric module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Managednetworkfabric. 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 Managednetworkfabric 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 := armmanagednetworkfabric.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,
    },
}
client, err := armmanagednetworkfabric.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.NewExternalNetworksClient()

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.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Managednetworkfabric 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 ACLActionType 

type ACLActionType string

ACLActionType - Type of actions that can be performed. 

const (
	ACLActionTypeCount ACLActionType = "Count"
	ACLActionTypeDrop  ACLActionType = "Drop"
	ACLActionTypeLog   ACLActionType = "Log"
)

func PossibleACLActionTypeValues 

func PossibleACLActionTypeValues() []ACLActionType

PossibleACLActionTypeValues returns the possible values for the ACLActionType const type.

type AccessControlList 

type AccessControlList struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *AccessControlListProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

AccessControlList - The Access Control List resource definition.

func (AccessControlList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlList.

func (*AccessControlList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlList.

type AccessControlListAction 

type AccessControlListAction struct {
	// Name of the counter block to get match count information.
	CounterName *string

	// Type of actions that can be performed.
	Type *ACLActionType
}

AccessControlListAction - Action that need to performed.

func (AccessControlListAction) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListAction.

func (*AccessControlListAction) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListAction.

type AccessControlListMatchCondition 

type AccessControlListMatchCondition struct {
	// List of DSCP Markings that needs to be matched.
	DscpMarkings []*string

	// List of ether type values that needs to be matched.
	EtherTypes []*string

	// List of IP fragment packets that needs to be matched.
	Fragments []*string

	// IP condition that needs to be matched.
	IPCondition *IPMatchCondition

	// List of IP Lengths that needs to be matched.
	IPLengths []*string

	// Defines the port condition that needs to be matched.
	PortCondition *AccessControlListPortCondition

	// List of the protocols that need to be matched.
	ProtocolTypes []*string

	// List of TTL [Time To Live] values that needs to be matched.
	TTLValues []*string

	// Vlan match condition that needs to be matched.
	VlanMatchCondition *VlanMatchCondition
}

AccessControlListMatchCondition - Defines the match condition that is supported to filter the traffic.

func (AccessControlListMatchCondition) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListMatchCondition.

func (*AccessControlListMatchCondition) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListMatchCondition.

type AccessControlListMatchConfiguration 

type AccessControlListMatchConfiguration struct {
	// List of actions that need to be performed for the matched conditions.
	Actions []*AccessControlListAction

	// Type of IP Address. IPv4 or IPv6
	IPAddressType *IPAddressType

	// List of the match conditions.
	MatchConditions []*AccessControlListMatchCondition

	// The name of the match configuration.
	MatchConfigurationName *string

	// Sequence Number of the match configuration.
	SequenceNumber *int64
}

AccessControlListMatchConfiguration - Defines the match configuration that are supported to filter the traffic.

func (AccessControlListMatchConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListMatchConfiguration.

func (*AccessControlListMatchConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListMatchConfiguration.

type AccessControlListPatch 

type AccessControlListPatch struct {
	// Access Control Lists patch properties.
	Properties *AccessControlListPatchProperties

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

AccessControlListPatch - The Access Control Lists patch resource definition.

func (AccessControlListPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListPatch.

func (*AccessControlListPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListPatch.

type AccessControlListPatchProperties 

type AccessControlListPatchProperties struct {
	// Access Control List file URL.
	ACLsURL *string

	// Switch configuration description.
	Annotation *string

	// Input method to configure Access Control List.
	ConfigurationType *ConfigurationType

	// List of dynamic match configurations.
	DynamicMatchConfigurations []*CommonDynamicMatchConfiguration

	// List of match configurations.
	MatchConfigurations []*AccessControlListMatchConfiguration
}

AccessControlListPatchProperties - Access Control Lists patch properties.

func (AccessControlListPatchProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListPatchProperties.

func (*AccessControlListPatchProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListPatchProperties.

type AccessControlListPortCondition 

type AccessControlListPortCondition struct {
	// REQUIRED; Layer4 protocol type that needs to be matched.
	Layer4Protocol *Layer4Protocol

	// List of protocol flags that needs to be matched.
	Flags []*string

	// List of the port Group Names that to be matched.
	PortGroupNames []*string

	// Port type that needs to be matched.
	PortType *PortType

	// List of the Ports that need to be matched.
	Ports []*string
}

AccessControlListPortCondition - Defines the port condition that needs to be matched.

func (AccessControlListPortCondition) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListPortCondition.

func (*AccessControlListPortCondition) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListPortCondition.

type AccessControlListProperties 

type AccessControlListProperties struct {
	// Access Control List file URL.
	ACLsURL *string

	// Switch configuration description.
	Annotation *string

	// Input method to configure Access Control List.
	ConfigurationType *ConfigurationType

	// List of dynamic match configurations.
	DynamicMatchConfigurations []*CommonDynamicMatchConfiguration

	// List of match configurations.
	MatchConfigurations []*AccessControlListMatchConfiguration

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; The last synced timestamp.
	LastSyncedTime *time.Time

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

AccessControlListProperties - Access Control List Properties defines the resource properties.

func (AccessControlListProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListProperties.

func (*AccessControlListProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListProperties.

type AccessControlListsClient 

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

AccessControlListsClient contains the methods for the AccessControlLists group. Don't use this type directly, use NewAccessControlListsClient() instead.

func NewAccessControlListsClient 

func NewAccessControlListsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AccessControlListsClient, error)

NewAccessControlListsClient creates a new instance of AccessControlListsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AccessControlListsClient) BeginCreate 

func (client *AccessControlListsClient) BeginCreate(ctx context.Context, resourceGroupName string, accessControlListName string, body AccessControlList, options *AccessControlListsClientBeginCreateOptions) (*runtime.Poller[AccessControlListsClientCreateResponse], error)

BeginCreate - Implements Access Control List PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • body - Request payload.
  • options - AccessControlListsClientBeginCreateOptions contains the optional parameters for the AccessControlListsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlListsClient().BeginCreate(ctx, "example-rg", "example-acl", armmanagednetworkfabric.AccessControlList{
		Location: to.Ptr("eastUs"),
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.AccessControlListProperties{
			ACLsURL:           to.Ptr("https://ACL-Storage-URL"),
			ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
			DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
				{
					IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
						{
							Name:          to.Ptr("example-ipGroup"),
							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
							IPPrefixes: []*string{
								to.Ptr("10.20.3.1/20")},
						}},
					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
						{
							Name: to.Ptr("example-portGroup"),
							Ports: []*string{
								to.Ptr("100-200")},
						}},
					VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
						{
							Name: to.Ptr("example-vlanGroup"),
							Vlans: []*string{
								to.Ptr("20-30")},
						}},
				}},
			MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
				{
					Actions: []*armmanagednetworkfabric.AccessControlListAction{
						{
							Type:        to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
							CounterName: to.Ptr("example-counter"),
						}},
					IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
					MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
						{
							IPCondition: &armmanagednetworkfabric.IPMatchCondition{
								Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
								IPGroupNames: []*string{
									to.Ptr("example-ipGroup")},
								IPPrefixValues: []*string{
									to.Ptr("10.20.20.20/12")},
								PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
							},
							ProtocolTypes: []*string{
								to.Ptr("TCP")},
							VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
								InnerVlans: []*string{
									to.Ptr("30")},
								VlanGroupNames: []*string{
									to.Ptr("example-vlanGroup")},
								Vlans: []*string{
									to.Ptr("20-30")},
							},
							DscpMarkings: []*string{
								to.Ptr("32")},
							EtherTypes: []*string{
								to.Ptr("0x1")},
							Fragments: []*string{
								to.Ptr("0xff00-0xffff")},
							IPLengths: []*string{
								to.Ptr("4094-9214")},
							PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
								Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
								PortGroupNames: []*string{
									to.Ptr("example-portGroup")},
								PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
								Ports: []*string{
									to.Ptr("1-20")},
								Flags: []*string{
									to.Ptr("established")},
							},
							TTLValues: []*string{
								to.Ptr("23")},
						}},
					MatchConfigurationName: to.Ptr("example-match"),
					SequenceNumber:         to.Ptr[int64](123),
				}},
			Annotation: to.Ptr("annotation"),
		},
	}, 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.AccessControlList = armmanagednetworkfabric.AccessControlList{
	// 	Name: to.Ptr("example-acl"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/accessControlLists"),
	// 	ID: to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastUs"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.AccessControlListProperties{
	// 		ACLsURL: to.Ptr("https://ACL-Storage-URL"),
	// 		ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
	// 		DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
	// 			{
	// 				IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
	// 					{
	// 						Name: to.Ptr("example-ipGroup"),
	// 						IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 						IPPrefixes: []*string{
	// 							to.Ptr("10.20.3.1/20")},
	// 					}},
	// 					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
	// 						{
	// 							Name: to.Ptr("example-portGroup"),
	// 							Ports: []*string{
	// 								to.Ptr("100-200")},
	// 						}},
	// 						VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
	// 							{
	// 								Name: to.Ptr("example-vlanGroup"),
	// 								Vlans: []*string{
	// 									to.Ptr("20-30")},
	// 							}},
	// 					}},
	// 					MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
	// 						{
	// 							Actions: []*armmanagednetworkfabric.AccessControlListAction{
	// 								{
	// 									Type: to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
	// 									CounterName: to.Ptr("example-counter"),
	// 							}},
	// 							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 							MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
	// 								{
	// 									IPCondition: &armmanagednetworkfabric.IPMatchCondition{
	// 										Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
	// 										IPGroupNames: []*string{
	// 											to.Ptr("example-ipGroup")},
	// 											IPPrefixValues: []*string{
	// 												to.Ptr("10.20.20.20/12")},
	// 												PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
	// 											},
	// 											ProtocolTypes: []*string{
	// 												to.Ptr("TCP")},
	// 												VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
	// 													InnerVlans: []*string{
	// 														to.Ptr("30")},
	// 														VlanGroupNames: []*string{
	// 															to.Ptr("example-vlanGroup")},
	// 															Vlans: []*string{
	// 																to.Ptr("20-30")},
	// 															},
	// 															DscpMarkings: []*string{
	// 																to.Ptr("32")},
	// 																EtherTypes: []*string{
	// 																	to.Ptr("0x1")},
	// 																	Fragments: []*string{
	// 																		to.Ptr("0xff00-0xffff")},
	// 																		IPLengths: []*string{
	// 																			to.Ptr("4094-9214")},
	// 																			PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
	// 																				Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
	// 																				PortGroupNames: []*string{
	// 																					to.Ptr("example-portGroup")},
	// 																					PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
	// 																					Ports: []*string{
	// 																						to.Ptr("1-20")},
	// 																						Flags: []*string{
	// 																							to.Ptr("established")},
	// 																						},
	// 																						TTLValues: []*string{
	// 																							to.Ptr("23")},
	// 																					}},
	// 																					MatchConfigurationName: to.Ptr("example-match"),
	// 																					SequenceNumber: to.Ptr[int64](123),
	// 																			}},
	// 																			Annotation: to.Ptr("annotation"),
	// 																			AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 																			ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 																			LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-17T08:56:23.203Z"); return t}()),
	// 																			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 																		},
	// 																	}
}

Output:

func (*AccessControlListsClient) BeginDelete 

func (client *AccessControlListsClient) BeginDelete(ctx context.Context, resourceGroupName string, accessControlListName string, options *AccessControlListsClientBeginDeleteOptions) (*runtime.Poller[AccessControlListsClientDeleteResponse], error)

BeginDelete - Implements Access Control List DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • options - AccessControlListsClientBeginDeleteOptions contains the optional parameters for the AccessControlListsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlListsClient().BeginDelete(ctx, "example-rg", "example-acl", 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)
	}
}

Output:

func (*AccessControlListsClient) BeginResync 

func (client *AccessControlListsClient) BeginResync(ctx context.Context, resourceGroupName string, accessControlListName string, options *AccessControlListsClientBeginResyncOptions) (*runtime.Poller[AccessControlListsClientResyncResponse], error)

BeginResync - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • options - AccessControlListsClientBeginResyncOptions contains the optional parameters for the AccessControlListsClient.BeginResync method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_Resync_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlListsClient().BeginResync(ctx, "example-rg", "example-acl", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*AccessControlListsClient) BeginUpdate 

func (client *AccessControlListsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accessControlListName string, body AccessControlListPatch, options *AccessControlListsClientBeginUpdateOptions) (*runtime.Poller[AccessControlListsClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the Access Control List resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • body - Access Control List properties to update.
  • options - AccessControlListsClientBeginUpdateOptions contains the optional parameters for the AccessControlListsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlListsClient().BeginUpdate(ctx, "example-rg", "example-acl", armmanagednetworkfabric.AccessControlListPatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.AccessControlListPatchProperties{
			ACLsURL:           to.Ptr("https://microsoft.com/a"),
			ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
			DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
				{
					IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
						{
							Name:          to.Ptr("example-ipGroup"),
							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
							IPPrefixes: []*string{
								to.Ptr("10.20.3.1/20")},
						}},
					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
						{
							Name: to.Ptr("example-portGroup"),
							Ports: []*string{
								to.Ptr("100-200")},
						}},
					VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
						{
							Name: to.Ptr("example-vlanGroup"),
							Vlans: []*string{
								to.Ptr("20-30")},
						}},
				}},
			MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
				{
					Actions: []*armmanagednetworkfabric.AccessControlListAction{
						{
							Type:        to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
							CounterName: to.Ptr("example-counter"),
						}},
					IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
					MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
						{
							IPCondition: &armmanagednetworkfabric.IPMatchCondition{
								Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
								IPGroupNames: []*string{
									to.Ptr("example-ipGroup")},
								IPPrefixValues: []*string{
									to.Ptr("10.20.20.20/12")},
								PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
							},
							ProtocolTypes: []*string{
								to.Ptr("TCP")},
							VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
								InnerVlans: []*string{
									to.Ptr("30")},
								VlanGroupNames: []*string{
									to.Ptr("example-vlanGroup")},
								Vlans: []*string{
									to.Ptr("20-30")},
							},
							DscpMarkings: []*string{
								to.Ptr("32")},
							EtherTypes: []*string{
								to.Ptr("0x1")},
							Fragments: []*string{
								to.Ptr("0xff00-0xffff")},
							IPLengths: []*string{
								to.Ptr("4094-9214")},
							PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
								Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
								PortGroupNames: []*string{
									to.Ptr("example-portGroup")},
								PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
								Ports: []*string{
									to.Ptr("1-20")},
								Flags: []*string{
									to.Ptr("established")},
							},
							TTLValues: []*string{
								to.Ptr("23")},
						}},
					MatchConfigurationName: to.Ptr("example-match"),
					SequenceNumber:         to.Ptr[int64](123),
				}},
			Annotation: to.Ptr("annotation"),
		},
	}, 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.AccessControlList = armmanagednetworkfabric.AccessControlList{
	// 	Name: to.Ptr("example-acl"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/accessControlLists"),
	// 	ID: to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastUs"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.AccessControlListProperties{
	// 		ACLsURL: to.Ptr("https://ACL-Storage-URL"),
	// 		ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
	// 		DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
	// 			{
	// 				IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
	// 					{
	// 						Name: to.Ptr("example-ipGroup"),
	// 						IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 						IPPrefixes: []*string{
	// 							to.Ptr("10.20.3.1/20")},
	// 					}},
	// 					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
	// 						{
	// 							Name: to.Ptr("example-portGroup"),
	// 							Ports: []*string{
	// 								to.Ptr("100-200")},
	// 						}},
	// 						VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
	// 							{
	// 								Name: to.Ptr("example-vlanGroup"),
	// 								Vlans: []*string{
	// 									to.Ptr("20-30")},
	// 							}},
	// 					}},
	// 					MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
	// 						{
	// 							Actions: []*armmanagednetworkfabric.AccessControlListAction{
	// 								{
	// 									Type: to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
	// 									CounterName: to.Ptr("example-counter"),
	// 							}},
	// 							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 							MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
	// 								{
	// 									IPCondition: &armmanagednetworkfabric.IPMatchCondition{
	// 										Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
	// 										IPGroupNames: []*string{
	// 											to.Ptr("example-ipGroup")},
	// 											IPPrefixValues: []*string{
	// 												to.Ptr("10.20.20.20/12")},
	// 												PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
	// 											},
	// 											ProtocolTypes: []*string{
	// 												to.Ptr("TCP")},
	// 												VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
	// 													InnerVlans: []*string{
	// 														to.Ptr("30")},
	// 														VlanGroupNames: []*string{
	// 															to.Ptr("example-vlanGroup")},
	// 															Vlans: []*string{
	// 																to.Ptr("20-30")},
	// 															},
	// 															DscpMarkings: []*string{
	// 																to.Ptr("32")},
	// 																EtherTypes: []*string{
	// 																	to.Ptr("0x1")},
	// 																	Fragments: []*string{
	// 																		to.Ptr("0xff00-0xffff")},
	// 																		IPLengths: []*string{
	// 																			to.Ptr("4094-9214")},
	// 																			PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
	// 																				Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
	// 																				PortGroupNames: []*string{
	// 																					to.Ptr("example-portGroup")},
	// 																					PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
	// 																					Ports: []*string{
	// 																						to.Ptr("1-20")},
	// 																						Flags: []*string{
	// 																							to.Ptr("established")},
	// 																						},
	// 																						TTLValues: []*string{
	// 																							to.Ptr("23")},
	// 																					}},
	// 																					MatchConfigurationName: to.Ptr("example-match"),
	// 																					SequenceNumber: to.Ptr[int64](123),
	// 																			}},
	// 																			Annotation: to.Ptr("annotation"),
	// 																			AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 																			ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 																			LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-17T08:56:23.203Z"); return t}()),
	// 																			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 																		},
	// 																	}
}

Output:

func (*AccessControlListsClient) BeginUpdateAdministrativeState 

func (client *AccessControlListsClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, accessControlListName string, body UpdateAdministrativeState, options *AccessControlListsClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[AccessControlListsClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • body - Request payload.
  • options - AccessControlListsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the AccessControlListsClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlListsClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-acl", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*AccessControlListsClient) BeginValidateConfiguration 

func (client *AccessControlListsClient) BeginValidateConfiguration(ctx context.Context, resourceGroupName string, accessControlListName string, options *AccessControlListsClientBeginValidateConfigurationOptions) (*runtime.Poller[AccessControlListsClientValidateConfigurationResponse], error)

BeginValidateConfiguration - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • options - AccessControlListsClientBeginValidateConfigurationOptions contains the optional parameters for the AccessControlListsClient.BeginValidateConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_ValidateConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlListsClient().BeginValidateConfiguration(ctx, "example-rg", "example-acl", 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ActionDetails"),
	// }
}

Output:

func (*AccessControlListsClient) Get 

func (client *AccessControlListsClient) Get(ctx context.Context, resourceGroupName string, accessControlListName string, options *AccessControlListsClientGetOptions) (AccessControlListsClientGetResponse, error)

Get - Implements Access Control List GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accessControlListName - Name of the Access Control List.
  • options - AccessControlListsClientGetOptions contains the optional parameters for the AccessControlListsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessControlListsClient().Get(ctx, "example-rg", "example-acl", 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.AccessControlList = armmanagednetworkfabric.AccessControlList{
	// 	Name: to.Ptr("example-acl"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/accessControlLists"),
	// 	ID: to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastUs"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.AccessControlListProperties{
	// 		ACLsURL: to.Ptr("https://ACL-Storage-URL"),
	// 		ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
	// 		DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
	// 			{
	// 				IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
	// 					{
	// 						Name: to.Ptr("example-ipGroup"),
	// 						IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 						IPPrefixes: []*string{
	// 							to.Ptr("10.20.3.1/20")},
	// 					}},
	// 					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
	// 						{
	// 							Name: to.Ptr("example-portGroup"),
	// 							Ports: []*string{
	// 								to.Ptr("100-200")},
	// 						}},
	// 						VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
	// 							{
	// 								Name: to.Ptr("example-vlanGroup"),
	// 								Vlans: []*string{
	// 									to.Ptr("20-30")},
	// 							}},
	// 					}},
	// 					MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
	// 						{
	// 							Actions: []*armmanagednetworkfabric.AccessControlListAction{
	// 								{
	// 									Type: to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
	// 									CounterName: to.Ptr("example-counter"),
	// 							}},
	// 							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 							MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
	// 								{
	// 									IPCondition: &armmanagednetworkfabric.IPMatchCondition{
	// 										Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
	// 										IPGroupNames: []*string{
	// 											to.Ptr("example-ipGroup")},
	// 											IPPrefixValues: []*string{
	// 												to.Ptr("10.20.20.20/12")},
	// 												PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
	// 											},
	// 											ProtocolTypes: []*string{
	// 												to.Ptr("TCP")},
	// 												VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
	// 													InnerVlans: []*string{
	// 														to.Ptr("30")},
	// 														VlanGroupNames: []*string{
	// 															to.Ptr("example-vlanGroup")},
	// 															Vlans: []*string{
	// 																to.Ptr("20-30")},
	// 															},
	// 															DscpMarkings: []*string{
	// 																to.Ptr("32")},
	// 																EtherTypes: []*string{
	// 																	to.Ptr("0x1")},
	// 																	Fragments: []*string{
	// 																		to.Ptr("0xff00-0xffff")},
	// 																		IPLengths: []*string{
	// 																			to.Ptr("4094-9214")},
	// 																			PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
	// 																				Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
	// 																				PortGroupNames: []*string{
	// 																					to.Ptr("example-portGroup")},
	// 																					PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
	// 																					Ports: []*string{
	// 																						to.Ptr("1-20")},
	// 																						Flags: []*string{
	// 																							to.Ptr("established")},
	// 																						},
	// 																						TTLValues: []*string{
	// 																							to.Ptr("23")},
	// 																					}},
	// 																					MatchConfigurationName: to.Ptr("example-match"),
	// 																					SequenceNumber: to.Ptr[int64](123),
	// 																			}},
	// 																			Annotation: to.Ptr("annotation"),
	// 																			AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 																			ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 																			LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-17T08:56:23.203Z"); return t}()),
	// 																			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 																		},
	// 																	}
}

Output:

func (*AccessControlListsClient) NewListByResourceGroupPager 

func (client *AccessControlListsClient) NewListByResourceGroupPager(resourceGroupName string, options *AccessControlListsClientListByResourceGroupOptions) *runtime.Pager[AccessControlListsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Implements AccessControlLists list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - AccessControlListsClientListByResourceGroupOptions contains the optional parameters for the AccessControlListsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccessControlListsClient().NewListByResourceGroupPager("example-rg", 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.AccessControlListsListResult = armmanagednetworkfabric.AccessControlListsListResult{
		// 	Value: []*armmanagednetworkfabric.AccessControlList{
		// 		{
		// 			Name: to.Ptr("example-acl"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/accessControlLists"),
		// 			ID: to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("UserId"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastUs"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.AccessControlListProperties{
		// 				ACLsURL: to.Ptr("https://ACL-Storage-URL"),
		// 				ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
		// 				DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
		// 					{
		// 						IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
		// 							{
		// 								Name: to.Ptr("example-ipGroup"),
		// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 								IPPrefixes: []*string{
		// 									to.Ptr("10.20.3.1/20")},
		// 							}},
		// 							PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
		// 								{
		// 									Name: to.Ptr("example-portGroup"),
		// 									Ports: []*string{
		// 										to.Ptr("100-200")},
		// 								}},
		// 								VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
		// 									{
		// 										Name: to.Ptr("example-vlanGroup"),
		// 										Vlans: []*string{
		// 											to.Ptr("20-30")},
		// 									}},
		// 							}},
		// 							MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
		// 								{
		// 									Actions: []*armmanagednetworkfabric.AccessControlListAction{
		// 										{
		// 											Type: to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
		// 											CounterName: to.Ptr("example-counter"),
		// 									}},
		// 									IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 									MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
		// 										{
		// 											IPCondition: &armmanagednetworkfabric.IPMatchCondition{
		// 												Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
		// 												IPGroupNames: []*string{
		// 													to.Ptr("example-ipGroup")},
		// 													IPPrefixValues: []*string{
		// 														to.Ptr("10.20.20.20/12")},
		// 														PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
		// 													},
		// 													ProtocolTypes: []*string{
		// 														to.Ptr("TCP")},
		// 														VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
		// 															InnerVlans: []*string{
		// 																to.Ptr("30")},
		// 																VlanGroupNames: []*string{
		// 																	to.Ptr("example-vlanGroup")},
		// 																	Vlans: []*string{
		// 																		to.Ptr("20-30")},
		// 																	},
		// 																	DscpMarkings: []*string{
		// 																		to.Ptr("32")},
		// 																		EtherTypes: []*string{
		// 																			to.Ptr("0x1")},
		// 																			Fragments: []*string{
		// 																				to.Ptr("0xff00-0xffff")},
		// 																				IPLengths: []*string{
		// 																					to.Ptr("4094-9214")},
		// 																					PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
		// 																						Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
		// 																						PortGroupNames: []*string{
		// 																							to.Ptr("example-portGroup")},
		// 																							PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
		// 																							Ports: []*string{
		// 																								to.Ptr("1-20")},
		// 																								Flags: []*string{
		// 																									to.Ptr("established")},
		// 																								},
		// 																								TTLValues: []*string{
		// 																									to.Ptr("23")},
		// 																							}},
		// 																							MatchConfigurationName: to.Ptr("example-match"),
		// 																							SequenceNumber: to.Ptr[int64](123),
		// 																					}},
		// 																					Annotation: to.Ptr("annotation"),
		// 																					AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 																					ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 																					LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-17T08:56:23.203Z"); return t}()),
		// 																					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 																				},
		// 																		}},
		// 																	}
	}
}

Output:

func (*AccessControlListsClient) NewListBySubscriptionPager 

func (client *AccessControlListsClient) NewListBySubscriptionPager(options *AccessControlListsClientListBySubscriptionOptions) *runtime.Pager[AccessControlListsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Implements AccessControlLists list by subscription GET method.

Generated from API version 2023-06-15

  • options - AccessControlListsClientListBySubscriptionOptions contains the optional parameters for the AccessControlListsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/AccessControlLists_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccessControlListsClient().NewListBySubscriptionPager(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.AccessControlListsListResult = armmanagednetworkfabric.AccessControlListsListResult{
		// 	Value: []*armmanagednetworkfabric.AccessControlList{
		// 		{
		// 			Name: to.Ptr("example-acl"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/accessControlLists"),
		// 			ID: to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("UserId"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastUs"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.AccessControlListProperties{
		// 				ACLsURL: to.Ptr("https://ACL-Storage-URL"),
		// 				ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
		// 				DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
		// 					{
		// 						IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
		// 							{
		// 								Name: to.Ptr("example-ipGroup"),
		// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 								IPPrefixes: []*string{
		// 									to.Ptr("10.20.3.1/20")},
		// 							}},
		// 							PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
		// 								{
		// 									Name: to.Ptr("example-portGroup"),
		// 									Ports: []*string{
		// 										to.Ptr("100-200")},
		// 								}},
		// 								VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
		// 									{
		// 										Name: to.Ptr("example-vlanGroup"),
		// 										Vlans: []*string{
		// 											to.Ptr("20-30")},
		// 									}},
		// 							}},
		// 							MatchConfigurations: []*armmanagednetworkfabric.AccessControlListMatchConfiguration{
		// 								{
		// 									Actions: []*armmanagednetworkfabric.AccessControlListAction{
		// 										{
		// 											Type: to.Ptr(armmanagednetworkfabric.ACLActionTypeCount),
		// 											CounterName: to.Ptr("example-counter"),
		// 									}},
		// 									IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 									MatchConditions: []*armmanagednetworkfabric.AccessControlListMatchCondition{
		// 										{
		// 											IPCondition: &armmanagednetworkfabric.IPMatchCondition{
		// 												Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
		// 												IPGroupNames: []*string{
		// 													to.Ptr("example-ipGroup")},
		// 													IPPrefixValues: []*string{
		// 														to.Ptr("10.20.20.20/12")},
		// 														PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
		// 													},
		// 													ProtocolTypes: []*string{
		// 														to.Ptr("TCP")},
		// 														VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
		// 															InnerVlans: []*string{
		// 																to.Ptr("30")},
		// 																VlanGroupNames: []*string{
		// 																	to.Ptr("example-vlanGroup")},
		// 																	Vlans: []*string{
		// 																		to.Ptr("20-30")},
		// 																	},
		// 																	DscpMarkings: []*string{
		// 																		to.Ptr("32")},
		// 																		EtherTypes: []*string{
		// 																			to.Ptr("0x1")},
		// 																			Fragments: []*string{
		// 																				to.Ptr("0xff00-0xffff")},
		// 																				IPLengths: []*string{
		// 																					to.Ptr("4094-9214")},
		// 																					PortCondition: &armmanagednetworkfabric.AccessControlListPortCondition{
		// 																						Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
		// 																						PortGroupNames: []*string{
		// 																							to.Ptr("example-portGroup")},
		// 																							PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
		// 																							Ports: []*string{
		// 																								to.Ptr("1-20")},
		// 																								Flags: []*string{
		// 																									to.Ptr("established")},
		// 																								},
		// 																								TTLValues: []*string{
		// 																									to.Ptr("23")},
		// 																							}},
		// 																							MatchConfigurationName: to.Ptr("example-match"),
		// 																							SequenceNumber: to.Ptr[int64](123),
		// 																					}},
		// 																					Annotation: to.Ptr("annotation"),
		// 																					AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 																					ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 																					LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-17T08:56:23.203Z"); return t}()),
		// 																					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 																				},
		// 																		}},
		// 																	}
	}
}

Output:

type AccessControlListsClientBeginCreateOptions 

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

AccessControlListsClientBeginCreateOptions contains the optional parameters for the AccessControlListsClient.BeginCreate method.

type AccessControlListsClientBeginDeleteOptions 

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

AccessControlListsClientBeginDeleteOptions contains the optional parameters for the AccessControlListsClient.BeginDelete method.

type AccessControlListsClientBeginResyncOptions 

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

AccessControlListsClientBeginResyncOptions contains the optional parameters for the AccessControlListsClient.BeginResync method.

type AccessControlListsClientBeginUpdateAdministrativeStateOptions 

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

AccessControlListsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the AccessControlListsClient.BeginUpdateAdministrativeState method.

type AccessControlListsClientBeginUpdateOptions 

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

AccessControlListsClientBeginUpdateOptions contains the optional parameters for the AccessControlListsClient.BeginUpdate method.

type AccessControlListsClientBeginValidateConfigurationOptions 

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

AccessControlListsClientBeginValidateConfigurationOptions contains the optional parameters for the AccessControlListsClient.BeginValidateConfiguration method.

type AccessControlListsClientCreateResponse 

type AccessControlListsClientCreateResponse struct {
	// The Access Control List resource definition.
	AccessControlList
}

AccessControlListsClientCreateResponse contains the response from method AccessControlListsClient.BeginCreate.

type AccessControlListsClientDeleteResponse 

type AccessControlListsClientDeleteResponse struct {
}

AccessControlListsClientDeleteResponse contains the response from method AccessControlListsClient.BeginDelete.

type AccessControlListsClientGetOptions 

type AccessControlListsClientGetOptions struct {
}

AccessControlListsClientGetOptions contains the optional parameters for the AccessControlListsClient.Get method.

type AccessControlListsClientGetResponse 

type AccessControlListsClientGetResponse struct {
	// The Access Control List resource definition.
	AccessControlList
}

AccessControlListsClientGetResponse contains the response from method AccessControlListsClient.Get.

type AccessControlListsClientListByResourceGroupOptions 

type AccessControlListsClientListByResourceGroupOptions struct {
}

AccessControlListsClientListByResourceGroupOptions contains the optional parameters for the AccessControlListsClient.NewListByResourceGroupPager method.

type AccessControlListsClientListByResourceGroupResponse 

type AccessControlListsClientListByResourceGroupResponse struct {
	// List of Access Control Lists.
	AccessControlListsListResult
}

AccessControlListsClientListByResourceGroupResponse contains the response from method AccessControlListsClient.NewListByResourceGroupPager.

type AccessControlListsClientListBySubscriptionOptions 

type AccessControlListsClientListBySubscriptionOptions struct {
}

AccessControlListsClientListBySubscriptionOptions contains the optional parameters for the AccessControlListsClient.NewListBySubscriptionPager method.

type AccessControlListsClientListBySubscriptionResponse 

type AccessControlListsClientListBySubscriptionResponse struct {
	// List of Access Control Lists.
	AccessControlListsListResult
}

AccessControlListsClientListBySubscriptionResponse contains the response from method AccessControlListsClient.NewListBySubscriptionPager.

type AccessControlListsClientResyncResponse 

type AccessControlListsClientResyncResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

AccessControlListsClientResyncResponse contains the response from method AccessControlListsClient.BeginResync.

type AccessControlListsClientUpdateAdministrativeStateResponse 

type AccessControlListsClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

AccessControlListsClientUpdateAdministrativeStateResponse contains the response from method AccessControlListsClient.BeginUpdateAdministrativeState.

type AccessControlListsClientUpdateResponse 

type AccessControlListsClientUpdateResponse struct {
	// The Access Control List resource definition.
	AccessControlList
}

AccessControlListsClientUpdateResponse contains the response from method AccessControlListsClient.BeginUpdate.

type AccessControlListsClientValidateConfigurationResponse 

type AccessControlListsClientValidateConfigurationResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

AccessControlListsClientValidateConfigurationResponse contains the response from method AccessControlListsClient.BeginValidateConfiguration.

type AccessControlListsListResult 

type AccessControlListsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Access Control List resources.
	Value []*AccessControlList
}

AccessControlListsListResult - List of Access Control Lists.

func (AccessControlListsListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlListsListResult.

func (*AccessControlListsListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlListsListResult.

type Action 

type Action string

Action - Specify action. 

const (
	ActionAllow Action = "Allow"
	ActionDeny  Action = "Deny"
)

func PossibleActionValues 

func PossibleActionValues() []Action

PossibleActionValues returns the possible values for the Action const type.

type ActionIPCommunityProperties 

type ActionIPCommunityProperties struct {
	// List of IP Community IDs.
	Add *IPCommunityIDList

	// List of IP Community IDs.
	Delete *IPCommunityIDList

	// List of IP Community IDs.
	Set *IPCommunityIDList
}

ActionIPCommunityProperties - IP Community Properties.

func (ActionIPCommunityProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ActionIPCommunityProperties.

func (*ActionIPCommunityProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ActionIPCommunityProperties.

type ActionIPExtendedCommunityProperties 

type ActionIPExtendedCommunityProperties struct {
	// List of IP Extended Community IDs.
	Add *IPExtendedCommunityIDList

	// List of IP Extended Community IDs.
	Delete *IPExtendedCommunityIDList

	// List of IP Extended Community IDs.
	Set *IPExtendedCommunityIDList
}

ActionIPExtendedCommunityProperties - IP Extended Community Properties.

func (ActionIPExtendedCommunityProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ActionIPExtendedCommunityProperties.

func (*ActionIPExtendedCommunityProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ActionIPExtendedCommunityProperties.

type ActionType 

type ActionType string

ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type AddressFamilyType 

type AddressFamilyType string

AddressFamilyType - AddressFamilyType. This parameter decides whether the given ipv4 or ipv6 route policy. 

const (
	AddressFamilyTypeIPv4 AddressFamilyType = "IPv4"
	AddressFamilyTypeIPv6 AddressFamilyType = "IPv6"
)

func PossibleAddressFamilyTypeValues 

func PossibleAddressFamilyTypeValues() []AddressFamilyType

PossibleAddressFamilyTypeValues returns the possible values for the AddressFamilyType const type.

type AdministrativeState 

type AdministrativeState string

AdministrativeState - State defined to represent administrative actions or post actions on a particular resource. 

const (
	AdministrativeStateDisabled AdministrativeState = "Disabled"
	AdministrativeStateEnabled  AdministrativeState = "Enabled"
	AdministrativeStateMAT      AdministrativeState = "MAT"
	AdministrativeStateRMA      AdministrativeState = "RMA"
)

func PossibleAdministrativeStateValues 

func PossibleAdministrativeStateValues() []AdministrativeState

PossibleAdministrativeStateValues returns the possible values for the AdministrativeState const type.

type AggregateRoute 

type AggregateRoute struct {
	// REQUIRED; IPv4 Prefix of the aggregate Ipv4Route.
	Prefix *string
}

AggregateRoute - aggregateIpv4Route model.

func (AggregateRoute) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AggregateRoute.

func (*AggregateRoute) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AggregateRoute.

type AggregateRouteConfiguration 

type AggregateRouteConfiguration struct {
	// List of IPv4 Route prefixes.
	IPv4Routes []*AggregateRoute

	// List of Ipv6Routes prefixes.
	IPv6Routes []*AggregateRoute
}

AggregateRouteConfiguration - List of IPv4 and IPv6 aggregate routes.

func (AggregateRouteConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AggregateRouteConfiguration.

func (*AggregateRouteConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AggregateRouteConfiguration.

type AllowASOverride 

type AllowASOverride string

AllowASOverride - Enable Or Disable state. 

const (
	AllowASOverrideDisable AllowASOverride = "Disable"
	AllowASOverrideEnable  AllowASOverride = "Enable"
)

func PossibleAllowASOverrideValues 

func PossibleAllowASOverrideValues() []AllowASOverride

PossibleAllowASOverrideValues returns the possible values for the AllowASOverride const type.

type BfdAdministrativeState 

type BfdAdministrativeState string

BfdAdministrativeState - Administrative state of the BfdConfiguration. Example: Enabled | Disabled. 

const (
	BfdAdministrativeStateDisabled BfdAdministrativeState = "Disabled"
	BfdAdministrativeStateEnabled  BfdAdministrativeState = "Enabled"
	BfdAdministrativeStateMAT      BfdAdministrativeState = "MAT"
	BfdAdministrativeStateRMA      BfdAdministrativeState = "RMA"
)

func PossibleBfdAdministrativeStateValues 

func PossibleBfdAdministrativeStateValues() []BfdAdministrativeState

PossibleBfdAdministrativeStateValues returns the possible values for the BfdAdministrativeState const type.

type BfdConfiguration 

type BfdConfiguration struct {
	// Interval in milliseconds. Example: 300.
	IntervalInMilliSeconds *int32

	// Multiplier for the Bfd Configuration. Example: 5.
	Multiplier *int32

	// READ-ONLY; Administrative state of the BfdConfiguration. Example: Enabled | Disabled.
	AdministrativeState *BfdAdministrativeState
}

BfdConfiguration - BFD configuration properties

func (BfdConfiguration) MarshalJSON 

func (b BfdConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BfdConfiguration.

func (*BfdConfiguration) UnmarshalJSON 

func (b *BfdConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BfdConfiguration.

type BgpConfiguration 

type BgpConfiguration struct {
	// Allows for routes to be received and processed even if the router detects its own ASN in the AS-Path. 0 is disable, Possible
	// values are 1-10, default is 2.
	AllowAS *int32

	// Enable Or Disable state.
	AllowASOverride *AllowASOverride

	// Switch configuration description.
	Annotation *string

	// BFD configuration properties
	BfdConfiguration *BfdConfiguration

	// Originate a defaultRoute. Ex: "True" | "False".
	DefaultRouteOriginate *BooleanEnumProperty

	// List of BGP IPv4 Listen Range prefixes.
	IPv4ListenRangePrefixes []*string

	// List with stringified IPv4 Neighbor Addresses.
	IPv4NeighborAddress []*NeighborAddress

	// List of BGP IPv6 Listen Ranges prefixes.
	IPv6ListenRangePrefixes []*string

	// List with stringified IPv6 Neighbor Address.
	IPv6NeighborAddress []*NeighborAddress

	// Peer ASN. Example: 65047.
	PeerASN *int64

	// READ-ONLY; ASN of Network Fabric. Example: 65048.
	FabricASN *int64
}

BgpConfiguration - BGP configuration properties

func (BgpConfiguration) MarshalJSON 

func (b BgpConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BgpConfiguration.

func (*BgpConfiguration) UnmarshalJSON 

func (b *BgpConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BgpConfiguration.

type BooleanEnumProperty 

type BooleanEnumProperty string

BooleanEnumProperty - Boolean Enum. Example- True/False 

const (
	BooleanEnumPropertyFalse BooleanEnumProperty = "False"
	BooleanEnumPropertyTrue  BooleanEnumProperty = "True"
)

func PossibleBooleanEnumPropertyValues 

func PossibleBooleanEnumPropertyValues() []BooleanEnumProperty

PossibleBooleanEnumPropertyValues returns the possible values for the BooleanEnumProperty 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 ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAccessControlListsClient 

func (c *ClientFactory) NewAccessControlListsClient() *AccessControlListsClient

NewAccessControlListsClient creates a new instance of AccessControlListsClient.

func (*ClientFactory) NewExternalNetworksClient 

func (c *ClientFactory) NewExternalNetworksClient() *ExternalNetworksClient

NewExternalNetworksClient creates a new instance of ExternalNetworksClient.

func (*ClientFactory) NewIPCommunitiesClient 

func (c *ClientFactory) NewIPCommunitiesClient() *IPCommunitiesClient

NewIPCommunitiesClient creates a new instance of IPCommunitiesClient.

func (*ClientFactory) NewIPExtendedCommunitiesClient 

func (c *ClientFactory) NewIPExtendedCommunitiesClient() *IPExtendedCommunitiesClient

NewIPExtendedCommunitiesClient creates a new instance of IPExtendedCommunitiesClient.

func (*ClientFactory) NewIPPrefixesClient 

func (c *ClientFactory) NewIPPrefixesClient() *IPPrefixesClient

NewIPPrefixesClient creates a new instance of IPPrefixesClient.

func (*ClientFactory) NewInternalNetworksClient 

func (c *ClientFactory) NewInternalNetworksClient() *InternalNetworksClient

NewInternalNetworksClient creates a new instance of InternalNetworksClient.

func (*ClientFactory) NewInternetGatewayRulesClient 

func (c *ClientFactory) NewInternetGatewayRulesClient() *InternetGatewayRulesClient

NewInternetGatewayRulesClient creates a new instance of InternetGatewayRulesClient.

func (*ClientFactory) NewInternetGatewaysClient 

func (c *ClientFactory) NewInternetGatewaysClient() *InternetGatewaysClient

NewInternetGatewaysClient creates a new instance of InternetGatewaysClient.

func (*ClientFactory) NewL2IsolationDomainsClient 

func (c *ClientFactory) NewL2IsolationDomainsClient() *L2IsolationDomainsClient

NewL2IsolationDomainsClient creates a new instance of L2IsolationDomainsClient.

func (*ClientFactory) NewL3IsolationDomainsClient 

func (c *ClientFactory) NewL3IsolationDomainsClient() *L3IsolationDomainsClient

NewL3IsolationDomainsClient creates a new instance of L3IsolationDomainsClient.

func (*ClientFactory) NewNeighborGroupsClient 

func (c *ClientFactory) NewNeighborGroupsClient() *NeighborGroupsClient

NewNeighborGroupsClient creates a new instance of NeighborGroupsClient.

func (*ClientFactory) NewNetworkDeviceSKUsClient 

func (c *ClientFactory) NewNetworkDeviceSKUsClient() *NetworkDeviceSKUsClient

NewNetworkDeviceSKUsClient creates a new instance of NetworkDeviceSKUsClient.

func (*ClientFactory) NewNetworkDevicesClient 

func (c *ClientFactory) NewNetworkDevicesClient() *NetworkDevicesClient

NewNetworkDevicesClient creates a new instance of NetworkDevicesClient.

func (*ClientFactory) NewNetworkFabricControllersClient 

func (c *ClientFactory) NewNetworkFabricControllersClient() *NetworkFabricControllersClient

NewNetworkFabricControllersClient creates a new instance of NetworkFabricControllersClient.

func (*ClientFactory) NewNetworkFabricSKUsClient 

func (c *ClientFactory) NewNetworkFabricSKUsClient() *NetworkFabricSKUsClient

NewNetworkFabricSKUsClient creates a new instance of NetworkFabricSKUsClient.

func (*ClientFactory) NewNetworkFabricsClient 

func (c *ClientFactory) NewNetworkFabricsClient() *NetworkFabricsClient

NewNetworkFabricsClient creates a new instance of NetworkFabricsClient.

func (*ClientFactory) NewNetworkInterfacesClient 

func (c *ClientFactory) NewNetworkInterfacesClient() *NetworkInterfacesClient

NewNetworkInterfacesClient creates a new instance of NetworkInterfacesClient.

func (*ClientFactory) NewNetworkPacketBrokersClient 

func (c *ClientFactory) NewNetworkPacketBrokersClient() *NetworkPacketBrokersClient

NewNetworkPacketBrokersClient creates a new instance of NetworkPacketBrokersClient.

func (*ClientFactory) NewNetworkRacksClient 

func (c *ClientFactory) NewNetworkRacksClient() *NetworkRacksClient

NewNetworkRacksClient creates a new instance of NetworkRacksClient.

func (*ClientFactory) NewNetworkTapRulesClient 

func (c *ClientFactory) NewNetworkTapRulesClient() *NetworkTapRulesClient

NewNetworkTapRulesClient creates a new instance of NetworkTapRulesClient.

func (*ClientFactory) NewNetworkTapsClient 

func (c *ClientFactory) NewNetworkTapsClient() *NetworkTapsClient

NewNetworkTapsClient creates a new instance of NetworkTapsClient.

func (*ClientFactory) NewNetworkToNetworkInterconnectsClient 

func (c *ClientFactory) NewNetworkToNetworkInterconnectsClient() *NetworkToNetworkInterconnectsClient

NewNetworkToNetworkInterconnectsClient creates a new instance of NetworkToNetworkInterconnectsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewRoutePoliciesClient 

func (c *ClientFactory) NewRoutePoliciesClient() *RoutePoliciesClient

NewRoutePoliciesClient creates a new instance of RoutePoliciesClient.

type CommonDynamicMatchConfiguration 

type CommonDynamicMatchConfiguration struct {
	// List of IP Groups.
	IPGroups []*IPGroupProperties

	// List of the port group.
	PortGroups []*PortGroupProperties

	// List of vlan groups.
	VlanGroups []*VlanGroupProperties
}

CommonDynamicMatchConfiguration - Dynamic match configuration object.

func (CommonDynamicMatchConfiguration) MarshalJSON 

func (c CommonDynamicMatchConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CommonDynamicMatchConfiguration.

func (*CommonDynamicMatchConfiguration) UnmarshalJSON 

func (c *CommonDynamicMatchConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CommonDynamicMatchConfiguration.

type CommonPostActionResponseForDeviceUpdate 

type CommonPostActionResponseForDeviceUpdate struct {
	// The error object.
	Error *ErrorDetail

	// List of ARM Resource IDs for which the given action failed to apply.
	FailedDevices []*string

	// List of ARM Resource IDs for which the given action applied successfully.
	SuccessfulDevices []*string

	// READ-ONLY; Gets the configuration state.
	ConfigurationState *ConfigurationState
}

CommonPostActionResponseForDeviceUpdate - Common response for device updates.

func (CommonPostActionResponseForDeviceUpdate) MarshalJSON 

func (c CommonPostActionResponseForDeviceUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CommonPostActionResponseForDeviceUpdate.

func (*CommonPostActionResponseForDeviceUpdate) UnmarshalJSON 

func (c *CommonPostActionResponseForDeviceUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CommonPostActionResponseForDeviceUpdate.

type CommonPostActionResponseForStateUpdate 

type CommonPostActionResponseForStateUpdate struct {
	// The error object.
	Error *ErrorDetail

	// READ-ONLY; Gets the configuration state.
	ConfigurationState *ConfigurationState
}

CommonPostActionResponseForStateUpdate - Common response for the state updates.

func (CommonPostActionResponseForStateUpdate) MarshalJSON 

func (c CommonPostActionResponseForStateUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CommonPostActionResponseForStateUpdate.

func (*CommonPostActionResponseForStateUpdate) UnmarshalJSON 

func (c *CommonPostActionResponseForStateUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CommonPostActionResponseForStateUpdate.

type CommunityActionTypes 

type CommunityActionTypes string

CommunityActionTypes - community action types. Example: Permit | Deny. 

const (
	CommunityActionTypesDeny   CommunityActionTypes = "Deny"
	CommunityActionTypesPermit CommunityActionTypes = "Permit"
)

func PossibleCommunityActionTypesValues 

func PossibleCommunityActionTypesValues() []CommunityActionTypes

PossibleCommunityActionTypesValues returns the possible values for the CommunityActionTypes const type.

type Condition 

type Condition string

Condition - Specify prefix-list bounds. 

const (
	ConditionEqualTo              Condition = "EqualTo"
	ConditionGreaterThanOrEqualTo Condition = "GreaterThanOrEqualTo"
	ConditionLesserThanOrEqualTo  Condition = "LesserThanOrEqualTo"
	ConditionRange                Condition = "Range"
)

func PossibleConditionValues 

func PossibleConditionValues() []Condition

PossibleConditionValues returns the possible values for the Condition const type.

type ConfigurationState 

type ConfigurationState string

ConfigurationState - Configuration state for the resource. 

const (
	ConfigurationStateAccepted            ConfigurationState = "Accepted"
	ConfigurationStateDeferredControl     ConfigurationState = "DeferredControl"
	ConfigurationStateDeprovisioned       ConfigurationState = "Deprovisioned"
	ConfigurationStateDeprovisioning      ConfigurationState = "Deprovisioning"
	ConfigurationStateErrorDeprovisioning ConfigurationState = "ErrorDeprovisioning"
	ConfigurationStateErrorProvisioning   ConfigurationState = "ErrorProvisioning"
	ConfigurationStateFailed              ConfigurationState = "Failed"
	ConfigurationStateProvisioned         ConfigurationState = "Provisioned"
	ConfigurationStateRejected            ConfigurationState = "Rejected"
	ConfigurationStateSucceeded           ConfigurationState = "Succeeded"
)

func PossibleConfigurationStateValues 

func PossibleConfigurationStateValues() []ConfigurationState

PossibleConfigurationStateValues returns the possible values for the ConfigurationState const type.

type ConfigurationType 

type ConfigurationType string

ConfigurationType - Input method to configure Access Control List. 

const (
	ConfigurationTypeFile   ConfigurationType = "File"
	ConfigurationTypeInline ConfigurationType = "Inline"
)

func PossibleConfigurationTypeValues 

func PossibleConfigurationTypeValues() []ConfigurationType

PossibleConfigurationTypeValues returns the possible values for the ConfigurationType const type.

type ConnectedSubnet 

type ConnectedSubnet struct {
	// REQUIRED; Prefix of the Connected Subnet.
	Prefix *string

	// Switch configuration description.
	Annotation *string
}

ConnectedSubnet - Connected Subnet properties.

func (ConnectedSubnet) MarshalJSON 

func (c ConnectedSubnet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectedSubnet.

func (*ConnectedSubnet) UnmarshalJSON 

func (c *ConnectedSubnet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectedSubnet.

type ConnectedSubnetRoutePolicy 

type ConnectedSubnetRoutePolicy struct {
	// Array of ARM Resource ID of the RoutePolicies.
	ExportRoutePolicy *L3ExportRoutePolicy

	// ARM Resource ID of the Route Policy. This is used for the backward compatibility.
	ExportRoutePolicyID *string
}

ConnectedSubnetRoutePolicy - Connected Subnet Route Policy properties.

func (ConnectedSubnetRoutePolicy) MarshalJSON 

func (c ConnectedSubnetRoutePolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConnectedSubnetRoutePolicy.

func (*ConnectedSubnetRoutePolicy) UnmarshalJSON 

func (c *ConnectedSubnetRoutePolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectedSubnetRoutePolicy.

type ControllerServices 

type ControllerServices struct {
	// The IPv4 Address space is optional, if the value is not defined at the time of NFC creation, then the default value 10.0.0.0/19
	// is considered. The IPV4 address subnet is an optional attribute.
	IPv4AddressSpaces []*string

	// The IPv6 is not supported right now.
	IPv6AddressSpaces []*string
}

ControllerServices - Network Fabric Controller services.

func (ControllerServices) MarshalJSON 

func (c ControllerServices) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ControllerServices.

func (*ControllerServices) UnmarshalJSON 

func (c *ControllerServices) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ControllerServices.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DestinationType 

type DestinationType string

DestinationType - Type of destination. Input can be IsolationDomain or Direct. 

const (
	DestinationTypeDirect          DestinationType = "Direct"
	DestinationTypeIsolationDomain DestinationType = "IsolationDomain"
)

func PossibleDestinationTypeValues 

func PossibleDestinationTypeValues() []DestinationType

PossibleDestinationTypeValues returns the possible values for the DestinationType const type.

type DeviceAdministrativeState 

type DeviceAdministrativeState string

DeviceAdministrativeState - Administrative state. 

const (
	DeviceAdministrativeStateGracefulQuarantine DeviceAdministrativeState = "GracefulQuarantine"
	DeviceAdministrativeStateQuarantine         DeviceAdministrativeState = "Quarantine"
	DeviceAdministrativeStateRMA                DeviceAdministrativeState = "RMA"
	DeviceAdministrativeStateResync             DeviceAdministrativeState = "Resync"
)

func PossibleDeviceAdministrativeStateValues 

func PossibleDeviceAdministrativeStateValues() []DeviceAdministrativeState

PossibleDeviceAdministrativeStateValues returns the possible values for the DeviceAdministrativeState const type.

type DeviceInterfaceProperties 

type DeviceInterfaceProperties struct {
	// Interface identifier. Example: HundredGigE0/0.
	Identifier *string

	// Interface type.
	InterfaceType *string

	// List of supported connector types.
	SupportedConnectorTypes []*SupportedConnectorProperties
}

DeviceInterfaceProperties - Network device interface properties.

func (DeviceInterfaceProperties) MarshalJSON 

func (d DeviceInterfaceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DeviceInterfaceProperties.

func (*DeviceInterfaceProperties) UnmarshalJSON 

func (d *DeviceInterfaceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DeviceInterfaceProperties.

type EnableDisableState 

type EnableDisableState string

EnableDisableState - Administrative state. 

const (
	EnableDisableStateDisable EnableDisableState = "Disable"
	EnableDisableStateEnable  EnableDisableState = "Enable"
)

func PossibleEnableDisableStateValues 

func PossibleEnableDisableStateValues() []EnableDisableState

PossibleEnableDisableStateValues returns the possible values for the EnableDisableState const type.

type Encapsulation 

type Encapsulation string

Encapsulation - Type of encapsulation. 

const (
	EncapsulationGRE  Encapsulation = "GRE"
	EncapsulationNone Encapsulation = "None"
)

func PossibleEncapsulationValues 

func PossibleEncapsulationValues() []Encapsulation

PossibleEncapsulationValues returns the possible values for the Encapsulation const type.

type EncapsulationType 

type EncapsulationType string

EncapsulationType - Encapsulation Type. 

const (
	EncapsulationTypeGTPv1 EncapsulationType = "GTPv1"
	EncapsulationTypeNone  EncapsulationType = "None"
)

func PossibleEncapsulationTypeValues 

func PossibleEncapsulationTypeValues() []EncapsulationType

PossibleEncapsulationTypeValues returns the possible values for the EncapsulationType const type.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any

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

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON 

func (e ErrorAdditionalInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON 

func (e *ErrorAdditionalInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

type ErrorDetail struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo

	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error details.
	Details []*ErrorDetail

	// READ-ONLY; The error message.
	Message *string

	// READ-ONLY; The error target.
	Target *string
}

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

func (e ErrorDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON 

func (e *ErrorDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type ExportRoutePolicy 

type ExportRoutePolicy struct {
	// ARM resource ID of RoutePolicy.
	ExportIPv4RoutePolicyID *string

	// ARM resource ID of RoutePolicy.
	ExportIPv6RoutePolicyID *string
}

ExportRoutePolicy - Export Route Policy either IPv4 or IPv6.

func (ExportRoutePolicy) MarshalJSON 

func (e ExportRoutePolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExportRoutePolicy.

func (*ExportRoutePolicy) UnmarshalJSON 

func (e *ExportRoutePolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExportRoutePolicy.

type ExportRoutePolicyInformation 

type ExportRoutePolicyInformation struct {
	// Export IPv4 Route Policy Id.
	ExportIPv4RoutePolicyID *string

	// Export IPv6 Route Policy Id.
	ExportIPv6RoutePolicyID *string
}

ExportRoutePolicyInformation - Export Route Policy Configuration.

func (ExportRoutePolicyInformation) MarshalJSON 

func (e ExportRoutePolicyInformation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExportRoutePolicyInformation.

func (*ExportRoutePolicyInformation) UnmarshalJSON 

func (e *ExportRoutePolicyInformation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExportRoutePolicyInformation.

type ExpressRouteConnectionInformation 

type ExpressRouteConnectionInformation struct {
	// REQUIRED; Authorization key for the circuit, must be of type Microsoft.Network/expressRouteCircuits/authorizations. The
	// Auth Key is a mandatory attribute.
	ExpressRouteAuthorizationKey *string

	// REQUIRED; The express route circuit Azure resource ID, must be of type Microsoft.Network/expressRouteCircuits/circuitName.
	// The ExpressRoute Circuit is a mandatory attribute.
	ExpressRouteCircuitID *string
}

ExpressRouteConnectionInformation - The ExpressRoute circuit ID and the Auth Key are required for you to successfully deploy NFC service.

func (ExpressRouteConnectionInformation) MarshalJSON 

func (e ExpressRouteConnectionInformation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExpressRouteConnectionInformation.

func (*ExpressRouteConnectionInformation) UnmarshalJSON 

func (e *ExpressRouteConnectionInformation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExpressRouteConnectionInformation.

type Extension 

type Extension string

Extension - Extension. Example: NoExtension | NPB. 

const (
	ExtensionNPB         Extension = "NPB"
	ExtensionNoExtension Extension = "NoExtension"
)

func PossibleExtensionValues 

func PossibleExtensionValues() []Extension

PossibleExtensionValues returns the possible values for the Extension const type.

type ExternalNetwork 

type ExternalNetwork struct {
	// REQUIRED; Resource properties.
	Properties *ExternalNetworkProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

ExternalNetwork - Defines the External Network resource.

func (ExternalNetwork) MarshalJSON 

func (e ExternalNetwork) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetwork.

func (*ExternalNetwork) UnmarshalJSON 

func (e *ExternalNetwork) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetwork.

type ExternalNetworkPatch 

type ExternalNetworkPatch struct {
	// External Network Patch properties.
	Properties *ExternalNetworkPatchProperties
}

ExternalNetworkPatch - The ExternalNetwork patch resource definition.

func (ExternalNetworkPatch) MarshalJSON 

func (e ExternalNetworkPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetworkPatch.

func (*ExternalNetworkPatch) UnmarshalJSON 

func (e *ExternalNetworkPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetworkPatch.

type ExternalNetworkPatchProperties 

type ExternalNetworkPatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// Export Route Policy either IPv4 or IPv6.
	ExportRoutePolicy *ExportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ExportRoutePolicyID *string

	// Import Route Policy either IPv4 or IPv6.
	ImportRoutePolicy *ImportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ImportRoutePolicyID *string

	// option A properties object
	OptionAProperties *ExternalNetworkPatchPropertiesOptionAProperties

	// option B properties object
	OptionBProperties *L3OptionBProperties

	// Peering option list.
	PeeringOption *PeeringOption
}

ExternalNetworkPatchProperties - External Network Patch properties.

func (ExternalNetworkPatchProperties) MarshalJSON 

func (e ExternalNetworkPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetworkPatchProperties.

func (*ExternalNetworkPatchProperties) UnmarshalJSON 

func (e *ExternalNetworkPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetworkPatchProperties.

type ExternalNetworkPatchPropertiesOptionAProperties 

type ExternalNetworkPatchPropertiesOptionAProperties struct {
	// BFD configuration properties
	BfdConfiguration *BfdConfiguration

	// Egress Acl. ARM resource ID of Access Control Lists.
	EgressACLID *string

	// Ingress Acl. ARM resource ID of Access Control Lists.
	IngressACLID *string

	// MTU to use for option A peering.
	Mtu *int32

	// Peer ASN number.Example : 28
	PeerASN *int64

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// Vlan identifier. Example : 501
	VlanID *int32

	// READ-ONLY; Fabric ASN number. Example 65001
	FabricASN *int64
}

ExternalNetworkPatchPropertiesOptionAProperties - option A properties object

func (ExternalNetworkPatchPropertiesOptionAProperties) MarshalJSON 

func (e ExternalNetworkPatchPropertiesOptionAProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetworkPatchPropertiesOptionAProperties.

func (*ExternalNetworkPatchPropertiesOptionAProperties) UnmarshalJSON 

func (e *ExternalNetworkPatchPropertiesOptionAProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetworkPatchPropertiesOptionAProperties.

type ExternalNetworkProperties 

type ExternalNetworkProperties struct {
	// REQUIRED; Peering option list.
	PeeringOption *PeeringOption

	// Switch configuration description.
	Annotation *string

	// Export Route Policy either IPv4 or IPv6.
	ExportRoutePolicy *ExportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ExportRoutePolicyID *string

	// Import Route Policy either IPv4 or IPv6.
	ImportRoutePolicy *ImportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ImportRoutePolicyID *string

	// option A properties object
	OptionAProperties *ExternalNetworkPropertiesOptionAProperties

	// option B properties object
	OptionBProperties *L3OptionBProperties

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Gets the networkToNetworkInterconnectId of the resource.
	NetworkToNetworkInterconnectID *string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

ExternalNetworkProperties - External Network Properties.

func (ExternalNetworkProperties) MarshalJSON 

func (e ExternalNetworkProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetworkProperties.

func (*ExternalNetworkProperties) UnmarshalJSON 

func (e *ExternalNetworkProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetworkProperties.

type ExternalNetworkPropertiesOptionAProperties 

type ExternalNetworkPropertiesOptionAProperties struct {
	// BFD configuration properties
	BfdConfiguration *BfdConfiguration

	// Egress Acl. ARM resource ID of Access Control Lists.
	EgressACLID *string

	// Ingress Acl. ARM resource ID of Access Control Lists.
	IngressACLID *string

	// MTU to use for option A peering.
	Mtu *int32

	// Peer ASN number.Example : 28
	PeerASN *int64

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// Vlan identifier. Example : 501
	VlanID *int32

	// READ-ONLY; Fabric ASN number. Example 65001
	FabricASN *int64
}

ExternalNetworkPropertiesOptionAProperties - option A properties object

func (ExternalNetworkPropertiesOptionAProperties) MarshalJSON 

func (e ExternalNetworkPropertiesOptionAProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetworkPropertiesOptionAProperties.

func (*ExternalNetworkPropertiesOptionAProperties) UnmarshalJSON 

func (e *ExternalNetworkPropertiesOptionAProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetworkPropertiesOptionAProperties.

type ExternalNetworksClient 

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

ExternalNetworksClient contains the methods for the ExternalNetworks group. Don't use this type directly, use NewExternalNetworksClient() instead.

func NewExternalNetworksClient 

func NewExternalNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ExternalNetworksClient, error)

NewExternalNetworksClient creates a new instance of ExternalNetworksClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ExternalNetworksClient) BeginCreate 

func (client *ExternalNetworksClient) BeginCreate(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, externalNetworkName string, body ExternalNetwork, options *ExternalNetworksClientBeginCreateOptions) (*runtime.Poller[ExternalNetworksClientCreateResponse], error)

BeginCreate - Creates ExternalNetwork PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • externalNetworkName - Name of the External Network.
  • body - Request payload.
  • options - ExternalNetworksClientBeginCreateOptions contains the optional parameters for the ExternalNetworksClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewExternalNetworksClient().BeginCreate(ctx, "example-rg", "example-l3domain", "example-externalnetwork", armmanagednetworkfabric.ExternalNetwork{
		Properties: &armmanagednetworkfabric.ExternalNetworkProperties{
			Annotation: to.Ptr("annotation"),
			ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
				ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			OptionAProperties: &armmanagednetworkfabric.ExternalNetworkPropertiesOptionAProperties{
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](15),
				},
				EgressACLID:         to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
				IngressACLID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
				Mtu:                 to.Ptr[int32](1500),
				PeerASN:             to.Ptr[int64](65047),
				VlanID:              to.Ptr[int32](1001),
				PrimaryIPv4Prefix:   to.Ptr("10.1.1.0/30"),
				PrimaryIPv6Prefix:   to.Ptr("3FFE:FFFF:0:CD30::a0/126"),
				SecondaryIPv4Prefix: to.Ptr("10.1.1.4/30"),
				SecondaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a4/126"),
			},
			OptionBProperties: &armmanagednetworkfabric.L3OptionBProperties{
				ExportRouteTargets: []*string{
					to.Ptr("65046:10039")},
				ImportRouteTargets: []*string{
					to.Ptr("65046:10039")},
				RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
					ExportIPv4RouteTargets: []*string{
						to.Ptr("65046:10039")},
					ExportIPv6RouteTargets: []*string{
						to.Ptr("65046:10039")},
					ImportIPv4RouteTargets: []*string{
						to.Ptr("65046:10039")},
					ImportIPv6RouteTargets: []*string{
						to.Ptr("65046:10039")},
				},
			},
			PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		},
	}, 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.ExternalNetwork = armmanagednetworkfabric.ExternalNetwork{
	// 	Name: to.Ptr("example-externalnetwork"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/externalnetworks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/externalNetworks/example-externalnetwork"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.ExternalNetworkProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 		OptionAProperties: &armmanagednetworkfabric.ExternalNetworkPropertiesOptionAProperties{
	// 			BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 				IntervalInMilliSeconds: to.Ptr[int32](300),
	// 				Multiplier: to.Ptr[int32](15),
	// 			},
	// 			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 			FabricASN: to.Ptr[int64](1234),
	// 			IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 			Mtu: to.Ptr[int32](1500),
	// 			PeerASN: to.Ptr[int64](65047),
	// 			VlanID: to.Ptr[int32](1001),
	// 			PrimaryIPv4Prefix: to.Ptr("10.1.1.0/30"),
	// 			PrimaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/126"),
	// 			SecondaryIPv4Prefix: to.Ptr("10.1.1.4/30"),
	// 			SecondaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a4/126"),
	// 		},
	// 		OptionBProperties: &armmanagednetworkfabric.L3OptionBProperties{
	// 			ExportRouteTargets: []*string{
	// 				to.Ptr("65046:10039")},
	// 				ImportRouteTargets: []*string{
	// 					to.Ptr("65046:10039")},
	// 					RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 						ExportIPv4RouteTargets: []*string{
	// 							to.Ptr("65046:10039")},
	// 							ExportIPv6RouteTargets: []*string{
	// 								to.Ptr("65046:10039")},
	// 								ImportIPv4RouteTargets: []*string{
	// 									to.Ptr("65046:10039")},
	// 									ImportIPv6RouteTargets: []*string{
	// 										to.Ptr("65046:10039")},
	// 									},
	// 								},
	// 								PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 								ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 							},
	// 						}
}

Output:

func (*ExternalNetworksClient) BeginDelete 

func (client *ExternalNetworksClient) BeginDelete(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, externalNetworkName string, options *ExternalNetworksClientBeginDeleteOptions) (*runtime.Poller[ExternalNetworksClientDeleteResponse], error)

BeginDelete - Implements ExternalNetworks DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • externalNetworkName - Name of the External Network.
  • options - ExternalNetworksClientBeginDeleteOptions contains the optional parameters for the ExternalNetworksClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewExternalNetworksClient().BeginDelete(ctx, "example-rg", "example-l3domain", "example-externalnetwork", 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)
	}
}

Output:

func (*ExternalNetworksClient) BeginUpdate 

func (client *ExternalNetworksClient) BeginUpdate(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, externalNetworkName string, body ExternalNetworkPatch, options *ExternalNetworksClientBeginUpdateOptions) (*runtime.Poller[ExternalNetworksClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the ExternalNetworks resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • externalNetworkName - Name of the External Network.
  • body - ExternalNetwork properties to update. Only annotations are supported.
  • options - ExternalNetworksClientBeginUpdateOptions contains the optional parameters for the ExternalNetworksClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewExternalNetworksClient().BeginUpdate(ctx, "example-rg", "example-l3domain", "example-externalnetwork", armmanagednetworkfabric.ExternalNetworkPatch{
		Properties: &armmanagednetworkfabric.ExternalNetworkPatchProperties{
			Annotation: to.Ptr("annotation1"),
			ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
				ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			OptionAProperties: &armmanagednetworkfabric.ExternalNetworkPatchPropertiesOptionAProperties{
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](15),
				},
				EgressACLID:         to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
				IngressACLID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
				Mtu:                 to.Ptr[int32](1500),
				PeerASN:             to.Ptr[int64](65047),
				VlanID:              to.Ptr[int32](1001),
				PrimaryIPv4Prefix:   to.Ptr("10.1.1.0/30"),
				PrimaryIPv6Prefix:   to.Ptr("3FFE:FFFF:0:CD30::a0/126"),
				SecondaryIPv4Prefix: to.Ptr("10.1.1.4/30"),
				SecondaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a4/126"),
			},
			OptionBProperties: &armmanagednetworkfabric.L3OptionBProperties{
				ExportRouteTargets: []*string{
					to.Ptr("65046:10039")},
				ImportRouteTargets: []*string{
					to.Ptr("65046:10039")},
				RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
					ExportIPv4RouteTargets: []*string{
						to.Ptr("65046:10039")},
					ExportIPv6RouteTargets: []*string{
						to.Ptr("65046:10039")},
					ImportIPv4RouteTargets: []*string{
						to.Ptr("65046:10039")},
					ImportIPv6RouteTargets: []*string{
						to.Ptr("65046:10039")},
				},
			},
			PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		},
	}, 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.ExternalNetwork = armmanagednetworkfabric.ExternalNetwork{
	// 	Name: to.Ptr("example-externalnetwork"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/externalnetworks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/externalNetworks/example-externalnetwork"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.ExternalNetworkProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 		OptionAProperties: &armmanagednetworkfabric.ExternalNetworkPropertiesOptionAProperties{
	// 			BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 				IntervalInMilliSeconds: to.Ptr[int32](300),
	// 				Multiplier: to.Ptr[int32](15),
	// 			},
	// 			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 			FabricASN: to.Ptr[int64](1234),
	// 			IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 			Mtu: to.Ptr[int32](1500),
	// 			PeerASN: to.Ptr[int64](65047),
	// 			VlanID: to.Ptr[int32](1001),
	// 			PrimaryIPv4Prefix: to.Ptr("10.1.1.0/30"),
	// 			PrimaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/126"),
	// 			SecondaryIPv4Prefix: to.Ptr("10.1.1.4/30"),
	// 			SecondaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a4/126"),
	// 		},
	// 		OptionBProperties: &armmanagednetworkfabric.L3OptionBProperties{
	// 			ExportRouteTargets: []*string{
	// 				to.Ptr("65046:10039")},
	// 				ImportRouteTargets: []*string{
	// 					to.Ptr("65046:10039")},
	// 					RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 						ExportIPv4RouteTargets: []*string{
	// 							to.Ptr("65046:10039")},
	// 							ExportIPv6RouteTargets: []*string{
	// 								to.Ptr("65046:10039")},
	// 								ImportIPv4RouteTargets: []*string{
	// 									to.Ptr("65046:10039")},
	// 									ImportIPv6RouteTargets: []*string{
	// 										to.Ptr("65046:10039")},
	// 									},
	// 								},
	// 								PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 								ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 							},
	// 						}
}

Output:

func (*ExternalNetworksClient) BeginUpdateAdministrativeState 

func (client *ExternalNetworksClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, externalNetworkName string, body UpdateAdministrativeState, options *ExternalNetworksClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[ExternalNetworksClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Executes update operation to enable or disable administrative State for externalNetwork. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • externalNetworkName - Name of the External Network.
  • body - Request payload.
  • options - ExternalNetworksClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the ExternalNetworksClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewExternalNetworksClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-l3domain", "example-externalnetwork", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*ExternalNetworksClient) BeginUpdateStaticRouteBfdAdministrativeState 

func (client *ExternalNetworksClient) BeginUpdateStaticRouteBfdAdministrativeState(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, externalNetworkName string, body UpdateAdministrativeState, options *ExternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions) (*runtime.Poller[ExternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse], error)

BeginUpdateStaticRouteBfdAdministrativeState - Update Static Route BFD for external Network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • externalNetworkName - Name of the External Network.
  • body - Request payload.
  • options - ExternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions contains the optional parameters for the ExternalNetworksClient.BeginUpdateStaticRouteBfdAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_UpdateStaticRouteBfdAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewExternalNetworksClient().BeginUpdateStaticRouteBfdAdministrativeState(ctx, "example-rg", "example-l3domain", "example-externalnetwork", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*ExternalNetworksClient) Get 

func (client *ExternalNetworksClient) Get(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, externalNetworkName string, options *ExternalNetworksClientGetOptions) (ExternalNetworksClientGetResponse, error)

Get - Implements ExternalNetworks GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • externalNetworkName - Name of the External Network.
  • options - ExternalNetworksClientGetOptions contains the optional parameters for the ExternalNetworksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewExternalNetworksClient().Get(ctx, "rgL3IsolationDomains", "yhtr", "fltpszzikbalrzaqq", 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.ExternalNetwork = armmanagednetworkfabric.ExternalNetwork{
	// 	Name: to.Ptr("example-externalnetwork"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/externalnetworks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/externalNetworks/example-externalnetwork"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.ExternalNetworkProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 		OptionAProperties: &armmanagednetworkfabric.ExternalNetworkPropertiesOptionAProperties{
	// 			BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 				IntervalInMilliSeconds: to.Ptr[int32](300),
	// 				Multiplier: to.Ptr[int32](15),
	// 			},
	// 			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 			FabricASN: to.Ptr[int64](1234),
	// 			IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 			Mtu: to.Ptr[int32](1500),
	// 			PeerASN: to.Ptr[int64](65047),
	// 			VlanID: to.Ptr[int32](1001),
	// 			PrimaryIPv4Prefix: to.Ptr("10.1.1.0/30"),
	// 			PrimaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/126"),
	// 			SecondaryIPv4Prefix: to.Ptr("10.1.1.4/30"),
	// 			SecondaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a4/126"),
	// 		},
	// 		OptionBProperties: &armmanagednetworkfabric.L3OptionBProperties{
	// 			ExportRouteTargets: []*string{
	// 				to.Ptr("65046:10039")},
	// 				ImportRouteTargets: []*string{
	// 					to.Ptr("65046:10039")},
	// 					RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 						ExportIPv4RouteTargets: []*string{
	// 							to.Ptr("65046:10039")},
	// 							ExportIPv6RouteTargets: []*string{
	// 								to.Ptr("65046:10039")},
	// 								ImportIPv4RouteTargets: []*string{
	// 									to.Ptr("65046:10039")},
	// 									ImportIPv6RouteTargets: []*string{
	// 										to.Ptr("65046:10039")},
	// 									},
	// 								},
	// 								PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 								ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 							},
	// 						}
}

Output:

func (*ExternalNetworksClient) NewListByL3IsolationDomainPager 

func (client *ExternalNetworksClient) NewListByL3IsolationDomainPager(resourceGroupName string, l3IsolationDomainName string, options *ExternalNetworksClientListByL3IsolationDomainOptions) *runtime.Pager[ExternalNetworksClientListByL3IsolationDomainResponse]

NewListByL3IsolationDomainPager - Implements External Networks list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • options - ExternalNetworksClientListByL3IsolationDomainOptions contains the optional parameters for the ExternalNetworksClient.NewListByL3IsolationDomainPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ExternalNetworks_ListByL3IsolationDomain_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewExternalNetworksClient().NewListByL3IsolationDomainPager("example-rg", "example-l3domain", 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.ExternalNetworksList = armmanagednetworkfabric.ExternalNetworksList{
		// 	Value: []*armmanagednetworkfabric.ExternalNetwork{
		// 		{
		// 			Name: to.Ptr("example-externalnetwork"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/externalnetworks"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/externalNetworks/example-externalnetwork"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("UserId"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Properties: &armmanagednetworkfabric.ExternalNetworkProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
		// 					ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 					ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				},
		// 				ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
		// 					ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 					ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				},
		// 				ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
		// 				OptionAProperties: &armmanagednetworkfabric.ExternalNetworkPropertiesOptionAProperties{
		// 					BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 						IntervalInMilliSeconds: to.Ptr[int32](300),
		// 						Multiplier: to.Ptr[int32](15),
		// 					},
		// 					EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 					FabricASN: to.Ptr[int64](1234),
		// 					IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 					Mtu: to.Ptr[int32](1500),
		// 					PeerASN: to.Ptr[int64](65047),
		// 					VlanID: to.Ptr[int32](1001),
		// 					PrimaryIPv4Prefix: to.Ptr("10.1.1.0/30"),
		// 					PrimaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/126"),
		// 					SecondaryIPv4Prefix: to.Ptr("10.1.1.4/30"),
		// 					SecondaryIPv6Prefix: to.Ptr("3FFE:FFFF:0:CD30::a4/126"),
		// 				},
		// 				OptionBProperties: &armmanagednetworkfabric.L3OptionBProperties{
		// 					ExportRouteTargets: []*string{
		// 						to.Ptr("65046:10039")},
		// 						ImportRouteTargets: []*string{
		// 							to.Ptr("65046:10039")},
		// 							RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
		// 								ExportIPv4RouteTargets: []*string{
		// 									to.Ptr("65046:10039")},
		// 									ExportIPv6RouteTargets: []*string{
		// 										to.Ptr("65046:10039")},
		// 										ImportIPv4RouteTargets: []*string{
		// 											to.Ptr("65046:10039")},
		// 											ImportIPv6RouteTargets: []*string{
		// 												to.Ptr("65046:10039")},
		// 											},
		// 										},
		// 										PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		// 										ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 									},
		// 							}},
		// 						}
	}
}

Output:

type ExternalNetworksClientBeginCreateOptions 

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

ExternalNetworksClientBeginCreateOptions contains the optional parameters for the ExternalNetworksClient.BeginCreate method.

type ExternalNetworksClientBeginDeleteOptions 

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

ExternalNetworksClientBeginDeleteOptions contains the optional parameters for the ExternalNetworksClient.BeginDelete method.

type ExternalNetworksClientBeginUpdateAdministrativeStateOptions 

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

ExternalNetworksClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the ExternalNetworksClient.BeginUpdateAdministrativeState method.

type ExternalNetworksClientBeginUpdateOptions 

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

ExternalNetworksClientBeginUpdateOptions contains the optional parameters for the ExternalNetworksClient.BeginUpdate method.

type ExternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions 

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

ExternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions contains the optional parameters for the ExternalNetworksClient.BeginUpdateStaticRouteBfdAdministrativeState method.

type ExternalNetworksClientCreateResponse 

type ExternalNetworksClientCreateResponse struct {
	// Defines the External Network resource.
	ExternalNetwork
}

ExternalNetworksClientCreateResponse contains the response from method ExternalNetworksClient.BeginCreate.

type ExternalNetworksClientDeleteResponse 

type ExternalNetworksClientDeleteResponse struct {
}

ExternalNetworksClientDeleteResponse contains the response from method ExternalNetworksClient.BeginDelete.

type ExternalNetworksClientGetOptions 

type ExternalNetworksClientGetOptions struct {
}

ExternalNetworksClientGetOptions contains the optional parameters for the ExternalNetworksClient.Get method.

type ExternalNetworksClientGetResponse 

type ExternalNetworksClientGetResponse struct {
	// Defines the External Network resource.
	ExternalNetwork
}

ExternalNetworksClientGetResponse contains the response from method ExternalNetworksClient.Get.

type ExternalNetworksClientListByL3IsolationDomainOptions 

type ExternalNetworksClientListByL3IsolationDomainOptions struct {
}

ExternalNetworksClientListByL3IsolationDomainOptions contains the optional parameters for the ExternalNetworksClient.NewListByL3IsolationDomainPager method.

type ExternalNetworksClientListByL3IsolationDomainResponse 

type ExternalNetworksClientListByL3IsolationDomainResponse struct {
	// List of External Networks.
	ExternalNetworksList
}

ExternalNetworksClientListByL3IsolationDomainResponse contains the response from method ExternalNetworksClient.NewListByL3IsolationDomainPager.

type ExternalNetworksClientUpdateAdministrativeStateResponse 

type ExternalNetworksClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

ExternalNetworksClientUpdateAdministrativeStateResponse contains the response from method ExternalNetworksClient.BeginUpdateAdministrativeState.

type ExternalNetworksClientUpdateResponse 

type ExternalNetworksClientUpdateResponse struct {
	// Defines the External Network resource.
	ExternalNetwork
}

ExternalNetworksClientUpdateResponse contains the response from method ExternalNetworksClient.BeginUpdate.

type ExternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse 

type ExternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

ExternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse contains the response from method ExternalNetworksClient.BeginUpdateStaticRouteBfdAdministrativeState.

type ExternalNetworksList 

type ExternalNetworksList struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of External Network resources.
	Value []*ExternalNetwork
}

ExternalNetworksList - List of External Networks.

func (ExternalNetworksList) MarshalJSON 

func (e ExternalNetworksList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalNetworksList.

func (*ExternalNetworksList) UnmarshalJSON 

func (e *ExternalNetworksList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalNetworksList.

type FabricSKUType 

type FabricSKUType string

FabricSKUType - Type of Network Fabric SKU. 

const (
	FabricSKUTypeMultiRack  FabricSKUType = "MultiRack"
	FabricSKUTypeSingleRack FabricSKUType = "SingleRack"
)

func PossibleFabricSKUTypeValues 

func PossibleFabricSKUTypeValues() []FabricSKUType

PossibleFabricSKUTypeValues returns the possible values for the FabricSKUType const type.

type GatewayType 

type GatewayType string

GatewayType - Gateway Type of the resource. 

const (
	GatewayTypeInfrastructure GatewayType = "Infrastructure"
	GatewayTypeWorkload       GatewayType = "Workload"
)

func PossibleGatewayTypeValues 

func PossibleGatewayTypeValues() []GatewayType

PossibleGatewayTypeValues returns the possible values for the GatewayType const type.

type IPAddressType 

type IPAddressType string

IPAddressType - IP Address type. 

const (
	IPAddressTypeIPv4 IPAddressType = "IPv4"
	IPAddressTypeIPv6 IPAddressType = "IPv6"
)

func PossibleIPAddressTypeValues 

func PossibleIPAddressTypeValues() []IPAddressType

PossibleIPAddressTypeValues returns the possible values for the IPAddressType const type.

type IPCommunitiesClient 

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

IPCommunitiesClient contains the methods for the IPCommunities group. Don't use this type directly, use NewIPCommunitiesClient() instead.

func NewIPCommunitiesClient 

func NewIPCommunitiesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IPCommunitiesClient, error)

NewIPCommunitiesClient creates a new instance of IPCommunitiesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*IPCommunitiesClient) BeginCreate 

func (client *IPCommunitiesClient) BeginCreate(ctx context.Context, resourceGroupName string, ipCommunityName string, body IPCommunity, options *IPCommunitiesClientBeginCreateOptions) (*runtime.Poller[IPCommunitiesClientCreateResponse], error)

BeginCreate - Implements an IP Community PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipCommunityName - Name of the IP Community.
  • body - Request payload.
  • options - IPCommunitiesClientBeginCreateOptions contains the optional parameters for the IPCommunitiesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpCommunities_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPCommunitiesClient().BeginCreate(ctx, "example-rg", "example-ipcommunity", armmanagednetworkfabric.IPCommunity{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyId": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.IPCommunityProperties{
			Annotation: to.Ptr("annotation"),
			IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
				{
					Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
					CommunityMembers: []*string{
						to.Ptr("1:1")},
					SequenceNumber: to.Ptr[int64](4155123341),
					WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
						to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
				}},
		},
	}, 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.IPCommunity = armmanagednetworkfabric.IPCommunity{
	// 	Name: to.Ptr("example-ipcommunity"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipcommunities"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipcommunity"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyId": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPCommunityProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				CommunityMembers: []*string{
	// 					to.Ptr("1:1")},
	// 					SequenceNumber: to.Ptr[int64](4155123341),
	// 					WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
	// 						to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
	// 				}},
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			},
	// 		}
}

Output:

func (*IPCommunitiesClient) BeginDelete 

func (client *IPCommunitiesClient) BeginDelete(ctx context.Context, resourceGroupName string, ipCommunityName string, options *IPCommunitiesClientBeginDeleteOptions) (*runtime.Poller[IPCommunitiesClientDeleteResponse], error)

BeginDelete - Implements IP Community DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipCommunityName - Name of the IP Community.
  • options - IPCommunitiesClientBeginDeleteOptions contains the optional parameters for the IPCommunitiesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpCommunities_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPCommunitiesClient().BeginDelete(ctx, "example-rg", "example-ipcommunity", 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)
	}
}

Output:

func (*IPCommunitiesClient) BeginUpdate 

func (client *IPCommunitiesClient) BeginUpdate(ctx context.Context, resourceGroupName string, ipCommunityName string, body IPCommunityPatch, options *IPCommunitiesClientBeginUpdateOptions) (*runtime.Poller[IPCommunitiesClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the IP Community resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipCommunityName - Name of the IP Community.
  • body - IP Community properties to update.
  • options - IPCommunitiesClientBeginUpdateOptions contains the optional parameters for the IPCommunitiesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpCommunities_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPCommunitiesClient().BeginUpdate(ctx, "example-rg", "example-ipcommunity", armmanagednetworkfabric.IPCommunityPatch{
		Properties: &armmanagednetworkfabric.IPCommunityPatchableProperties{
			IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
				{
					Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
					CommunityMembers: []*string{
						to.Ptr("1:1")},
					SequenceNumber: to.Ptr[int64](4155123341),
					WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
						to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
				}},
		},
	}, 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.IPCommunity = armmanagednetworkfabric.IPCommunity{
	// 	Name: to.Ptr("example-ipcommunity"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipcommunities"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipcommunity"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPCommunityProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				CommunityMembers: []*string{
	// 					to.Ptr("1:1")},
	// 					SequenceNumber: to.Ptr[int64](4155123341),
	// 					WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
	// 						to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
	// 				}},
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			},
	// 		}
}

Output:

func (*IPCommunitiesClient) Get 

func (client *IPCommunitiesClient) Get(ctx context.Context, resourceGroupName string, ipCommunityName string, options *IPCommunitiesClientGetOptions) (IPCommunitiesClientGetResponse, error)

Get - Implements an IP Community GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipCommunityName - Name of the IP Community.
  • options - IPCommunitiesClientGetOptions contains the optional parameters for the IPCommunitiesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpCommunities_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIPCommunitiesClient().Get(ctx, "example-rg", "example-ipcommunity", 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.IPCommunity = armmanagednetworkfabric.IPCommunity{
	// 	Name: to.Ptr("example-ipcommunity"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipcommunities"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipcommunity"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyId": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPCommunityProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				CommunityMembers: []*string{
	// 					to.Ptr("1:1")},
	// 					SequenceNumber: to.Ptr[int64](4155123341),
	// 					WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
	// 						to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
	// 				}},
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			},
	// 		}
}

Output:

func (*IPCommunitiesClient) NewListByResourceGroupPager 

func (client *IPCommunitiesClient) NewListByResourceGroupPager(resourceGroupName string, options *IPCommunitiesClientListByResourceGroupOptions) *runtime.Pager[IPCommunitiesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Implements IP Communities list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IPCommunitiesClientListByResourceGroupOptions contains the optional parameters for the IPCommunitiesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpCommunities_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIPCommunitiesClient().NewListByResourceGroupPager("example-rg", 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.IPCommunitiesListResult = armmanagednetworkfabric.IPCommunitiesListResult{
		// 	Value: []*armmanagednetworkfabric.IPCommunity{
		// 		{
		// 			Name: to.Ptr("example-ipcommunity"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/ipcommunities"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipcommunity"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyId": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.IPCommunityProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
		// 					{
		// 						Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
		// 						CommunityMembers: []*string{
		// 							to.Ptr("1:1")},
		// 							SequenceNumber: to.Ptr[int64](4155123341),
		// 							WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
		// 								to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
		// 						}},
		// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 						ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

func (*IPCommunitiesClient) NewListBySubscriptionPager 

func (client *IPCommunitiesClient) NewListBySubscriptionPager(options *IPCommunitiesClientListBySubscriptionOptions) *runtime.Pager[IPCommunitiesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Implements IP Communities list by subscription GET method.

Generated from API version 2023-06-15

  • options - IPCommunitiesClientListBySubscriptionOptions contains the optional parameters for the IPCommunitiesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpCommunities_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIPCommunitiesClient().NewListBySubscriptionPager(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.IPCommunitiesListResult = armmanagednetworkfabric.IPCommunitiesListResult{
		// 	Value: []*armmanagednetworkfabric.IPCommunity{
		// 		{
		// 			Name: to.Ptr("example-ipcommunity"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/ipcommunities"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipcommunity"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:26:17.611Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyId": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.IPCommunityProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				IPCommunityRules: []*armmanagednetworkfabric.IPCommunityRule{
		// 					{
		// 						Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
		// 						CommunityMembers: []*string{
		// 							to.Ptr("1:1")},
		// 							SequenceNumber: to.Ptr[int64](4155123341),
		// 							WellKnownCommunities: []*armmanagednetworkfabric.WellKnownCommunities{
		// 								to.Ptr(armmanagednetworkfabric.WellKnownCommunitiesInternet)},
		// 						}},
		// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 						ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type IPCommunitiesClientBeginCreateOptions 

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

IPCommunitiesClientBeginCreateOptions contains the optional parameters for the IPCommunitiesClient.BeginCreate method.

type IPCommunitiesClientBeginDeleteOptions 

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

IPCommunitiesClientBeginDeleteOptions contains the optional parameters for the IPCommunitiesClient.BeginDelete method.

type IPCommunitiesClientBeginUpdateOptions 

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

IPCommunitiesClientBeginUpdateOptions contains the optional parameters for the IPCommunitiesClient.BeginUpdate method.

type IPCommunitiesClientCreateResponse 

type IPCommunitiesClientCreateResponse struct {
	// The IP Community resource definition.
	IPCommunity
}

IPCommunitiesClientCreateResponse contains the response from method IPCommunitiesClient.BeginCreate.

type IPCommunitiesClientDeleteResponse 

type IPCommunitiesClientDeleteResponse struct {
}

IPCommunitiesClientDeleteResponse contains the response from method IPCommunitiesClient.BeginDelete.

type IPCommunitiesClientGetOptions 

type IPCommunitiesClientGetOptions struct {
}

IPCommunitiesClientGetOptions contains the optional parameters for the IPCommunitiesClient.Get method.

type IPCommunitiesClientGetResponse 

type IPCommunitiesClientGetResponse struct {
	// The IP Community resource definition.
	IPCommunity
}

IPCommunitiesClientGetResponse contains the response from method IPCommunitiesClient.Get.

type IPCommunitiesClientListByResourceGroupOptions 

type IPCommunitiesClientListByResourceGroupOptions struct {
}

IPCommunitiesClientListByResourceGroupOptions contains the optional parameters for the IPCommunitiesClient.NewListByResourceGroupPager method.

type IPCommunitiesClientListByResourceGroupResponse 

type IPCommunitiesClientListByResourceGroupResponse struct {
	// List of IP Communities.
	IPCommunitiesListResult
}

IPCommunitiesClientListByResourceGroupResponse contains the response from method IPCommunitiesClient.NewListByResourceGroupPager.

type IPCommunitiesClientListBySubscriptionOptions 

type IPCommunitiesClientListBySubscriptionOptions struct {
}

IPCommunitiesClientListBySubscriptionOptions contains the optional parameters for the IPCommunitiesClient.NewListBySubscriptionPager method.

type IPCommunitiesClientListBySubscriptionResponse 

type IPCommunitiesClientListBySubscriptionResponse struct {
	// List of IP Communities.
	IPCommunitiesListResult
}

IPCommunitiesClientListBySubscriptionResponse contains the response from method IPCommunitiesClient.NewListBySubscriptionPager.

type IPCommunitiesClientUpdateResponse 

type IPCommunitiesClientUpdateResponse struct {
	// The IP Community resource definition.
	IPCommunity
}

IPCommunitiesClientUpdateResponse contains the response from method IPCommunitiesClient.BeginUpdate.

type IPCommunitiesListResult 

type IPCommunitiesListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of IP Community resources.
	Value []*IPCommunity
}

IPCommunitiesListResult - List of IP Communities.

func (IPCommunitiesListResult) MarshalJSON 

func (i IPCommunitiesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunitiesListResult.

func (*IPCommunitiesListResult) UnmarshalJSON 

func (i *IPCommunitiesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunitiesListResult.

type IPCommunity 

type IPCommunity struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *IPCommunityProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

IPCommunity - The IP Community resource definition.

func (IPCommunity) MarshalJSON 

func (i IPCommunity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunity.

func (*IPCommunity) UnmarshalJSON 

func (i *IPCommunity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunity.

type IPCommunityIDList 

type IPCommunityIDList struct {
	// List of IP Community resource IDs.
	IPCommunityIDs []*string
}

IPCommunityIDList - IP Community ID list properties.

func (IPCommunityIDList) MarshalJSON 

func (i IPCommunityIDList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunityIDList.

func (*IPCommunityIDList) UnmarshalJSON 

func (i *IPCommunityIDList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunityIDList.

type IPCommunityPatch 

type IPCommunityPatch struct {
	// IP Community patchable properties.
	Properties *IPCommunityPatchableProperties

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

IPCommunityPatch - The IP Community patch resource definition.

func (IPCommunityPatch) MarshalJSON 

func (i IPCommunityPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunityPatch.

func (*IPCommunityPatch) UnmarshalJSON 

func (i *IPCommunityPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunityPatch.

type IPCommunityPatchableProperties 

type IPCommunityPatchableProperties struct {
	// List of IP Community Rules.
	IPCommunityRules []*IPCommunityRule
}

IPCommunityPatchableProperties - IP Community patchable properties.

func (IPCommunityPatchableProperties) MarshalJSON 

func (i IPCommunityPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunityPatchableProperties.

func (*IPCommunityPatchableProperties) UnmarshalJSON 

func (i *IPCommunityPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunityPatchableProperties.

type IPCommunityProperties 

type IPCommunityProperties struct {
	// Switch configuration description.
	Annotation *string

	// List of IP Community Rules.
	IPCommunityRules []*IPCommunityRule

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

IPCommunityProperties - IP Community Properties defines the resource properties.

func (IPCommunityProperties) MarshalJSON 

func (i IPCommunityProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunityProperties.

func (*IPCommunityProperties) UnmarshalJSON 

func (i *IPCommunityProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunityProperties.

type IPCommunityRule 

type IPCommunityRule struct {
	// REQUIRED; Action to be taken on the configuration. Example: Permit | Deny.
	Action *CommunityActionTypes

	// REQUIRED; List the community members of IP Community.
	CommunityMembers []*string

	// REQUIRED; Sequence to insert to/delete from existing route. Prefix lists are evaluated starting with the lowest sequence
	// number and continue down the list until a match is made. Once a match is made, the permit
	// or deny statement is applied to that network and the rest of the list is ignored.
	SequenceNumber *int64

	// Supported well known Community List.
	WellKnownCommunities []*WellKnownCommunities
}

IPCommunityRule - IP Community patchable properties.

func (IPCommunityRule) MarshalJSON 

func (i IPCommunityRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPCommunityRule.

func (*IPCommunityRule) UnmarshalJSON 

func (i *IPCommunityRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPCommunityRule.

type IPExtendedCommunitiesClient 

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

IPExtendedCommunitiesClient contains the methods for the IPExtendedCommunities group. Don't use this type directly, use NewIPExtendedCommunitiesClient() instead.

func NewIPExtendedCommunitiesClient 

func NewIPExtendedCommunitiesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IPExtendedCommunitiesClient, error)

NewIPExtendedCommunitiesClient creates a new instance of IPExtendedCommunitiesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*IPExtendedCommunitiesClient) BeginCreate 

func (client *IPExtendedCommunitiesClient) BeginCreate(ctx context.Context, resourceGroupName string, ipExtendedCommunityName string, body IPExtendedCommunity, options *IPExtendedCommunitiesClientBeginCreateOptions) (*runtime.Poller[IPExtendedCommunitiesClientCreateResponse], error)

BeginCreate - Implements IP Extended Community PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipExtendedCommunityName - Name of the IP Extended Community.
  • body - Request payload.
  • options - IPExtendedCommunitiesClientBeginCreateOptions contains the optional parameters for the IPExtendedCommunitiesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpExtendedCommunities_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPExtendedCommunitiesClient().BeginCreate(ctx, "example-rg", "example-ipExtendedCommunity", armmanagednetworkfabric.IPExtendedCommunity{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.IPExtendedCommunityProperties{
			Annotation: to.Ptr("annotation"),
			IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
				{
					Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
					RouteTargets: []*string{
						to.Ptr("1234:2345")},
					SequenceNumber: to.Ptr[int64](4155123341),
				}},
		},
	}, 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.IPExtendedCommunity = armmanagednetworkfabric.IPExtendedCommunity{
	// 	Name: to.Ptr("example-ipExtendedCommunity"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipExtendedCommunities"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPExtendedCommunityProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				RouteTargets: []*string{
	// 					to.Ptr("1234:2345")},
	// 					SequenceNumber: to.Ptr[int64](4155123341),
	// 			}},
	// 			AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 			ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		},
	// 	}
}

Output:

func (*IPExtendedCommunitiesClient) BeginDelete 

func (client *IPExtendedCommunitiesClient) BeginDelete(ctx context.Context, resourceGroupName string, ipExtendedCommunityName string, options *IPExtendedCommunitiesClientBeginDeleteOptions) (*runtime.Poller[IPExtendedCommunitiesClientDeleteResponse], error)

BeginDelete - Implements IP Extended Community DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipExtendedCommunityName - Name of the IP Extended Community.
  • options - IPExtendedCommunitiesClientBeginDeleteOptions contains the optional parameters for the IPExtendedCommunitiesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpExtendedCommunities_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPExtendedCommunitiesClient().BeginDelete(ctx, "example-rg", "example-ipExtendedCommunity", 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)
	}
}

Output:

func (*IPExtendedCommunitiesClient) BeginUpdate 

func (client *IPExtendedCommunitiesClient) BeginUpdate(ctx context.Context, resourceGroupName string, ipExtendedCommunityName string, body IPExtendedCommunityPatch, options *IPExtendedCommunitiesClientBeginUpdateOptions) (*runtime.Poller[IPExtendedCommunitiesClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the IP Extended Community resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipExtendedCommunityName - Name of the IP Extended Community.
  • body - IP Extended Community properties to update.
  • options - IPExtendedCommunitiesClientBeginUpdateOptions contains the optional parameters for the IPExtendedCommunitiesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpExtendedCommunities_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPExtendedCommunitiesClient().BeginUpdate(ctx, "example-rg", "example-ipExtendedCommunity", armmanagednetworkfabric.IPExtendedCommunityPatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.IPExtendedCommunityPatchProperties{
			IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
				{
					Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
					RouteTargets: []*string{
						to.Ptr("1234:2345")},
					SequenceNumber: to.Ptr[int64](4155123341),
				}},
		},
	}, 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.IPExtendedCommunity = armmanagednetworkfabric.IPExtendedCommunity{
	// 	Name: to.Ptr("example-ipExtendedCommunity"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipExtendedCommunities"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPExtendedCommunityProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				RouteTargets: []*string{
	// 					to.Ptr("1234:2345")},
	// 					SequenceNumber: to.Ptr[int64](4155123341),
	// 			}},
	// 			AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 			ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		},
	// 	}
}

Output:

func (*IPExtendedCommunitiesClient) Get 

func (client *IPExtendedCommunitiesClient) Get(ctx context.Context, resourceGroupName string, ipExtendedCommunityName string, options *IPExtendedCommunitiesClientGetOptions) (IPExtendedCommunitiesClientGetResponse, error)

Get - Implements IP Extended Community GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipExtendedCommunityName - Name of the IP Extended Community.
  • options - IPExtendedCommunitiesClientGetOptions contains the optional parameters for the IPExtendedCommunitiesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpExtendedCommunities_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIPExtendedCommunitiesClient().Get(ctx, "example-rg", "example-ipExtendedCommunity", 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.IPExtendedCommunity = armmanagednetworkfabric.IPExtendedCommunity{
	// 	Name: to.Ptr("example-ipExtendedCommunity"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipExtendedCommunities"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPExtendedCommunityProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				RouteTargets: []*string{
	// 					to.Ptr("1234:2345")},
	// 					SequenceNumber: to.Ptr[int64](4155123341),
	// 			}},
	// 			AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 			ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		},
	// 	}
}

Output:

func (*IPExtendedCommunitiesClient) NewListByResourceGroupPager 

func (client *IPExtendedCommunitiesClient) NewListByResourceGroupPager(resourceGroupName string, options *IPExtendedCommunitiesClientListByResourceGroupOptions) *runtime.Pager[IPExtendedCommunitiesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Implements IpExtendedCommunities list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IPExtendedCommunitiesClientListByResourceGroupOptions contains the optional parameters for the IPExtendedCommunitiesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpExtendedCommunities_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIPExtendedCommunitiesClient().NewListByResourceGroupPager("example-rg", 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.IPExtendedCommunityListResult = armmanagednetworkfabric.IPExtendedCommunityListResult{
		// 	Value: []*armmanagednetworkfabric.IPExtendedCommunity{
		// 		{
		// 			Name: to.Ptr("example-ipExtendedCommunity"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/ipExtendedCommunities"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.IPExtendedCommunityProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
		// 					{
		// 						Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
		// 						RouteTargets: []*string{
		// 							to.Ptr("1234:2345")},
		// 							SequenceNumber: to.Ptr[int64](4155123341),
		// 					}},
		// 					AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 					ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

func (*IPExtendedCommunitiesClient) NewListBySubscriptionPager 

func (client *IPExtendedCommunitiesClient) NewListBySubscriptionPager(options *IPExtendedCommunitiesClientListBySubscriptionOptions) *runtime.Pager[IPExtendedCommunitiesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Implements IpExtendedCommunities list by subscription GET method.

Generated from API version 2023-06-15

  • options - IPExtendedCommunitiesClientListBySubscriptionOptions contains the optional parameters for the IPExtendedCommunitiesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpExtendedCommunities_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIPExtendedCommunitiesClient().NewListBySubscriptionPager(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.IPExtendedCommunityListResult = armmanagednetworkfabric.IPExtendedCommunityListResult{
		// 	Value: []*armmanagednetworkfabric.IPExtendedCommunity{
		// 		{
		// 			Name: to.Ptr("example-ipExtendedCommunity"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/ipExtendedCommunities"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T18:49:33.904Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.IPExtendedCommunityProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				IPExtendedCommunityRules: []*armmanagednetworkfabric.IPExtendedCommunityRule{
		// 					{
		// 						Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
		// 						RouteTargets: []*string{
		// 							to.Ptr("1234:2345")},
		// 							SequenceNumber: to.Ptr[int64](4155123341),
		// 					}},
		// 					AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 					ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type IPExtendedCommunitiesClientBeginCreateOptions 

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

IPExtendedCommunitiesClientBeginCreateOptions contains the optional parameters for the IPExtendedCommunitiesClient.BeginCreate method.

type IPExtendedCommunitiesClientBeginDeleteOptions 

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

IPExtendedCommunitiesClientBeginDeleteOptions contains the optional parameters for the IPExtendedCommunitiesClient.BeginDelete method.

type IPExtendedCommunitiesClientBeginUpdateOptions 

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

IPExtendedCommunitiesClientBeginUpdateOptions contains the optional parameters for the IPExtendedCommunitiesClient.BeginUpdate method.

type IPExtendedCommunitiesClientCreateResponse 

type IPExtendedCommunitiesClientCreateResponse struct {
	// The IP Extended Community resource definition.
	IPExtendedCommunity
}

IPExtendedCommunitiesClientCreateResponse contains the response from method IPExtendedCommunitiesClient.BeginCreate.

type IPExtendedCommunitiesClientDeleteResponse 

type IPExtendedCommunitiesClientDeleteResponse struct {
}

IPExtendedCommunitiesClientDeleteResponse contains the response from method IPExtendedCommunitiesClient.BeginDelete.

type IPExtendedCommunitiesClientGetOptions 

type IPExtendedCommunitiesClientGetOptions struct {
}

IPExtendedCommunitiesClientGetOptions contains the optional parameters for the IPExtendedCommunitiesClient.Get method.

type IPExtendedCommunitiesClientGetResponse 

type IPExtendedCommunitiesClientGetResponse struct {
	// The IP Extended Community resource definition.
	IPExtendedCommunity
}

IPExtendedCommunitiesClientGetResponse contains the response from method IPExtendedCommunitiesClient.Get.

type IPExtendedCommunitiesClientListByResourceGroupOptions 

type IPExtendedCommunitiesClientListByResourceGroupOptions struct {
}

IPExtendedCommunitiesClientListByResourceGroupOptions contains the optional parameters for the IPExtendedCommunitiesClient.NewListByResourceGroupPager method.

type IPExtendedCommunitiesClientListByResourceGroupResponse 

type IPExtendedCommunitiesClientListByResourceGroupResponse struct {
	// List of IP Extended Communities.
	IPExtendedCommunityListResult
}

IPExtendedCommunitiesClientListByResourceGroupResponse contains the response from method IPExtendedCommunitiesClient.NewListByResourceGroupPager.

type IPExtendedCommunitiesClientListBySubscriptionOptions 

type IPExtendedCommunitiesClientListBySubscriptionOptions struct {
}

IPExtendedCommunitiesClientListBySubscriptionOptions contains the optional parameters for the IPExtendedCommunitiesClient.NewListBySubscriptionPager method.

type IPExtendedCommunitiesClientListBySubscriptionResponse 

type IPExtendedCommunitiesClientListBySubscriptionResponse struct {
	// List of IP Extended Communities.
	IPExtendedCommunityListResult
}

IPExtendedCommunitiesClientListBySubscriptionResponse contains the response from method IPExtendedCommunitiesClient.NewListBySubscriptionPager.

type IPExtendedCommunitiesClientUpdateResponse 

type IPExtendedCommunitiesClientUpdateResponse struct {
	// The IP Extended Community resource definition.
	IPExtendedCommunity
}

IPExtendedCommunitiesClientUpdateResponse contains the response from method IPExtendedCommunitiesClient.BeginUpdate.

type IPExtendedCommunity 

type IPExtendedCommunity struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *IPExtendedCommunityProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

IPExtendedCommunity - The IP Extended Community resource definition.

func (IPExtendedCommunity) MarshalJSON 

func (i IPExtendedCommunity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunity.

func (*IPExtendedCommunity) UnmarshalJSON 

func (i *IPExtendedCommunity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunity.

type IPExtendedCommunityIDList 

type IPExtendedCommunityIDList struct {
	// List of IP Extended Community resource IDs.
	IPExtendedCommunityIDs []*string
}

IPExtendedCommunityIDList - IP Extended Community Id list properties.

func (IPExtendedCommunityIDList) MarshalJSON 

func (i IPExtendedCommunityIDList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunityIDList.

func (*IPExtendedCommunityIDList) UnmarshalJSON 

func (i *IPExtendedCommunityIDList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunityIDList.

type IPExtendedCommunityListResult 

type IPExtendedCommunityListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of IP Extended Communities resources.
	Value []*IPExtendedCommunity
}

IPExtendedCommunityListResult - List of IP Extended Communities.

func (IPExtendedCommunityListResult) MarshalJSON 

func (i IPExtendedCommunityListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunityListResult.

func (*IPExtendedCommunityListResult) UnmarshalJSON 

func (i *IPExtendedCommunityListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunityListResult.

type IPExtendedCommunityPatch 

type IPExtendedCommunityPatch struct {
	// IP Extended Community patchable properties.
	Properties *IPExtendedCommunityPatchProperties

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

IPExtendedCommunityPatch - The IP Extended Communities patch resource definition.

func (IPExtendedCommunityPatch) MarshalJSON 

func (i IPExtendedCommunityPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunityPatch.

func (*IPExtendedCommunityPatch) UnmarshalJSON 

func (i *IPExtendedCommunityPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunityPatch.

type IPExtendedCommunityPatchProperties 

type IPExtendedCommunityPatchProperties struct {
	// REQUIRED; List of IP Extended Community Rules.
	IPExtendedCommunityRules []*IPExtendedCommunityRule

	// Switch configuration description.
	Annotation *string
}

IPExtendedCommunityPatchProperties - IP Extended Community patchable properties.

func (IPExtendedCommunityPatchProperties) MarshalJSON 

func (i IPExtendedCommunityPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunityPatchProperties.

func (*IPExtendedCommunityPatchProperties) UnmarshalJSON 

func (i *IPExtendedCommunityPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunityPatchProperties.

type IPExtendedCommunityProperties 

type IPExtendedCommunityProperties struct {
	// REQUIRED; List of IP Extended Community Rules.
	IPExtendedCommunityRules []*IPExtendedCommunityRule

	// Switch configuration description.
	Annotation *string

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

IPExtendedCommunityProperties - IP Extended Community Properties defines the resource properties.

func (IPExtendedCommunityProperties) MarshalJSON 

func (i IPExtendedCommunityProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunityProperties.

func (*IPExtendedCommunityProperties) UnmarshalJSON 

func (i *IPExtendedCommunityProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunityProperties.

type IPExtendedCommunityRule 

type IPExtendedCommunityRule struct {
	// REQUIRED; Action to be taken on the configuration. Example: Permit | Deny.
	Action *CommunityActionTypes

	// REQUIRED; Route Target List.The expected formats are ASN(plain):NN >> example 4294967294:50, ASN.ASN:NN >> example 65533.65333:40,
	// IP-address:NN >> example 10.10.10.10:65535. The possible values of ASN,NN are
	// in range of 0-65535, ASN(plain) is in range of 0-4294967295.
	RouteTargets []*string

	// REQUIRED; Sequence to insert to/delete from existing route. Prefix lists are evaluated starting with the lowest sequence
	// number and continue down the list until a match is made. Once a match is made, the permit
	// or deny statement is applied to that network and the rest of the list is ignored.
	SequenceNumber *int64
}

IPExtendedCommunityRule - List of IP Extended Community Rules.

func (IPExtendedCommunityRule) MarshalJSON 

func (i IPExtendedCommunityRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPExtendedCommunityRule.

func (*IPExtendedCommunityRule) UnmarshalJSON 

func (i *IPExtendedCommunityRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPExtendedCommunityRule.

type IPGroupProperties 

type IPGroupProperties struct {
	// IP Address type.
	IPAddressType *IPAddressType

	// List of IP Prefixes.
	IPPrefixes []*string

	// IP Group name.
	Name *string
}

IPGroupProperties - IP Group properties.

func (IPGroupProperties) MarshalJSON 

func (i IPGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPGroupProperties.

func (*IPGroupProperties) UnmarshalJSON 

func (i *IPGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPGroupProperties.

type IPMatchCondition 

type IPMatchCondition struct {
	// The List of IP Group Names that need to be matched.
	IPGroupNames []*string

	// The list of IP Prefixes.
	IPPrefixValues []*string

	// IP Prefix Type.
	PrefixType *PrefixType

	// IP Address type.
	Type *SourceDestinationType
}

IPMatchCondition - Defines the condition that can be filtered using the selected IPs.

func (IPMatchCondition) MarshalJSON 

func (i IPMatchCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPMatchCondition.

func (*IPMatchCondition) UnmarshalJSON 

func (i *IPMatchCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPMatchCondition.

type IPPrefix 

type IPPrefix struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *IPPrefixProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

IPPrefix - The IP Prefix resource definition.

func (IPPrefix) MarshalJSON 

func (i IPPrefix) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPPrefix.

func (*IPPrefix) UnmarshalJSON 

func (i *IPPrefix) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPPrefix.

type IPPrefixPatch 

type IPPrefixPatch struct {
	// IP Prefix patchable properties.
	Properties *IPPrefixPatchProperties

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

IPPrefixPatch - The IP Prefix patch resource definition.

func (IPPrefixPatch) MarshalJSON 

func (i IPPrefixPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPPrefixPatch.

func (*IPPrefixPatch) UnmarshalJSON 

func (i *IPPrefixPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPPrefixPatch.

type IPPrefixPatchProperties 

type IPPrefixPatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// The list of IP Prefix Rules.
	IPPrefixRules []*IPPrefixRule
}

IPPrefixPatchProperties - IP Prefix patchable properties.

func (IPPrefixPatchProperties) MarshalJSON 

func (i IPPrefixPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPPrefixPatchProperties.

func (*IPPrefixPatchProperties) UnmarshalJSON 

func (i *IPPrefixPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPPrefixPatchProperties.

type IPPrefixProperties 

type IPPrefixProperties struct {
	// Switch configuration description.
	Annotation *string

	// The list of IP Prefix Rules.
	IPPrefixRules []*IPPrefixRule

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

IPPrefixProperties - IP Prefix Properties defines the properties of the resource.

func (IPPrefixProperties) MarshalJSON 

func (i IPPrefixProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPPrefixProperties.

func (*IPPrefixProperties) UnmarshalJSON 

func (i *IPPrefixProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPPrefixProperties.

type IPPrefixRule 

type IPPrefixRule struct {
	// REQUIRED; Action to be taken on the configuration. Example: Permit | Deny.
	Action *CommunityActionTypes

	// REQUIRED; Network Prefix specifying IPv4/IPv6 packets to be permitted or denied. Example: 1.1.1.0/24 | 3FFE:FFFF:0:CD30::/126
	NetworkPrefix *string

	// REQUIRED; Sequence to insert to/delete from existing route. Prefix lists are evaluated starting with the lowest sequence
	// number and continue down the list until a match is made. Once a match is made, the permit
	// or deny statement is applied to that network and the rest of the list is ignored.
	SequenceNumber *int64

	// Specify prefix-list bounds.
	Condition *Condition

	// SubnetMaskLength gives the minimum NetworkPrefix length to be matched. Possible values for IPv4 are 1 - 32 . Possible values
	// of IPv6 are 1 - 128.
	SubnetMaskLength *string
}

IPPrefixRule - IP Prefix Rule properties.

func (IPPrefixRule) MarshalJSON 

func (i IPPrefixRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPPrefixRule.

func (*IPPrefixRule) UnmarshalJSON 

func (i *IPPrefixRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPPrefixRule.

type IPPrefixesClient 

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

IPPrefixesClient contains the methods for the IPPrefixes group. Don't use this type directly, use NewIPPrefixesClient() instead.

func NewIPPrefixesClient 

func NewIPPrefixesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IPPrefixesClient, error)

NewIPPrefixesClient creates a new instance of IPPrefixesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*IPPrefixesClient) BeginCreate 

func (client *IPPrefixesClient) BeginCreate(ctx context.Context, resourceGroupName string, ipPrefixName string, body IPPrefix, options *IPPrefixesClientBeginCreateOptions) (*runtime.Poller[IPPrefixesClientCreateResponse], error)

BeginCreate - Implements IP Prefix PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipPrefixName - Name of the IP Prefix.
  • body - Request payload.
  • options - IPPrefixesClientBeginCreateOptions contains the optional parameters for the IPPrefixesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpPrefixes_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPPrefixesClient().BeginCreate(ctx, "example-rg", "example-ipPrefix", armmanagednetworkfabric.IPPrefix{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.IPPrefixProperties{
			Annotation: to.Ptr("annotation"),
			IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
				{
					Action:           to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
					Condition:        to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
					NetworkPrefix:    to.Ptr("10.10.10.10/30"),
					SequenceNumber:   to.Ptr[int64](4155123341),
					SubnetMaskLength: to.Ptr("10"),
				}},
		},
	}, 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.IPPrefix = armmanagednetworkfabric.IPPrefix{
	// 	Name: to.Ptr("example-ipPrefix"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipPrefixes"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.656Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.657Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPPrefixProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				Condition: to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
	// 				NetworkPrefix: to.Ptr("10.10.10.10/30"),
	// 				SequenceNumber: to.Ptr[int64](4155123341),
	// 				SubnetMaskLength: to.Ptr("10"),
	// 		}},
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*IPPrefixesClient) BeginDelete 

func (client *IPPrefixesClient) BeginDelete(ctx context.Context, resourceGroupName string, ipPrefixName string, options *IPPrefixesClientBeginDeleteOptions) (*runtime.Poller[IPPrefixesClientDeleteResponse], error)

BeginDelete - Implements IP Prefix DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipPrefixName - Name of the IP Prefix.
  • options - IPPrefixesClientBeginDeleteOptions contains the optional parameters for the IPPrefixesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpPrefixes_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPPrefixesClient().BeginDelete(ctx, "example-rg", "example-ipPrefix", 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)
	}
}

Output:

func (*IPPrefixesClient) BeginUpdate 

func (client *IPPrefixesClient) BeginUpdate(ctx context.Context, resourceGroupName string, ipPrefixName string, body IPPrefixPatch, options *IPPrefixesClientBeginUpdateOptions) (*runtime.Poller[IPPrefixesClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the IP Prefix resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipPrefixName - Name of the IP Prefix.
  • body - IP Prefix properties to update.
  • options - IPPrefixesClientBeginUpdateOptions contains the optional parameters for the IPPrefixesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpPrefixes_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIPPrefixesClient().BeginUpdate(ctx, "example-rg", "example-ipPrefix", armmanagednetworkfabric.IPPrefixPatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.IPPrefixPatchProperties{
			Annotation: to.Ptr("annotation"),
			IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
				{
					Action:           to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
					Condition:        to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
					NetworkPrefix:    to.Ptr("10.10.10.10/30"),
					SequenceNumber:   to.Ptr[int64](4155123341),
					SubnetMaskLength: to.Ptr("10"),
				}},
		},
	}, 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.IPPrefix = armmanagednetworkfabric.IPPrefix{
	// 	Name: to.Ptr("example-ipPrefix"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipPrefixes"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.656Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.657Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPPrefixProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				Condition: to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
	// 				NetworkPrefix: to.Ptr("10.10.10.10/30"),
	// 				SequenceNumber: to.Ptr[int64](4155123341),
	// 				SubnetMaskLength: to.Ptr("10"),
	// 		}},
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*IPPrefixesClient) Get 

func (client *IPPrefixesClient) Get(ctx context.Context, resourceGroupName string, ipPrefixName string, options *IPPrefixesClientGetOptions) (IPPrefixesClientGetResponse, error)

Get - Implements IP Prefix GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • ipPrefixName - Name of the IP Prefix.
  • options - IPPrefixesClientGetOptions contains the optional parameters for the IPPrefixesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpPrefixes_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIPPrefixesClient().Get(ctx, "example-rg", "example-ipPrefix", 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.IPPrefix = armmanagednetworkfabric.IPPrefix{
	// 	Name: to.Ptr("example-ipPrefix"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/ipPrefixes"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.656Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.657Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.IPPrefixProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
	// 			{
	// 				Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
	// 				Condition: to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
	// 				NetworkPrefix: to.Ptr("10.10.10.10/30"),
	// 				SequenceNumber: to.Ptr[int64](4155123341),
	// 				SubnetMaskLength: to.Ptr("10"),
	// 		}},
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*IPPrefixesClient) NewListByResourceGroupPager 

func (client *IPPrefixesClient) NewListByResourceGroupPager(resourceGroupName string, options *IPPrefixesClientListByResourceGroupOptions) *runtime.Pager[IPPrefixesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Implements IpPrefixes list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IPPrefixesClientListByResourceGroupOptions contains the optional parameters for the IPPrefixesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpPrefixes_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIPPrefixesClient().NewListByResourceGroupPager("example-rg", 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.IPPrefixesListResult = armmanagednetworkfabric.IPPrefixesListResult{
		// 	Value: []*armmanagednetworkfabric.IPPrefix{
		// 		{
		// 			Name: to.Ptr("example-ipPrefix"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/ipPrefixes"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.656Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.657Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.IPPrefixProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
		// 					{
		// 						Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
		// 						Condition: to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
		// 						NetworkPrefix: to.Ptr("10.10.10.10/30"),
		// 						SequenceNumber: to.Ptr[int64](4155123341),
		// 						SubnetMaskLength: to.Ptr("10"),
		// 				}},
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*IPPrefixesClient) NewListBySubscriptionPager 

func (client *IPPrefixesClient) NewListBySubscriptionPager(options *IPPrefixesClientListBySubscriptionOptions) *runtime.Pager[IPPrefixesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Implements IpPrefixes list by subscription GET method.

Generated from API version 2023-06-15

  • options - IPPrefixesClientListBySubscriptionOptions contains the optional parameters for the IPPrefixesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/IpPrefixes_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIPPrefixesClient().NewListBySubscriptionPager(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.IPPrefixesListResult = armmanagednetworkfabric.IPPrefixesListResult{
		// 	Value: []*armmanagednetworkfabric.IPPrefix{
		// 		{
		// 			Name: to.Ptr("example-ipPrefix"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/ipPrefixes"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.656Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T03:52:05.657Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.IPPrefixProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				IPPrefixRules: []*armmanagednetworkfabric.IPPrefixRule{
		// 					{
		// 						Action: to.Ptr(armmanagednetworkfabric.CommunityActionTypesPermit),
		// 						Condition: to.Ptr(armmanagednetworkfabric.ConditionGreaterThanOrEqualTo),
		// 						NetworkPrefix: to.Ptr("10.10.10.10/30"),
		// 						SequenceNumber: to.Ptr[int64](4155123341),
		// 						SubnetMaskLength: to.Ptr("10"),
		// 				}},
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

type IPPrefixesClientBeginCreateOptions 

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

IPPrefixesClientBeginCreateOptions contains the optional parameters for the IPPrefixesClient.BeginCreate method.

type IPPrefixesClientBeginDeleteOptions 

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

IPPrefixesClientBeginDeleteOptions contains the optional parameters for the IPPrefixesClient.BeginDelete method.

type IPPrefixesClientBeginUpdateOptions 

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

IPPrefixesClientBeginUpdateOptions contains the optional parameters for the IPPrefixesClient.BeginUpdate method.

type IPPrefixesClientCreateResponse 

type IPPrefixesClientCreateResponse struct {
	// The IP Prefix resource definition.
	IPPrefix
}

IPPrefixesClientCreateResponse contains the response from method IPPrefixesClient.BeginCreate.

type IPPrefixesClientDeleteResponse 

type IPPrefixesClientDeleteResponse struct {
}

IPPrefixesClientDeleteResponse contains the response from method IPPrefixesClient.BeginDelete.

type IPPrefixesClientGetOptions 

type IPPrefixesClientGetOptions struct {
}

IPPrefixesClientGetOptions contains the optional parameters for the IPPrefixesClient.Get method.

type IPPrefixesClientGetResponse 

type IPPrefixesClientGetResponse struct {
	// The IP Prefix resource definition.
	IPPrefix
}

IPPrefixesClientGetResponse contains the response from method IPPrefixesClient.Get.

type IPPrefixesClientListByResourceGroupOptions 

type IPPrefixesClientListByResourceGroupOptions struct {
}

IPPrefixesClientListByResourceGroupOptions contains the optional parameters for the IPPrefixesClient.NewListByResourceGroupPager method.

type IPPrefixesClientListByResourceGroupResponse 

type IPPrefixesClientListByResourceGroupResponse struct {
	// List of IP Prefixes.
	IPPrefixesListResult
}

IPPrefixesClientListByResourceGroupResponse contains the response from method IPPrefixesClient.NewListByResourceGroupPager.

type IPPrefixesClientListBySubscriptionOptions 

type IPPrefixesClientListBySubscriptionOptions struct {
}

IPPrefixesClientListBySubscriptionOptions contains the optional parameters for the IPPrefixesClient.NewListBySubscriptionPager method.

type IPPrefixesClientListBySubscriptionResponse 

type IPPrefixesClientListBySubscriptionResponse struct {
	// List of IP Prefixes.
	IPPrefixesListResult
}

IPPrefixesClientListBySubscriptionResponse contains the response from method IPPrefixesClient.NewListBySubscriptionPager.

type IPPrefixesClientUpdateResponse 

type IPPrefixesClientUpdateResponse struct {
	// The IP Prefix resource definition.
	IPPrefix
}

IPPrefixesClientUpdateResponse contains the response from method IPPrefixesClient.BeginUpdate.

type IPPrefixesListResult 

type IPPrefixesListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of IP Prefix resources.
	Value []*IPPrefix
}

IPPrefixesListResult - List of IP Prefixes.

func (IPPrefixesListResult) MarshalJSON 

func (i IPPrefixesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPPrefixesListResult.

func (*IPPrefixesListResult) UnmarshalJSON 

func (i *IPPrefixesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPPrefixesListResult.

type ImportRoutePolicy 

type ImportRoutePolicy struct {
	// ARM resource ID of RoutePolicy.
	ImportIPv4RoutePolicyID *string

	// ARM resource ID of RoutePolicy.
	ImportIPv6RoutePolicyID *string
}

ImportRoutePolicy - Import Route Policy either IPv4 or IPv6.

func (ImportRoutePolicy) MarshalJSON 

func (i ImportRoutePolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ImportRoutePolicy.

func (*ImportRoutePolicy) UnmarshalJSON 

func (i *ImportRoutePolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ImportRoutePolicy.

type ImportRoutePolicyInformation 

type ImportRoutePolicyInformation struct {
	// Import IPv4 Route Policy Id.
	ImportIPv4RoutePolicyID *string

	// Import IPv6 Route Policy Id.
	ImportIPv6RoutePolicyID *string
}

ImportRoutePolicyInformation - Import Route Policy Configuration.

func (ImportRoutePolicyInformation) MarshalJSON 

func (i ImportRoutePolicyInformation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ImportRoutePolicyInformation.

func (*ImportRoutePolicyInformation) UnmarshalJSON 

func (i *ImportRoutePolicyInformation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ImportRoutePolicyInformation.

type InterfaceType 

type InterfaceType string

InterfaceType - The Interface Type. Example: Management/Data 

const (
	InterfaceTypeData       InterfaceType = "Data"
	InterfaceTypeManagement InterfaceType = "Management"
)

func PossibleInterfaceTypeValues 

func PossibleInterfaceTypeValues() []InterfaceType

PossibleInterfaceTypeValues returns the possible values for the InterfaceType const type.

type InternalNetwork 

type InternalNetwork struct {
	// REQUIRED; Resource properties.
	Properties *InternalNetworkProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

InternalNetwork - Defines the Internal Network resource.

func (InternalNetwork) MarshalJSON 

func (i InternalNetwork) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetwork.

func (*InternalNetwork) UnmarshalJSON 

func (i *InternalNetwork) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetwork.

type InternalNetworkPatch 

type InternalNetworkPatch struct {
	// InternalNetwork Patch properties.
	Properties *InternalNetworkPatchProperties
}

InternalNetworkPatch - The InternalNetwork patch resource definition.

func (InternalNetworkPatch) MarshalJSON 

func (i InternalNetworkPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetworkPatch.

func (*InternalNetworkPatch) UnmarshalJSON 

func (i *InternalNetworkPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetworkPatch.

type InternalNetworkPatchProperties 

type InternalNetworkPatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// BGP configuration properties.
	BgpConfiguration *BgpConfiguration

	// List of Connected IPv4 Subnets.
	ConnectedIPv4Subnets []*ConnectedSubnet

	// List of connected IPv6 Subnets.
	ConnectedIPv6Subnets []*ConnectedSubnet

	// Egress Acl. ARM resource ID of Access Control Lists.
	EgressACLID *string

	// Export Route Policy either IPv4 or IPv6.
	ExportRoutePolicy *ExportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ExportRoutePolicyID *string

	// Import Route Policy either IPv4 or IPv6.
	ImportRoutePolicy *ImportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ImportRoutePolicyID *string

	// Ingress Acl. ARM resource ID of Access Control Lists.
	IngressACLID *string

	// To check whether monitoring of internal network is enabled or not.
	IsMonitoringEnabled *IsMonitoringEnabled

	// Maximum transmission unit. Default value is 1500.
	Mtu *int32

	// Static Route Configuration properties.
	StaticRouteConfiguration *StaticRouteConfiguration
}

InternalNetworkPatchProperties - InternalNetwork Patch properties.

func (InternalNetworkPatchProperties) MarshalJSON 

func (i InternalNetworkPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetworkPatchProperties.

func (*InternalNetworkPatchProperties) UnmarshalJSON 

func (i *InternalNetworkPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetworkPatchProperties.

type InternalNetworkProperties 

type InternalNetworkProperties struct {
	// REQUIRED; Vlan identifier. Example: 1001.
	VlanID *int32

	// Switch configuration description.
	Annotation *string

	// BGP configuration properties.
	BgpConfiguration *InternalNetworkPropertiesBgpConfiguration

	// List of Connected IPv4 Subnets.
	ConnectedIPv4Subnets []*ConnectedSubnet

	// List of connected IPv6 Subnets.
	ConnectedIPv6Subnets []*ConnectedSubnet

	// Egress Acl. ARM resource ID of Access Control Lists.
	EgressACLID *string

	// Export Route Policy either IPv4 or IPv6.
	ExportRoutePolicy *ExportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ExportRoutePolicyID *string

	// Extension. Example: NoExtension | NPB.
	Extension *Extension

	// Import Route Policy either IPv4 or IPv6.
	ImportRoutePolicy *ImportRoutePolicy

	// ARM Resource ID of the RoutePolicy. This is used for the backward compatibility.
	ImportRoutePolicyID *string

	// Ingress Acl. ARM resource ID of Access Control Lists.
	IngressACLID *string

	// To check whether monitoring of internal network is enabled or not.
	IsMonitoringEnabled *IsMonitoringEnabled

	// Maximum transmission unit. Default value is 1500.
	Mtu *int32

	// Static Route Configuration properties.
	StaticRouteConfiguration *InternalNetworkPropertiesStaticRouteConfiguration

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

InternalNetworkProperties - Internal Network Properties defines the properties of the resource.

func (InternalNetworkProperties) MarshalJSON 

func (i InternalNetworkProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetworkProperties.

func (*InternalNetworkProperties) UnmarshalJSON 

func (i *InternalNetworkProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetworkProperties.

type InternalNetworkPropertiesBgpConfiguration 

type InternalNetworkPropertiesBgpConfiguration struct {
	// Allows for routes to be received and processed even if the router detects its own ASN in the AS-Path. 0 is disable, Possible
	// values are 1-10, default is 2.
	AllowAS *int32

	// Enable Or Disable state.
	AllowASOverride *AllowASOverride

	// Switch configuration description.
	Annotation *string

	// BFD configuration properties
	BfdConfiguration *BfdConfiguration

	// Originate a defaultRoute. Ex: "True" | "False".
	DefaultRouteOriginate *BooleanEnumProperty

	// List of BGP IPv4 Listen Range prefixes.
	IPv4ListenRangePrefixes []*string

	// List with stringified IPv4 Neighbor Addresses.
	IPv4NeighborAddress []*NeighborAddress

	// List of BGP IPv6 Listen Ranges prefixes.
	IPv6ListenRangePrefixes []*string

	// List with stringified IPv6 Neighbor Address.
	IPv6NeighborAddress []*NeighborAddress

	// Peer ASN. Example: 65047.
	PeerASN *int64

	// READ-ONLY; ASN of Network Fabric. Example: 65048.
	FabricASN *int64
}

InternalNetworkPropertiesBgpConfiguration - BGP configuration properties.

func (InternalNetworkPropertiesBgpConfiguration) MarshalJSON 

func (i InternalNetworkPropertiesBgpConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetworkPropertiesBgpConfiguration.

func (*InternalNetworkPropertiesBgpConfiguration) UnmarshalJSON 

func (i *InternalNetworkPropertiesBgpConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetworkPropertiesBgpConfiguration.

type InternalNetworkPropertiesStaticRouteConfiguration 

type InternalNetworkPropertiesStaticRouteConfiguration struct {
	// BFD configuration properties
	BfdConfiguration *BfdConfiguration

	// Extension. Example: NoExtension | NPB.
	Extension *Extension

	// List of IPv4 Routes.
	IPv4Routes []*StaticRouteProperties

	// List of IPv6 Routes.
	IPv6Routes []*StaticRouteProperties
}

InternalNetworkPropertiesStaticRouteConfiguration - Static Route Configuration properties.

func (InternalNetworkPropertiesStaticRouteConfiguration) MarshalJSON 

func (i InternalNetworkPropertiesStaticRouteConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetworkPropertiesStaticRouteConfiguration.

func (*InternalNetworkPropertiesStaticRouteConfiguration) UnmarshalJSON 

func (i *InternalNetworkPropertiesStaticRouteConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetworkPropertiesStaticRouteConfiguration.

type InternalNetworksClient 

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

InternalNetworksClient contains the methods for the InternalNetworks group. Don't use this type directly, use NewInternalNetworksClient() instead.

func NewInternalNetworksClient 

func NewInternalNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*InternalNetworksClient, error)

NewInternalNetworksClient creates a new instance of InternalNetworksClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*InternalNetworksClient) BeginCreate 

func (client *InternalNetworksClient) BeginCreate(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, body InternalNetwork, options *InternalNetworksClientBeginCreateOptions) (*runtime.Poller[InternalNetworksClientCreateResponse], error)

BeginCreate - Creates InternalNetwork PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • body - Request payload.
  • options - InternalNetworksClientBeginCreateOptions contains the optional parameters for the InternalNetworksClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternalNetworksClient().BeginCreate(ctx, "example-rg", "example-l3domain", "example-internalnetwork", armmanagednetworkfabric.InternalNetwork{
		Properties: &armmanagednetworkfabric.InternalNetworkProperties{
			Annotation: to.Ptr("annotation"),
			Extension:  to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
			ConnectedIPv4Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
				{
					Annotation: to.Ptr("annotation"),
					Prefix:     to.Ptr("10.0.0.0/24"),
				}},
			ConnectedIPv6Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
				{
					Annotation: to.Ptr("annotation"),
					Prefix:     to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
				}},
			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
				ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			IngressACLID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			IsMonitoringEnabled: to.Ptr(armmanagednetworkfabric.IsMonitoringEnabledTrue),
			Mtu:                 to.Ptr[int32](1500),
			BgpConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesBgpConfiguration{
				Annotation:      to.Ptr("annotation"),
				AllowAS:         to.Ptr[int32](10),
				AllowASOverride: to.Ptr(armmanagednetworkfabric.AllowASOverrideEnable),
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](5),
				},
				DefaultRouteOriginate: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
				IPv4ListenRangePrefixes: []*string{
					to.Ptr("10.1.0.0/25")},
				IPv4NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
					{
						Address: to.Ptr("10.1.0.0"),
					}},
				IPv6ListenRangePrefixes: []*string{
					to.Ptr("2fff::/66")},
				IPv6NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
					{
						Address: to.Ptr("2fff::"),
					}},
				PeerASN: to.Ptr[int64](61234),
			},
			StaticRouteConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesStaticRouteConfiguration{
				Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](15),
				},
				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("10.0.0.1")},
						Prefix: to.Ptr("jffgck"),
					}},
				IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("3ffe::1")},
						Prefix: to.Ptr("2fff::/64"),
					}},
			},
			VlanID: to.Ptr[int32](755),
		},
	}, 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.InternalNetwork = armmanagednetworkfabric.InternalNetwork{
	// 	Name: to.Ptr("example-internalnetwork"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/internalnetworks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/internalNetworks/example-internalnetwork"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternalNetworkProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
	// 		ConnectedIPv4Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Prefix: to.Ptr("10.0.0.0/24"),
	// 		}},
	// 		ConnectedIPv6Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
	// 		}},
	// 		EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		IsMonitoringEnabled: to.Ptr(armmanagednetworkfabric.IsMonitoringEnabledTrue),
	// 		Mtu: to.Ptr[int32](1500),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		BgpConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesBgpConfiguration{
	// 			Annotation: to.Ptr("annotation"),
	// 			AllowAS: to.Ptr[int32](10),
	// 			AllowASOverride: to.Ptr(armmanagednetworkfabric.AllowASOverrideEnable),
	// 			BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 				IntervalInMilliSeconds: to.Ptr[int32](300),
	// 				Multiplier: to.Ptr[int32](5),
	// 			},
	// 			DefaultRouteOriginate: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 			FabricASN: to.Ptr[int64](20),
	// 			IPv4ListenRangePrefixes: []*string{
	// 				to.Ptr("10.1.0.0/25")},
	// 				IPv4NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
	// 					{
	// 						Address: to.Ptr("10.1.0.0"),
	// 						ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				}},
	// 				IPv6ListenRangePrefixes: []*string{
	// 					to.Ptr("2fff::/66")},
	// 					IPv6NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
	// 						{
	// 							Address: to.Ptr("2fff::"),
	// 							ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 					}},
	// 					PeerASN: to.Ptr[int64](61234),
	// 				},
	// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 				StaticRouteConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesStaticRouteConfiguration{
	// 					Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
	// 					BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 						IntervalInMilliSeconds: to.Ptr[int32](300),
	// 						Multiplier: to.Ptr[int32](15),
	// 					},
	// 					IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 						{
	// 							NextHop: []*string{
	// 								to.Ptr("10.0.0.1")},
	// 								Prefix: to.Ptr("jffgck"),
	// 						}},
	// 						IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 							{
	// 								NextHop: []*string{
	// 									to.Ptr("3ffe::1")},
	// 									Prefix: to.Ptr("2fff::/64"),
	// 							}},
	// 						},
	// 						VlanID: to.Ptr[int32](755),
	// 					},
	// 				}
}

Output:

func (*InternalNetworksClient) BeginDelete 

func (client *InternalNetworksClient) BeginDelete(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, options *InternalNetworksClientBeginDeleteOptions) (*runtime.Poller[InternalNetworksClientDeleteResponse], error)

BeginDelete - Implements InternalNetworks DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • options - InternalNetworksClientBeginDeleteOptions contains the optional parameters for the InternalNetworksClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternalNetworksClient().BeginDelete(ctx, "example-rg", "example-l3domain", "example-internalnetwork", 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)
	}
}

Output:

func (*InternalNetworksClient) BeginUpdate 

func (client *InternalNetworksClient) BeginUpdate(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, body InternalNetworkPatch, options *InternalNetworksClientBeginUpdateOptions) (*runtime.Poller[InternalNetworksClientUpdateResponse], error)

BeginUpdate - Updates a InternalNetworks. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • body - InternalNetwork properties to update. Only annotations are supported.
  • options - InternalNetworksClientBeginUpdateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternalNetworksClient().BeginUpdate(ctx, "example-rg", "example-l3domain", "example-internalnetwork", armmanagednetworkfabric.InternalNetworkPatch{
		Properties: &armmanagednetworkfabric.InternalNetworkPatchProperties{
			Annotation: to.Ptr("annotation"),
			ConnectedIPv4Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
				{
					Annotation: to.Ptr("annotation"),
					Prefix:     to.Ptr("10.0.0.0/24"),
				}},
			ConnectedIPv6Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
				{
					Annotation: to.Ptr("annotation"),
					Prefix:     to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
				}},
			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
				ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
				ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			IngressACLID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			IsMonitoringEnabled: to.Ptr(armmanagednetworkfabric.IsMonitoringEnabledTrue),
			Mtu:                 to.Ptr[int32](1500),
			BgpConfiguration: &armmanagednetworkfabric.BgpConfiguration{
				Annotation:      to.Ptr("annotation"),
				AllowAS:         to.Ptr[int32](10),
				AllowASOverride: to.Ptr(armmanagednetworkfabric.AllowASOverrideEnable),
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](5),
				},
				DefaultRouteOriginate: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
				IPv4ListenRangePrefixes: []*string{
					to.Ptr("10.1.0.0/25")},
				IPv4NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
					{
						Address: to.Ptr("10.1.0.0"),
					}},
				IPv6ListenRangePrefixes: []*string{
					to.Ptr("2fff::/66")},
				IPv6NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
					{
						Address: to.Ptr("2fff::"),
					}},
				PeerASN: to.Ptr[int64](61234),
			},
			StaticRouteConfiguration: &armmanagednetworkfabric.StaticRouteConfiguration{
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](15),
				},
				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("10.0.0.1")},
						Prefix: to.Ptr("20.20.20.20/25"),
					}},
				IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("3ffe::1")},
						Prefix: to.Ptr("2fff::/64"),
					}},
			},
		},
	}, 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.InternalNetwork = armmanagednetworkfabric.InternalNetwork{
	// 	Name: to.Ptr("example-internalnetwork"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/internalnetworks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/internalNetworks/example-internalnetwork"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternalNetworkProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
	// 		ConnectedIPv4Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Prefix: to.Ptr("10.0.0.0/24"),
	// 		}},
	// 		ConnectedIPv6Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
	// 		}},
	// 		EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		IsMonitoringEnabled: to.Ptr(armmanagednetworkfabric.IsMonitoringEnabledTrue),
	// 		Mtu: to.Ptr[int32](1500),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		BgpConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesBgpConfiguration{
	// 			Annotation: to.Ptr("annotation"),
	// 			AllowAS: to.Ptr[int32](10),
	// 			AllowASOverride: to.Ptr(armmanagednetworkfabric.AllowASOverrideEnable),
	// 			BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 				IntervalInMilliSeconds: to.Ptr[int32](300),
	// 				Multiplier: to.Ptr[int32](5),
	// 			},
	// 			DefaultRouteOriginate: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 			FabricASN: to.Ptr[int64](20),
	// 			IPv4ListenRangePrefixes: []*string{
	// 				to.Ptr("10.1.0.0/25")},
	// 				IPv4NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
	// 					{
	// 						Address: to.Ptr("10.1.0.0"),
	// 						ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				}},
	// 				IPv6ListenRangePrefixes: []*string{
	// 					to.Ptr("2fff::/66")},
	// 					IPv6NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
	// 						{
	// 							Address: to.Ptr("2fff::"),
	// 							ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 					}},
	// 					PeerASN: to.Ptr[int64](61234),
	// 				},
	// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 				StaticRouteConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesStaticRouteConfiguration{
	// 					Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
	// 					BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 						IntervalInMilliSeconds: to.Ptr[int32](300),
	// 						Multiplier: to.Ptr[int32](15),
	// 					},
	// 					IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 						{
	// 							NextHop: []*string{
	// 								to.Ptr("10.0.0.1")},
	// 								Prefix: to.Ptr("jffgck"),
	// 						}},
	// 						IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 							{
	// 								NextHop: []*string{
	// 									to.Ptr("3ffe::1")},
	// 									Prefix: to.Ptr("2fff::/64"),
	// 							}},
	// 						},
	// 						VlanID: to.Ptr[int32](755),
	// 					},
	// 				}
}

Output:

func (*InternalNetworksClient) BeginUpdateAdministrativeState 

func (client *InternalNetworksClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, body UpdateAdministrativeState, options *InternalNetworksClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[InternalNetworksClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Update Administrative state of InternalNetworks on resources referred by their resource ids. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • body - Request payload.
  • options - InternalNetworksClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternalNetworksClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-l3domain", "example-internalnetwork", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*InternalNetworksClient) BeginUpdateBgpAdministrativeState 

func (client *InternalNetworksClient) BeginUpdateBgpAdministrativeState(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, body UpdateAdministrativeState, options *InternalNetworksClientBeginUpdateBgpAdministrativeStateOptions) (*runtime.Poller[InternalNetworksClientUpdateBgpAdministrativeStateResponse], error)

BeginUpdateBgpAdministrativeState - Update BGP state for internalNetwork. Allowed only on edge devices. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • body - Request payload.
  • options - InternalNetworksClientBeginUpdateBgpAdministrativeStateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdateBgpAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_UpdateBgpAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternalNetworksClient().BeginUpdateBgpAdministrativeState(ctx, "example-rg", "example-l3domain", "example-internalNetwork", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*InternalNetworksClient) BeginUpdateStaticRouteBfdAdministrativeState 

func (client *InternalNetworksClient) BeginUpdateStaticRouteBfdAdministrativeState(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, body UpdateAdministrativeState, options *InternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions) (*runtime.Poller[InternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse], error)

BeginUpdateStaticRouteBfdAdministrativeState - Update Static Route BFD administrative state for internalNetwork. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • body - Request payload.
  • options - InternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdateStaticRouteBfdAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_UpdateStaticRouteBfdAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternalNetworksClient().BeginUpdateStaticRouteBfdAdministrativeState(ctx, "example-rg", "example-l3domain", "example-internalNetwork", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*InternalNetworksClient) Get 

func (client *InternalNetworksClient) Get(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, internalNetworkName string, options *InternalNetworksClientGetOptions) (InternalNetworksClientGetResponse, error)

Get - Gets a InternalNetworks. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • internalNetworkName - Name of the Internal Network.
  • options - InternalNetworksClientGetOptions contains the optional parameters for the InternalNetworksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewInternalNetworksClient().Get(ctx, "example-rg", "example-l3domain", "example-internalnetwork", 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.InternalNetwork = armmanagednetworkfabric.InternalNetwork{
	// 	Name: to.Ptr("example-internalnetwork"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/internalnetworks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/internalNetworks/example-internalnetwork"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternalNetworkProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
	// 		ConnectedIPv4Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Prefix: to.Ptr("10.0.0.0/24"),
	// 		}},
	// 		ConnectedIPv6Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
	// 		}},
	// 		EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		IsMonitoringEnabled: to.Ptr(armmanagednetworkfabric.IsMonitoringEnabledTrue),
	// 		Mtu: to.Ptr[int32](1500),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		BgpConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesBgpConfiguration{
	// 			Annotation: to.Ptr("annotation"),
	// 			AllowAS: to.Ptr[int32](10),
	// 			AllowASOverride: to.Ptr(armmanagednetworkfabric.AllowASOverrideEnable),
	// 			BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 				IntervalInMilliSeconds: to.Ptr[int32](300),
	// 				Multiplier: to.Ptr[int32](5),
	// 			},
	// 			DefaultRouteOriginate: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 			FabricASN: to.Ptr[int64](20),
	// 			IPv4ListenRangePrefixes: []*string{
	// 				to.Ptr("10.1.0.0/25")},
	// 				IPv4NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
	// 					{
	// 						Address: to.Ptr("10.1.0.0"),
	// 						ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				}},
	// 				IPv6ListenRangePrefixes: []*string{
	// 					to.Ptr("2fff::/66")},
	// 					IPv6NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
	// 						{
	// 							Address: to.Ptr("2fff::"),
	// 							ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 					}},
	// 					PeerASN: to.Ptr[int64](61234),
	// 				},
	// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 				StaticRouteConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesStaticRouteConfiguration{
	// 					Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
	// 					BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 						IntervalInMilliSeconds: to.Ptr[int32](300),
	// 						Multiplier: to.Ptr[int32](15),
	// 					},
	// 					IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 						{
	// 							NextHop: []*string{
	// 								to.Ptr("10.0.0.1")},
	// 								Prefix: to.Ptr("jffgck"),
	// 						}},
	// 						IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 							{
	// 								NextHop: []*string{
	// 									to.Ptr("3ffe::1")},
	// 									Prefix: to.Ptr("2fff::/64"),
	// 							}},
	// 						},
	// 						VlanID: to.Ptr[int32](755),
	// 					},
	// 				}
}

Output:

func (*InternalNetworksClient) NewListByL3IsolationDomainPager 

func (client *InternalNetworksClient) NewListByL3IsolationDomainPager(resourceGroupName string, l3IsolationDomainName string, options *InternalNetworksClientListByL3IsolationDomainOptions) *runtime.Pager[InternalNetworksClientListByL3IsolationDomainResponse]

NewListByL3IsolationDomainPager - Displays InternalNetworks list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • options - InternalNetworksClientListByL3IsolationDomainOptions contains the optional parameters for the InternalNetworksClient.NewListByL3IsolationDomainPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternalNetworks_ListByL3IsolationDomain_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInternalNetworksClient().NewListByL3IsolationDomainPager("example-rg", "example-l3domain", 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.InternalNetworksList = armmanagednetworkfabric.InternalNetworksList{
		// 	Value: []*armmanagednetworkfabric.InternalNetwork{
		// 		{
		// 			Name: to.Ptr("example-internalnetwork"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/l3IsolationDomains/internalnetworks"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain/internalNetworks/example-internalnetwork"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-09T04:51:41.251Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("UserId"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Properties: &armmanagednetworkfabric.InternalNetworkProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
		// 				ConnectedIPv4Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
		// 					{
		// 						Annotation: to.Ptr("annotation"),
		// 						Prefix: to.Ptr("10.0.0.0/24"),
		// 				}},
		// 				ConnectedIPv6Subnets: []*armmanagednetworkfabric.ConnectedSubnet{
		// 					{
		// 						Annotation: to.Ptr("annotation"),
		// 						Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
		// 				}},
		// 				EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 				ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicy{
		// 					ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 					ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				},
		// 				ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicy{
		// 					ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 					ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				},
		// 				ImportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 				IsMonitoringEnabled: to.Ptr(armmanagednetworkfabric.IsMonitoringEnabledTrue),
		// 				Mtu: to.Ptr[int32](1500),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				BgpConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesBgpConfiguration{
		// 					Annotation: to.Ptr("annotation"),
		// 					AllowAS: to.Ptr[int32](10),
		// 					AllowASOverride: to.Ptr(armmanagednetworkfabric.AllowASOverrideEnable),
		// 					BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 						IntervalInMilliSeconds: to.Ptr[int32](300),
		// 						Multiplier: to.Ptr[int32](5),
		// 					},
		// 					DefaultRouteOriginate: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
		// 					FabricASN: to.Ptr[int64](20),
		// 					IPv4ListenRangePrefixes: []*string{
		// 						to.Ptr("10.1.0.0/25")},
		// 						IPv4NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
		// 							{
		// 								Address: to.Ptr("10.1.0.0"),
		// 								ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 						}},
		// 						IPv6ListenRangePrefixes: []*string{
		// 							to.Ptr("2fff::/66")},
		// 							IPv6NeighborAddress: []*armmanagednetworkfabric.NeighborAddress{
		// 								{
		// 									Address: to.Ptr("2fff::"),
		// 									ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 							}},
		// 							PeerASN: to.Ptr[int64](61234),
		// 						},
		// 						ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 						StaticRouteConfiguration: &armmanagednetworkfabric.InternalNetworkPropertiesStaticRouteConfiguration{
		// 							Extension: to.Ptr(armmanagednetworkfabric.ExtensionNoExtension),
		// 							BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 								AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 								IntervalInMilliSeconds: to.Ptr[int32](300),
		// 								Multiplier: to.Ptr[int32](15),
		// 							},
		// 							IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
		// 								{
		// 									NextHop: []*string{
		// 										to.Ptr("10.0.0.1")},
		// 										Prefix: to.Ptr("jffgck"),
		// 								}},
		// 								IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
		// 									{
		// 										NextHop: []*string{
		// 											to.Ptr("3ffe::1")},
		// 											Prefix: to.Ptr("2fff::/64"),
		// 									}},
		// 								},
		// 								VlanID: to.Ptr[int32](755),
		// 							},
		// 					}},
		// 				}
	}
}

Output:

type InternalNetworksClientBeginCreateOptions 

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

InternalNetworksClientBeginCreateOptions contains the optional parameters for the InternalNetworksClient.BeginCreate method.

type InternalNetworksClientBeginDeleteOptions 

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

InternalNetworksClientBeginDeleteOptions contains the optional parameters for the InternalNetworksClient.BeginDelete method.

type InternalNetworksClientBeginUpdateAdministrativeStateOptions 

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

InternalNetworksClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdateAdministrativeState method.

type InternalNetworksClientBeginUpdateBgpAdministrativeStateOptions 

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

InternalNetworksClientBeginUpdateBgpAdministrativeStateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdateBgpAdministrativeState method.

type InternalNetworksClientBeginUpdateOptions 

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

InternalNetworksClientBeginUpdateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdate method.

type InternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions 

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

InternalNetworksClientBeginUpdateStaticRouteBfdAdministrativeStateOptions contains the optional parameters for the InternalNetworksClient.BeginUpdateStaticRouteBfdAdministrativeState method.

type InternalNetworksClientCreateResponse 

type InternalNetworksClientCreateResponse struct {
	// Defines the Internal Network resource.
	InternalNetwork
}

InternalNetworksClientCreateResponse contains the response from method InternalNetworksClient.BeginCreate.

type InternalNetworksClientDeleteResponse 

type InternalNetworksClientDeleteResponse struct {
}

InternalNetworksClientDeleteResponse contains the response from method InternalNetworksClient.BeginDelete.

type InternalNetworksClientGetOptions 

type InternalNetworksClientGetOptions struct {
}

InternalNetworksClientGetOptions contains the optional parameters for the InternalNetworksClient.Get method.

type InternalNetworksClientGetResponse 

type InternalNetworksClientGetResponse struct {
	// Defines the Internal Network resource.
	InternalNetwork
}

InternalNetworksClientGetResponse contains the response from method InternalNetworksClient.Get.

type InternalNetworksClientListByL3IsolationDomainOptions 

type InternalNetworksClientListByL3IsolationDomainOptions struct {
}

InternalNetworksClientListByL3IsolationDomainOptions contains the optional parameters for the InternalNetworksClient.NewListByL3IsolationDomainPager method.

type InternalNetworksClientListByL3IsolationDomainResponse 

type InternalNetworksClientListByL3IsolationDomainResponse struct {
	// List of Internal Networks.
	InternalNetworksList
}

InternalNetworksClientListByL3IsolationDomainResponse contains the response from method InternalNetworksClient.NewListByL3IsolationDomainPager.

type InternalNetworksClientUpdateAdministrativeStateResponse 

type InternalNetworksClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

InternalNetworksClientUpdateAdministrativeStateResponse contains the response from method InternalNetworksClient.BeginUpdateAdministrativeState.

type InternalNetworksClientUpdateBgpAdministrativeStateResponse 

type InternalNetworksClientUpdateBgpAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

InternalNetworksClientUpdateBgpAdministrativeStateResponse contains the response from method InternalNetworksClient.BeginUpdateBgpAdministrativeState.

type InternalNetworksClientUpdateResponse 

type InternalNetworksClientUpdateResponse struct {
	// Defines the Internal Network resource.
	InternalNetwork
}

InternalNetworksClientUpdateResponse contains the response from method InternalNetworksClient.BeginUpdate.

type InternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse 

type InternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

InternalNetworksClientUpdateStaticRouteBfdAdministrativeStateResponse contains the response from method InternalNetworksClient.BeginUpdateStaticRouteBfdAdministrativeState.

type InternalNetworksList 

type InternalNetworksList struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Internal Network resources.
	Value []*InternalNetwork
}

InternalNetworksList - List of Internal Networks.

func (InternalNetworksList) MarshalJSON 

func (i InternalNetworksList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternalNetworksList.

func (*InternalNetworksList) UnmarshalJSON 

func (i *InternalNetworksList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternalNetworksList.

type InternetGateway 

type InternetGateway struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *InternetGatewayProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

InternetGateway - The Internet Gateway resource definition.

func (InternetGateway) MarshalJSON 

func (i InternetGateway) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGateway.

func (*InternetGateway) UnmarshalJSON 

func (i *InternetGateway) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGateway.

type InternetGatewayPatch 

type InternetGatewayPatch struct {
	// Resource properties.
	Properties *InternetGatewayPatchableProperties

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

InternetGatewayPatch - The Internet Gateway patch resource definition.

func (InternetGatewayPatch) MarshalJSON 

func (i InternetGatewayPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayPatch.

func (*InternetGatewayPatch) UnmarshalJSON 

func (i *InternetGatewayPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayPatch.

type InternetGatewayPatchableProperties 

type InternetGatewayPatchableProperties struct {
	// ARM Resource ID of the Internet Gateway Rule.
	InternetGatewayRuleID *string
}

InternetGatewayPatchableProperties - Internet Gateway Patchable Properties defines the patchable properties of the resource.

func (InternetGatewayPatchableProperties) MarshalJSON 

func (i InternetGatewayPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayPatchableProperties.

func (*InternetGatewayPatchableProperties) UnmarshalJSON 

func (i *InternetGatewayPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayPatchableProperties.

type InternetGatewayProperties 

type InternetGatewayProperties struct {
	// REQUIRED; ARM Resource ID of the Network Fabric Controller.
	NetworkFabricControllerID *string

	// REQUIRED; Gateway Type of the resource.
	Type *GatewayType

	// Switch configuration description.
	Annotation *string

	// ARM Resource ID of the Internet Gateway Rule.
	InternetGatewayRuleID *string

	// READ-ONLY; IPv4 Address of Internet Gateway.
	IPv4Address *string

	// READ-ONLY; Port number of Internet Gateway.
	Port *int32

	// READ-ONLY; Provisioning state of resource.
	ProvisioningState *ProvisioningState
}

InternetGatewayProperties - Internet Gateway Properties defines the properties of the resource.

func (InternetGatewayProperties) MarshalJSON 

func (i InternetGatewayProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayProperties.

func (*InternetGatewayProperties) UnmarshalJSON 

func (i *InternetGatewayProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayProperties.

type InternetGatewayRule 

type InternetGatewayRule struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *InternetGatewayRuleProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

InternetGatewayRule - The Internet Gateway Rule resource definition.

func (InternetGatewayRule) MarshalJSON 

func (i InternetGatewayRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayRule.

func (*InternetGatewayRule) UnmarshalJSON 

func (i *InternetGatewayRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayRule.

type InternetGatewayRulePatch 

type InternetGatewayRulePatch struct {
	// Resource tags
	Tags map[string]*string
}

InternetGatewayRulePatch - The Internet Gateway Rules patch resource definition.

func (InternetGatewayRulePatch) MarshalJSON 

func (i InternetGatewayRulePatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayRulePatch.

func (*InternetGatewayRulePatch) UnmarshalJSON 

func (i *InternetGatewayRulePatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayRulePatch.

type InternetGatewayRuleProperties 

type InternetGatewayRuleProperties struct {
	// REQUIRED; Rules for the InternetGateways
	RuleProperties *RuleProperties

	// Switch configuration description.
	Annotation *string

	// READ-ONLY; List of Internet Gateway resource Id.
	InternetGatewayIDs []*string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

InternetGatewayRuleProperties - Internet Gateway Rule Properties defines the resource properties.

func (InternetGatewayRuleProperties) MarshalJSON 

func (i InternetGatewayRuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayRuleProperties.

func (*InternetGatewayRuleProperties) UnmarshalJSON 

func (i *InternetGatewayRuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayRuleProperties.

type InternetGatewayRulesClient 

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

InternetGatewayRulesClient contains the methods for the InternetGatewayRules group. Don't use this type directly, use NewInternetGatewayRulesClient() instead.

func NewInternetGatewayRulesClient 

func NewInternetGatewayRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*InternetGatewayRulesClient, error)

NewInternetGatewayRulesClient creates a new instance of InternetGatewayRulesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*InternetGatewayRulesClient) BeginCreate 

func (client *InternetGatewayRulesClient) BeginCreate(ctx context.Context, resourceGroupName string, internetGatewayRuleName string, body InternetGatewayRule, options *InternetGatewayRulesClientBeginCreateOptions) (*runtime.Poller[InternetGatewayRulesClientCreateResponse], error)

BeginCreate - Creates an Internet Gateway rule resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayRuleName - Name of the Internet Gateway rule.
  • body - Request payload.
  • options - InternetGatewayRulesClientBeginCreateOptions contains the optional parameters for the InternetGatewayRulesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGatewayRules_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternetGatewayRulesClient().BeginCreate(ctx, "example-rg", "example-internetGatewayRule", armmanagednetworkfabric.InternetGatewayRule{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.InternetGatewayRuleProperties{
			Annotation: to.Ptr("annotationValue"),
			RuleProperties: &armmanagednetworkfabric.RuleProperties{
				Action: to.Ptr(armmanagednetworkfabric.ActionAllow),
				AddressList: []*string{
					to.Ptr("10.10.10.10")},
			},
		},
	}, 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.InternetGatewayRule = armmanagednetworkfabric.InternetGatewayRule{
	// 	Name: to.Ptr("example-internetGatewayRule"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/internetGatewayRules"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-InternetGatewayRule"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternetGatewayRuleProperties{
	// 		Annotation: to.Ptr("annotationValue"),
	// 		InternetGatewayIDs: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			RuleProperties: &armmanagednetworkfabric.RuleProperties{
	// 				Action: to.Ptr(armmanagednetworkfabric.ActionAllow),
	// 				AddressList: []*string{
	// 					to.Ptr("10.10.10.10")},
	// 				},
	// 			},
	// 		}
}

Output:

func (*InternetGatewayRulesClient) BeginDelete 

func (client *InternetGatewayRulesClient) BeginDelete(ctx context.Context, resourceGroupName string, internetGatewayRuleName string, options *InternetGatewayRulesClientBeginDeleteOptions) (*runtime.Poller[InternetGatewayRulesClientDeleteResponse], error)

BeginDelete - Implements Internet Gateway Rules DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayRuleName - Name of the Internet Gateway rule.
  • options - InternetGatewayRulesClientBeginDeleteOptions contains the optional parameters for the InternetGatewayRulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGatewayRules_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternetGatewayRulesClient().BeginDelete(ctx, "example-rg", "example-internetGatewayRule", 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)
	}
}

Output:

func (*InternetGatewayRulesClient) BeginUpdate 

func (client *InternetGatewayRulesClient) BeginUpdate(ctx context.Context, resourceGroupName string, internetGatewayRuleName string, body InternetGatewayRulePatch, options *InternetGatewayRulesClientBeginUpdateOptions) (*runtime.Poller[InternetGatewayRulesClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the Internet Gateway Rule resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayRuleName - Name of the Internet Gateway rule.
  • body - Internet Gateway Rule properties to update.
  • options - InternetGatewayRulesClientBeginUpdateOptions contains the optional parameters for the InternetGatewayRulesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGatewayRules_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternetGatewayRulesClient().BeginUpdate(ctx, "example-rg", "example-internetGatewayRule", armmanagednetworkfabric.InternetGatewayRulePatch{
		Tags: map[string]*string{
			"key3311": to.Ptr("1234"),
		},
	}, 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.InternetGatewayRule = armmanagednetworkfabric.InternetGatewayRule{
	// 	Name: to.Ptr("example-internetGatewayRule"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/internetGatewayRules"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-InternetGatewayRule"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key3311": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternetGatewayRuleProperties{
	// 		Annotation: to.Ptr("annotationValue"),
	// 		InternetGatewayIDs: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			RuleProperties: &armmanagednetworkfabric.RuleProperties{
	// 				Action: to.Ptr(armmanagednetworkfabric.ActionAllow),
	// 				AddressList: []*string{
	// 					to.Ptr("10.10.10.10")},
	// 				},
	// 			},
	// 		}
}

Output:

func (*InternetGatewayRulesClient) Get 

func (client *InternetGatewayRulesClient) Get(ctx context.Context, resourceGroupName string, internetGatewayRuleName string, options *InternetGatewayRulesClientGetOptions) (InternetGatewayRulesClientGetResponse, error)

Get - Gets an Internet Gateway Rule resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayRuleName - Name of the Internet Gateway rule.
  • options - InternetGatewayRulesClientGetOptions contains the optional parameters for the InternetGatewayRulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGatewayRules_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewInternetGatewayRulesClient().Get(ctx, "example-rg", "example-internetGatewayRule", 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.InternetGatewayRule = armmanagednetworkfabric.InternetGatewayRule{
	// 	Name: to.Ptr("example-internetGatewayRule"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/internetGatewayRules"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-InternetGatewayRule"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternetGatewayRuleProperties{
	// 		Annotation: to.Ptr("annotationValue"),
	// 		InternetGatewayIDs: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			RuleProperties: &armmanagednetworkfabric.RuleProperties{
	// 				Action: to.Ptr(armmanagednetworkfabric.ActionAllow),
	// 				AddressList: []*string{
	// 					to.Ptr("10.10.10.10")},
	// 				},
	// 			},
	// 		}
}

Output:

func (*InternetGatewayRulesClient) NewListByResourceGroupPager 

func (client *InternetGatewayRulesClient) NewListByResourceGroupPager(resourceGroupName string, options *InternetGatewayRulesClientListByResourceGroupOptions) *runtime.Pager[InternetGatewayRulesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Implements Internet Gateway Rules list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - InternetGatewayRulesClientListByResourceGroupOptions contains the optional parameters for the InternetGatewayRulesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGatewayRules_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInternetGatewayRulesClient().NewListByResourceGroupPager("example-internetGatewayRule", 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.InternetGatewayRulesListResult = armmanagednetworkfabric.InternetGatewayRulesListResult{
		// 	Value: []*armmanagednetworkfabric.InternetGatewayRule{
		// 		{
		// 			Name: to.Ptr("example-internetGatewayRule"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/internetGatewayRules"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-InternetGatewayRule"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.InternetGatewayRuleProperties{
		// 				Annotation: to.Ptr("annotationValue"),
		// 				InternetGatewayIDs: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 					RuleProperties: &armmanagednetworkfabric.RuleProperties{
		// 						Action: to.Ptr(armmanagednetworkfabric.ActionAllow),
		// 						AddressList: []*string{
		// 							to.Ptr("10.10.10.10")},
		// 						},
		// 					},
		// 			}},
		// 		}
	}
}

Output:

func (*InternetGatewayRulesClient) NewListBySubscriptionPager 

func (client *InternetGatewayRulesClient) NewListBySubscriptionPager(options *InternetGatewayRulesClientListBySubscriptionOptions) *runtime.Pager[InternetGatewayRulesClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all Internet Gateway rules in the given subscription.

Generated from API version 2023-06-15

  • options - InternetGatewayRulesClientListBySubscriptionOptions contains the optional parameters for the InternetGatewayRulesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGatewayRules_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInternetGatewayRulesClient().NewListBySubscriptionPager(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.InternetGatewayRulesListResult = armmanagednetworkfabric.InternetGatewayRulesListResult{
		// 	Value: []*armmanagednetworkfabric.InternetGatewayRule{
		// 		{
		// 			Name: to.Ptr("example-internetGatewayRule"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/internetGatewayRules"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-InternetGatewayRule"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-24T18:22:51.443Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.InternetGatewayRuleProperties{
		// 				Annotation: to.Ptr("annotationValue"),
		// 				InternetGatewayIDs: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 					RuleProperties: &armmanagednetworkfabric.RuleProperties{
		// 						Action: to.Ptr(armmanagednetworkfabric.ActionAllow),
		// 						AddressList: []*string{
		// 							to.Ptr("10.10.10.10")},
		// 						},
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type InternetGatewayRulesClientBeginCreateOptions 

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

InternetGatewayRulesClientBeginCreateOptions contains the optional parameters for the InternetGatewayRulesClient.BeginCreate method.

type InternetGatewayRulesClientBeginDeleteOptions 

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

InternetGatewayRulesClientBeginDeleteOptions contains the optional parameters for the InternetGatewayRulesClient.BeginDelete method.

type InternetGatewayRulesClientBeginUpdateOptions 

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

InternetGatewayRulesClientBeginUpdateOptions contains the optional parameters for the InternetGatewayRulesClient.BeginUpdate method.

type InternetGatewayRulesClientCreateResponse 

type InternetGatewayRulesClientCreateResponse struct {
	// The Internet Gateway Rule resource definition.
	InternetGatewayRule
}

InternetGatewayRulesClientCreateResponse contains the response from method InternetGatewayRulesClient.BeginCreate.

type InternetGatewayRulesClientDeleteResponse 

type InternetGatewayRulesClientDeleteResponse struct {
}

InternetGatewayRulesClientDeleteResponse contains the response from method InternetGatewayRulesClient.BeginDelete.

type InternetGatewayRulesClientGetOptions 

type InternetGatewayRulesClientGetOptions struct {
}

InternetGatewayRulesClientGetOptions contains the optional parameters for the InternetGatewayRulesClient.Get method.

type InternetGatewayRulesClientGetResponse 

type InternetGatewayRulesClientGetResponse struct {
	// The Internet Gateway Rule resource definition.
	InternetGatewayRule
}

InternetGatewayRulesClientGetResponse contains the response from method InternetGatewayRulesClient.Get.

type InternetGatewayRulesClientListByResourceGroupOptions 

type InternetGatewayRulesClientListByResourceGroupOptions struct {
}

InternetGatewayRulesClientListByResourceGroupOptions contains the optional parameters for the InternetGatewayRulesClient.NewListByResourceGroupPager method.

type InternetGatewayRulesClientListByResourceGroupResponse 

type InternetGatewayRulesClientListByResourceGroupResponse struct {
	// List of Internet Gateway Rules.
	InternetGatewayRulesListResult
}

InternetGatewayRulesClientListByResourceGroupResponse contains the response from method InternetGatewayRulesClient.NewListByResourceGroupPager.

type InternetGatewayRulesClientListBySubscriptionOptions 

type InternetGatewayRulesClientListBySubscriptionOptions struct {
}

InternetGatewayRulesClientListBySubscriptionOptions contains the optional parameters for the InternetGatewayRulesClient.NewListBySubscriptionPager method.

type InternetGatewayRulesClientListBySubscriptionResponse 

type InternetGatewayRulesClientListBySubscriptionResponse struct {
	// List of Internet Gateway Rules.
	InternetGatewayRulesListResult
}

InternetGatewayRulesClientListBySubscriptionResponse contains the response from method InternetGatewayRulesClient.NewListBySubscriptionPager.

type InternetGatewayRulesClientUpdateResponse 

type InternetGatewayRulesClientUpdateResponse struct {
	// The Internet Gateway Rule resource definition.
	InternetGatewayRule
}

InternetGatewayRulesClientUpdateResponse contains the response from method InternetGatewayRulesClient.BeginUpdate.

type InternetGatewayRulesListResult 

type InternetGatewayRulesListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Internet Gateway Rule resources.
	Value []*InternetGatewayRule
}

InternetGatewayRulesListResult - List of Internet Gateway Rules.

func (InternetGatewayRulesListResult) MarshalJSON 

func (i InternetGatewayRulesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewayRulesListResult.

func (*InternetGatewayRulesListResult) UnmarshalJSON 

func (i *InternetGatewayRulesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewayRulesListResult.

type InternetGatewaysClient 

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

InternetGatewaysClient contains the methods for the InternetGateways group. Don't use this type directly, use NewInternetGatewaysClient() instead.

func NewInternetGatewaysClient 

func NewInternetGatewaysClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*InternetGatewaysClient, error)

NewInternetGatewaysClient creates a new instance of InternetGatewaysClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*InternetGatewaysClient) BeginCreate 

func (client *InternetGatewaysClient) BeginCreate(ctx context.Context, resourceGroupName string, internetGatewayName string, body InternetGateway, options *InternetGatewaysClientBeginCreateOptions) (*runtime.Poller[InternetGatewaysClientCreateResponse], error)

BeginCreate - Creates a Network Fabric Service Internet Gateway resource instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayName - Name of the Internet Gateway.
  • body - Request payload.
  • options - InternetGatewaysClientBeginCreateOptions contains the optional parameters for the InternetGatewaysClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGateways_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternetGatewaysClient().BeginCreate(ctx, "example-rg", "example-internetGateway", armmanagednetworkfabric.InternetGateway{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"key3540": to.Ptr("1234"),
		},
		Properties: &armmanagednetworkfabric.InternetGatewayProperties{
			Annotation:                to.Ptr("annotation"),
			InternetGatewayRuleID:     to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
			Type:                      to.Ptr(armmanagednetworkfabric.GatewayTypeInfrastructure),
			NetworkFabricControllerID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkFabricController"),
		},
	}, 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.InternetGateway = armmanagednetworkfabric.InternetGateway{
	// 	Name: to.Ptr("example-internetGateway"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/internetGateways"),
	// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key3540": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternetGatewayProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		InternetGatewayRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
	// 		Type: to.Ptr(armmanagednetworkfabric.GatewayTypeInfrastructure),
	// 		IPv4Address: to.Ptr("10.10.10.10"),
	// 		NetworkFabricControllerID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkFabricController"),
	// 		Port: to.Ptr[int32](25),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*InternetGatewaysClient) BeginDelete 

func (client *InternetGatewaysClient) BeginDelete(ctx context.Context, resourceGroupName string, internetGatewayName string, options *InternetGatewaysClientBeginDeleteOptions) (*runtime.Poller[InternetGatewaysClientDeleteResponse], error)

BeginDelete - Execute a delete on Network Fabric Service Internet Gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayName - Name of the Internet Gateway.
  • options - InternetGatewaysClientBeginDeleteOptions contains the optional parameters for the InternetGatewaysClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGateways_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternetGatewaysClient().BeginDelete(ctx, "example-rg", "example-internetGateway", 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)
	}
}

Output:

func (*InternetGatewaysClient) BeginUpdate 

func (client *InternetGatewaysClient) BeginUpdate(ctx context.Context, resourceGroupName string, internetGatewayName string, body InternetGatewayPatch, options *InternetGatewaysClientBeginUpdateOptions) (*runtime.Poller[InternetGatewaysClientUpdateResponse], error)

BeginUpdate - Execute patch on Network Fabric Service Internet Gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayName - Name of the Internet Gateway.
  • body - API to update certain properties of the L2 Isolation Domain resource..
  • options - InternetGatewaysClientBeginUpdateOptions contains the optional parameters for the InternetGatewaysClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGateways_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInternetGatewaysClient().BeginUpdate(ctx, "example-rg", "example-internetGateway", armmanagednetworkfabric.InternetGatewayPatch{
		Tags: map[string]*string{
			"key81": to.Ptr("2345"),
		},
		Properties: &armmanagednetworkfabric.InternetGatewayPatchableProperties{
			InternetGatewayRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
		},
	}, 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.InternetGateway = armmanagednetworkfabric.InternetGateway{
	// 	Name: to.Ptr("example-internetGateway"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/internetGateways"),
	// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key3540": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternetGatewayProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		InternetGatewayRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
	// 		Type: to.Ptr(armmanagednetworkfabric.GatewayTypeInfrastructure),
	// 		IPv4Address: to.Ptr("10.10.10.10"),
	// 		NetworkFabricControllerID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkFabricController"),
	// 		Port: to.Ptr[int32](25),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*InternetGatewaysClient) Get 

func (client *InternetGatewaysClient) Get(ctx context.Context, resourceGroupName string, internetGatewayName string, options *InternetGatewaysClientGetOptions) (InternetGatewaysClientGetResponse, error)

Get - Implements Gateway GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • internetGatewayName - Name of the Internet Gateway.
  • options - InternetGatewaysClientGetOptions contains the optional parameters for the InternetGatewaysClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGateways_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewInternetGatewaysClient().Get(ctx, "example-rg", "example-internetGateway", 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.InternetGateway = armmanagednetworkfabric.InternetGateway{
	// 	Name: to.Ptr("example-internetGateway"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/internetGateways"),
	// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key3540": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.InternetGatewayProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		InternetGatewayRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
	// 		Type: to.Ptr(armmanagednetworkfabric.GatewayTypeInfrastructure),
	// 		IPv4Address: to.Ptr("10.10.10.10"),
	// 		NetworkFabricControllerID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkFabricController"),
	// 		Port: to.Ptr[int32](25),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*InternetGatewaysClient) NewListByResourceGroupPager 

func (client *InternetGatewaysClient) NewListByResourceGroupPager(resourceGroupName string, options *InternetGatewaysClientListByResourceGroupOptions) *runtime.Pager[InternetGatewaysClientListByResourceGroupResponse]

NewListByResourceGroupPager - Displays Internet Gateways list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - InternetGatewaysClientListByResourceGroupOptions contains the optional parameters for the InternetGatewaysClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGateways_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInternetGatewaysClient().NewListByResourceGroupPager("example-rg", 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.InternetGatewaysListResult = armmanagednetworkfabric.InternetGatewaysListResult{
		// 	Value: []*armmanagednetworkfabric.InternetGateway{
		// 		{
		// 			Name: to.Ptr("example-internetGateway"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/internetGateways"),
		// 			ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"key3540": to.Ptr("1234"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.InternetGatewayProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				InternetGatewayRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
		// 				Type: to.Ptr(armmanagednetworkfabric.GatewayTypeInfrastructure),
		// 				IPv4Address: to.Ptr("10.10.10.10"),
		// 				NetworkFabricControllerID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkFabricController"),
		// 				Port: to.Ptr[int32](25),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*InternetGatewaysClient) NewListBySubscriptionPager 

func (client *InternetGatewaysClient) NewListBySubscriptionPager(options *InternetGatewaysClientListBySubscriptionOptions) *runtime.Pager[InternetGatewaysClientListBySubscriptionResponse]

NewListBySubscriptionPager - Displays Internet Gateways list by subscription GET method.

Generated from API version 2023-06-15

  • options - InternetGatewaysClientListBySubscriptionOptions contains the optional parameters for the InternetGatewaysClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/InternetGateways_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInternetGatewaysClient().NewListBySubscriptionPager(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.InternetGatewaysListResult = armmanagednetworkfabric.InternetGatewaysListResult{
		// 	Value: []*armmanagednetworkfabric.InternetGateway{
		// 		{
		// 			Name: to.Ptr("example-internetGateway"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/internetGateways"),
		// 			ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T14:51:13.501Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"key3540": to.Ptr("1234"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.InternetGatewayProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				InternetGatewayRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/providers/Microsoft.ManagedNetworkFabric/internetGatewayRules/example-internetGatewayRule"),
		// 				Type: to.Ptr(armmanagednetworkfabric.GatewayTypeInfrastructure),
		// 				IPv4Address: to.Ptr("10.10.10.10"),
		// 				NetworkFabricControllerID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkFabricController"),
		// 				Port: to.Ptr[int32](25),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

type InternetGatewaysClientBeginCreateOptions 

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

InternetGatewaysClientBeginCreateOptions contains the optional parameters for the InternetGatewaysClient.BeginCreate method.

type InternetGatewaysClientBeginDeleteOptions 

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

InternetGatewaysClientBeginDeleteOptions contains the optional parameters for the InternetGatewaysClient.BeginDelete method.

type InternetGatewaysClientBeginUpdateOptions 

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

InternetGatewaysClientBeginUpdateOptions contains the optional parameters for the InternetGatewaysClient.BeginUpdate method.

type InternetGatewaysClientCreateResponse 

type InternetGatewaysClientCreateResponse struct {
	// The Internet Gateway resource definition.
	InternetGateway
}

InternetGatewaysClientCreateResponse contains the response from method InternetGatewaysClient.BeginCreate.

type InternetGatewaysClientDeleteResponse 

type InternetGatewaysClientDeleteResponse struct {
}

InternetGatewaysClientDeleteResponse contains the response from method InternetGatewaysClient.BeginDelete.

type InternetGatewaysClientGetOptions 

type InternetGatewaysClientGetOptions struct {
}

InternetGatewaysClientGetOptions contains the optional parameters for the InternetGatewaysClient.Get method.

type InternetGatewaysClientGetResponse 

type InternetGatewaysClientGetResponse struct {
	// The Internet Gateway resource definition.
	InternetGateway
}

InternetGatewaysClientGetResponse contains the response from method InternetGatewaysClient.Get.

type InternetGatewaysClientListByResourceGroupOptions 

type InternetGatewaysClientListByResourceGroupOptions struct {
}

InternetGatewaysClientListByResourceGroupOptions contains the optional parameters for the InternetGatewaysClient.NewListByResourceGroupPager method.

type InternetGatewaysClientListByResourceGroupResponse 

type InternetGatewaysClientListByResourceGroupResponse struct {
	// List of InternetGateways.
	InternetGatewaysListResult
}

InternetGatewaysClientListByResourceGroupResponse contains the response from method InternetGatewaysClient.NewListByResourceGroupPager.

type InternetGatewaysClientListBySubscriptionOptions 

type InternetGatewaysClientListBySubscriptionOptions struct {
}

InternetGatewaysClientListBySubscriptionOptions contains the optional parameters for the InternetGatewaysClient.NewListBySubscriptionPager method.

type InternetGatewaysClientListBySubscriptionResponse 

type InternetGatewaysClientListBySubscriptionResponse struct {
	// List of InternetGateways.
	InternetGatewaysListResult
}

InternetGatewaysClientListBySubscriptionResponse contains the response from method InternetGatewaysClient.NewListBySubscriptionPager.

type InternetGatewaysClientUpdateResponse 

type InternetGatewaysClientUpdateResponse struct {
	// The Internet Gateway resource definition.
	InternetGateway
}

InternetGatewaysClientUpdateResponse contains the response from method InternetGatewaysClient.BeginUpdate.

type InternetGatewaysListResult 

type InternetGatewaysListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// Displays list of Internet Gateway resources.
	Value []*InternetGateway
}

InternetGatewaysListResult - List of InternetGateways.

func (InternetGatewaysListResult) MarshalJSON 

func (i InternetGatewaysListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InternetGatewaysListResult.

func (*InternetGatewaysListResult) UnmarshalJSON 

func (i *InternetGatewaysListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InternetGatewaysListResult.

type IsManagementType 

type IsManagementType string

IsManagementType - Configuration to use NNI for Infrastructure Management. Example: True/False. 

const (
	IsManagementTypeFalse IsManagementType = "False"
	IsManagementTypeTrue  IsManagementType = "True"
)

func PossibleIsManagementTypeValues 

func PossibleIsManagementTypeValues() []IsManagementType

PossibleIsManagementTypeValues returns the possible values for the IsManagementType const type.

type IsMonitoringEnabled 

type IsMonitoringEnabled string

IsMonitoringEnabled - To check whether monitoring of internal network is enabled or not. 

const (
	IsMonitoringEnabledFalse IsMonitoringEnabled = "False"
	IsMonitoringEnabledTrue  IsMonitoringEnabled = "True"
)

func PossibleIsMonitoringEnabledValues 

func PossibleIsMonitoringEnabledValues() []IsMonitoringEnabled

PossibleIsMonitoringEnabledValues returns the possible values for the IsMonitoringEnabled const type.

type IsWorkloadManagementNetworkEnabled 

type IsWorkloadManagementNetworkEnabled string

IsWorkloadManagementNetworkEnabled - A workload management network is required for all the tenant (workload) traffic. This traffic is only dedicated for Tenant workloads which are required to access internet or any other MSFT/Public endpoints. 

const (
	IsWorkloadManagementNetworkEnabledFalse IsWorkloadManagementNetworkEnabled = "False"
	IsWorkloadManagementNetworkEnabledTrue  IsWorkloadManagementNetworkEnabled = "True"
)

func PossibleIsWorkloadManagementNetworkEnabledValues 

func PossibleIsWorkloadManagementNetworkEnabledValues() []IsWorkloadManagementNetworkEnabled

PossibleIsWorkloadManagementNetworkEnabledValues returns the possible values for the IsWorkloadManagementNetworkEnabled const type.

type IsolationDomainProperties 

type IsolationDomainProperties struct {
	// Type of encapsulation.
	Encapsulation *Encapsulation

	// List of Neighbor Group IDs.
	NeighborGroupIDs []*string
}

IsolationDomainProperties - Isolation Domain Properties.

func (IsolationDomainProperties) MarshalJSON 

func (i IsolationDomainProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IsolationDomainProperties.

func (*IsolationDomainProperties) UnmarshalJSON 

func (i *IsolationDomainProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IsolationDomainProperties.

type L2IsolationDomain 

type L2IsolationDomain struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *L2IsolationDomainProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

L2IsolationDomain - The L2 Isolation Domain resource definition.

func (L2IsolationDomain) MarshalJSON 

func (l L2IsolationDomain) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L2IsolationDomain.

func (*L2IsolationDomain) UnmarshalJSON 

func (l *L2IsolationDomain) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L2IsolationDomain.

type L2IsolationDomainPatch 

type L2IsolationDomainPatch struct {
	// Resource properties.
	Properties *L2IsolationDomainPatchProperties

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

L2IsolationDomainPatch - The L2 Isolation Domain patch resource definition.

func (L2IsolationDomainPatch) MarshalJSON 

func (l L2IsolationDomainPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L2IsolationDomainPatch.

func (*L2IsolationDomainPatch) UnmarshalJSON 

func (l *L2IsolationDomainPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L2IsolationDomainPatch.

type L2IsolationDomainPatchProperties 

type L2IsolationDomainPatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// Maximum transmission unit. Default value is 1500.
	Mtu *int32
}

L2IsolationDomainPatchProperties - L2 Isolation Domain Patch Properties defines the patchable properties of the resource.

func (L2IsolationDomainPatchProperties) MarshalJSON 

func (l L2IsolationDomainPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L2IsolationDomainPatchProperties.

func (*L2IsolationDomainPatchProperties) UnmarshalJSON 

func (l *L2IsolationDomainPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L2IsolationDomainPatchProperties.

type L2IsolationDomainProperties 

type L2IsolationDomainProperties struct {
	// REQUIRED; ARM Resource ID of the Network Fabric.
	NetworkFabricID *string

	// REQUIRED; Vlan Identifier of the Network Fabric. Example: 501.
	VlanID *int32

	// Switch configuration description.
	Annotation *string

	// Maximum transmission unit. Default value is 1500.
	Mtu *int32

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

L2IsolationDomainProperties - L2Isolation Domain Properties defines the properties of the resource.

func (L2IsolationDomainProperties) MarshalJSON 

func (l L2IsolationDomainProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L2IsolationDomainProperties.

func (*L2IsolationDomainProperties) UnmarshalJSON 

func (l *L2IsolationDomainProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L2IsolationDomainProperties.

type L2IsolationDomainsClient 

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

L2IsolationDomainsClient contains the methods for the L2IsolationDomains group. Don't use this type directly, use NewL2IsolationDomainsClient() instead.

func NewL2IsolationDomainsClient 

func NewL2IsolationDomainsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*L2IsolationDomainsClient, error)

NewL2IsolationDomainsClient creates a new instance of L2IsolationDomainsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*L2IsolationDomainsClient) BeginCommitConfiguration 

func (client *L2IsolationDomainsClient) BeginCommitConfiguration(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, options *L2IsolationDomainsClientBeginCommitConfigurationOptions) (*runtime.Poller[L2IsolationDomainsClientCommitConfigurationResponse], error)

BeginCommitConfiguration - Commits the configuration of the given resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • options - L2IsolationDomainsClientBeginCommitConfigurationOptions contains the optional parameters for the L2IsolationDomainsClient.BeginCommitConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_CommitConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL2IsolationDomainsClient().BeginCommitConfiguration(ctx, "example-rg", "example-l2domain", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*L2IsolationDomainsClient) BeginCreate 

func (client *L2IsolationDomainsClient) BeginCreate(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, body L2IsolationDomain, options *L2IsolationDomainsClientBeginCreateOptions) (*runtime.Poller[L2IsolationDomainsClientCreateResponse], error)

BeginCreate - Creates layer 2 network connectivity between compute nodes within a rack and across racks.The configuration is applied on the devices only after the isolation domain is enabled. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • body - Request payload.
  • options - L2IsolationDomainsClientBeginCreateOptions contains the optional parameters for the L2IsolationDomainsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL2IsolationDomainsClient().BeginCreate(ctx, "example-rg", "example-l2domain", armmanagednetworkfabric.L2IsolationDomain{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.L2IsolationDomainProperties{
			Annotation:      to.Ptr("annotation"),
			Mtu:             to.Ptr[int32](1500),
			NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
			VlanID:          to.Ptr[int32](501),
		},
	}, 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.L2IsolationDomain = armmanagednetworkfabric.L2IsolationDomain{
	// 	Name: to.Ptr("example-l2domain"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l2IsolationDomains"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2domain"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.977Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.978Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.L2IsolationDomainProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		Mtu: to.Ptr[int32](1500),
	// 		NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		VlanID: to.Ptr[int32](501),
	// 	},
	// }
}

Output:

func (*L2IsolationDomainsClient) BeginDelete 

func (client *L2IsolationDomainsClient) BeginDelete(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, options *L2IsolationDomainsClientBeginDeleteOptions) (*runtime.Poller[L2IsolationDomainsClientDeleteResponse], error)

BeginDelete - Deletes layer 2 connectivity between compute nodes by managed by named L2 Isolation name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • options - L2IsolationDomainsClientBeginDeleteOptions contains the optional parameters for the L2IsolationDomainsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL2IsolationDomainsClient().BeginDelete(ctx, "example-rg", "example-l2Domain", 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)
	}
}

Output:

func (*L2IsolationDomainsClient) BeginUpdate 

func (client *L2IsolationDomainsClient) BeginUpdate(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, body L2IsolationDomainPatch, options *L2IsolationDomainsClientBeginUpdateOptions) (*runtime.Poller[L2IsolationDomainsClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the L2 Isolation Domain resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • body - API to update certain properties of the L2 Isolation Domain resource..
  • options - L2IsolationDomainsClientBeginUpdateOptions contains the optional parameters for the L2IsolationDomainsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL2IsolationDomainsClient().BeginUpdate(ctx, "example-rg", "example-l2Domain", armmanagednetworkfabric.L2IsolationDomainPatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.L2IsolationDomainPatchProperties{
			Annotation: to.Ptr("annotation1"),
			Mtu:        to.Ptr[int32](6000),
		},
	}, 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.L2IsolationDomain = armmanagednetworkfabric.L2IsolationDomain{
	// 	Name: to.Ptr("example-l2domain"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l2IsolationDomains"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2domain"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.977Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.978Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.L2IsolationDomainProperties{
	// 		Annotation: to.Ptr("annotation1"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		Mtu: to.Ptr[int32](1500),
	// 		NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		VlanID: to.Ptr[int32](501),
	// 	},
	// }
}

Output:

func (*L2IsolationDomainsClient) BeginUpdateAdministrativeState 

func (client *L2IsolationDomainsClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, body UpdateAdministrativeState, options *L2IsolationDomainsClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[L2IsolationDomainsClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Enables isolation domain across the fabric or on specified racks. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • body - Request payload.
  • options - L2IsolationDomainsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the L2IsolationDomainsClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_updateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL2IsolationDomainsClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-l2Domain", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForDeviceUpdate = armmanagednetworkfabric.CommonPostActionResponseForDeviceUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	FailedDevices: []*string{
	// 		to.Ptr("")},
	// 		SuccessfulDevices: []*string{
	// 			to.Ptr("")},
	// 		}
}

Output:

func (*L2IsolationDomainsClient) BeginValidateConfiguration 

func (client *L2IsolationDomainsClient) BeginValidateConfiguration(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, options *L2IsolationDomainsClientBeginValidateConfigurationOptions) (*runtime.Poller[L2IsolationDomainsClientValidateConfigurationResponse], error)

BeginValidateConfiguration - Validates the configuration of the resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • options - L2IsolationDomainsClientBeginValidateConfigurationOptions contains the optional parameters for the L2IsolationDomainsClient.BeginValidateConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_ValidateConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL2IsolationDomainsClient().BeginValidateConfiguration(ctx, "example-rg", "example-l2domain", 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ActionDetails"),
	// }
}

Output:

func (*L2IsolationDomainsClient) Get 

func (client *L2IsolationDomainsClient) Get(ctx context.Context, resourceGroupName string, l2IsolationDomainName string, options *L2IsolationDomainsClientGetOptions) (L2IsolationDomainsClientGetResponse, error)

Get - Implements L2 Isolation Domain GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l2IsolationDomainName - Name of the L2 Isolation Domain.
  • options - L2IsolationDomainsClientGetOptions contains the optional parameters for the L2IsolationDomainsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewL2IsolationDomainsClient().Get(ctx, "example-rg", "example-l2Domain", 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.L2IsolationDomain = armmanagednetworkfabric.L2IsolationDomain{
	// 	Name: to.Ptr("example-l2domain"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l2IsolationDomains"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2domain"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.977Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.978Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.L2IsolationDomainProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		Mtu: to.Ptr[int32](1500),
	// 		NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		VlanID: to.Ptr[int32](501),
	// 	},
	// }
}

Output:

func (*L2IsolationDomainsClient) NewListByResourceGroupPager 

func (client *L2IsolationDomainsClient) NewListByResourceGroupPager(resourceGroupName string, options *L2IsolationDomainsClientListByResourceGroupOptions) *runtime.Pager[L2IsolationDomainsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Displays L2IsolationDomains list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - L2IsolationDomainsClientListByResourceGroupOptions contains the optional parameters for the L2IsolationDomainsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewL2IsolationDomainsClient().NewListByResourceGroupPager("example-rg", 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.L2IsolationDomainsListResult = armmanagednetworkfabric.L2IsolationDomainsListResult{
		// 	Value: []*armmanagednetworkfabric.L2IsolationDomain{
		// 		{
		// 			Name: to.Ptr("example-l2domain"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/l2IsolationDomains"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2domain"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.977Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.978Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.L2IsolationDomainProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				Mtu: to.Ptr[int32](1500),
		// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				VlanID: to.Ptr[int32](501),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*L2IsolationDomainsClient) NewListBySubscriptionPager 

func (client *L2IsolationDomainsClient) NewListBySubscriptionPager(options *L2IsolationDomainsClientListBySubscriptionOptions) *runtime.Pager[L2IsolationDomainsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Displays L2IsolationDomains list by subscription GET method.

Generated from API version 2023-06-15

  • options - L2IsolationDomainsClientListBySubscriptionOptions contains the optional parameters for the L2IsolationDomainsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L2IsolationDomains_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewL2IsolationDomainsClient().NewListBySubscriptionPager(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.L2IsolationDomainsListResult = armmanagednetworkfabric.L2IsolationDomainsListResult{
		// 	Value: []*armmanagednetworkfabric.L2IsolationDomain{
		// 		{
		// 			Name: to.Ptr("example-l2domain"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/l2IsolationDomains"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2domain"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.977Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T17:42:03.978Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.L2IsolationDomainProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				Mtu: to.Ptr[int32](1500),
		// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				VlanID: to.Ptr[int32](501),
		// 			},
		// 	}},
		// }
	}
}

Output:

type L2IsolationDomainsClientBeginCommitConfigurationOptions 

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

L2IsolationDomainsClientBeginCommitConfigurationOptions contains the optional parameters for the L2IsolationDomainsClient.BeginCommitConfiguration method.

type L2IsolationDomainsClientBeginCreateOptions 

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

L2IsolationDomainsClientBeginCreateOptions contains the optional parameters for the L2IsolationDomainsClient.BeginCreate method.

type L2IsolationDomainsClientBeginDeleteOptions 

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

L2IsolationDomainsClientBeginDeleteOptions contains the optional parameters for the L2IsolationDomainsClient.BeginDelete method.

type L2IsolationDomainsClientBeginUpdateAdministrativeStateOptions 

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

L2IsolationDomainsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the L2IsolationDomainsClient.BeginUpdateAdministrativeState method.

type L2IsolationDomainsClientBeginUpdateOptions 

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

L2IsolationDomainsClientBeginUpdateOptions contains the optional parameters for the L2IsolationDomainsClient.BeginUpdate method.

type L2IsolationDomainsClientBeginValidateConfigurationOptions 

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

L2IsolationDomainsClientBeginValidateConfigurationOptions contains the optional parameters for the L2IsolationDomainsClient.BeginValidateConfiguration method.

type L2IsolationDomainsClientCommitConfigurationResponse 

type L2IsolationDomainsClientCommitConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

L2IsolationDomainsClientCommitConfigurationResponse contains the response from method L2IsolationDomainsClient.BeginCommitConfiguration.

type L2IsolationDomainsClientCreateResponse 

type L2IsolationDomainsClientCreateResponse struct {
	// The L2 Isolation Domain resource definition.
	L2IsolationDomain
}

L2IsolationDomainsClientCreateResponse contains the response from method L2IsolationDomainsClient.BeginCreate.

type L2IsolationDomainsClientDeleteResponse 

type L2IsolationDomainsClientDeleteResponse struct {
}

L2IsolationDomainsClientDeleteResponse contains the response from method L2IsolationDomainsClient.BeginDelete.

type L2IsolationDomainsClientGetOptions 

type L2IsolationDomainsClientGetOptions struct {
}

L2IsolationDomainsClientGetOptions contains the optional parameters for the L2IsolationDomainsClient.Get method.

type L2IsolationDomainsClientGetResponse 

type L2IsolationDomainsClientGetResponse struct {
	// The L2 Isolation Domain resource definition.
	L2IsolationDomain
}

L2IsolationDomainsClientGetResponse contains the response from method L2IsolationDomainsClient.Get.

type L2IsolationDomainsClientListByResourceGroupOptions 

type L2IsolationDomainsClientListByResourceGroupOptions struct {
}

L2IsolationDomainsClientListByResourceGroupOptions contains the optional parameters for the L2IsolationDomainsClient.NewListByResourceGroupPager method.

type L2IsolationDomainsClientListByResourceGroupResponse 

type L2IsolationDomainsClientListByResourceGroupResponse struct {
	// List of L2 Isolation Domains.
	L2IsolationDomainsListResult
}

L2IsolationDomainsClientListByResourceGroupResponse contains the response from method L2IsolationDomainsClient.NewListByResourceGroupPager.

type L2IsolationDomainsClientListBySubscriptionOptions 

type L2IsolationDomainsClientListBySubscriptionOptions struct {
}

L2IsolationDomainsClientListBySubscriptionOptions contains the optional parameters for the L2IsolationDomainsClient.NewListBySubscriptionPager method.

type L2IsolationDomainsClientListBySubscriptionResponse 

type L2IsolationDomainsClientListBySubscriptionResponse struct {
	// List of L2 Isolation Domains.
	L2IsolationDomainsListResult
}

L2IsolationDomainsClientListBySubscriptionResponse contains the response from method L2IsolationDomainsClient.NewListBySubscriptionPager.

type L2IsolationDomainsClientUpdateAdministrativeStateResponse 

type L2IsolationDomainsClientUpdateAdministrativeStateResponse struct {
	// Common response for device updates.
	CommonPostActionResponseForDeviceUpdate
}

L2IsolationDomainsClientUpdateAdministrativeStateResponse contains the response from method L2IsolationDomainsClient.BeginUpdateAdministrativeState.

type L2IsolationDomainsClientUpdateResponse 

type L2IsolationDomainsClientUpdateResponse struct {
	// The L2 Isolation Domain resource definition.
	L2IsolationDomain
}

L2IsolationDomainsClientUpdateResponse contains the response from method L2IsolationDomainsClient.BeginUpdate.

type L2IsolationDomainsClientValidateConfigurationResponse 

type L2IsolationDomainsClientValidateConfigurationResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

L2IsolationDomainsClientValidateConfigurationResponse contains the response from method L2IsolationDomainsClient.BeginValidateConfiguration.

type L2IsolationDomainsListResult 

type L2IsolationDomainsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// Displays list of L2 Isolation Domain resources.
	Value []*L2IsolationDomain
}

L2IsolationDomainsListResult - List of L2 Isolation Domains.

func (L2IsolationDomainsListResult) MarshalJSON 

func (l L2IsolationDomainsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L2IsolationDomainsListResult.

func (*L2IsolationDomainsListResult) UnmarshalJSON 

func (l *L2IsolationDomainsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L2IsolationDomainsListResult.

type L3ExportRoutePolicy 

type L3ExportRoutePolicy struct {
	// ARM Resource ID of the RoutePolicy.
	ExportIPv4RoutePolicyID *string

	// ARM Resource ID of the RoutePolicy.
	ExportIPv6RoutePolicyID *string
}

L3ExportRoutePolicy - Array of ARM Resource ID of the RoutePolicies.

func (L3ExportRoutePolicy) MarshalJSON 

func (l L3ExportRoutePolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3ExportRoutePolicy.

func (*L3ExportRoutePolicy) UnmarshalJSON 

func (l *L3ExportRoutePolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3ExportRoutePolicy.

type L3IsolationDomain 

type L3IsolationDomain struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *L3IsolationDomainProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

L3IsolationDomain - The L3 Isolation Domain resource definition.

func (L3IsolationDomain) MarshalJSON 

func (l L3IsolationDomain) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3IsolationDomain.

func (*L3IsolationDomain) UnmarshalJSON 

func (l *L3IsolationDomain) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3IsolationDomain.

type L3IsolationDomainPatch 

type L3IsolationDomainPatch struct {
	// Resource properties.
	Properties *L3IsolationDomainPatchProperties

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

L3IsolationDomainPatch - The L3 Isolation Domain patch resource definition.

func (L3IsolationDomainPatch) MarshalJSON 

func (l L3IsolationDomainPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3IsolationDomainPatch.

func (*L3IsolationDomainPatch) UnmarshalJSON 

func (l *L3IsolationDomainPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3IsolationDomainPatch.

type L3IsolationDomainPatchProperties 

type L3IsolationDomainPatchProperties struct {
	// Aggregate route configurations.
	AggregateRouteConfiguration *AggregateRouteConfiguration

	// Switch configuration description.
	Annotation *string

	// Connected Subnet RoutePolicy
	ConnectedSubnetRoutePolicy *ConnectedSubnetRoutePolicy

	// Advertise Connected Subnets. Ex: "True" | "False".
	RedistributeConnectedSubnets *RedistributeConnectedSubnets

	// Advertise Static Routes. Ex: "True" | "False".
	RedistributeStaticRoutes *RedistributeStaticRoutes
}

L3IsolationDomainPatchProperties - Resource properties.

func (L3IsolationDomainPatchProperties) MarshalJSON 

func (l L3IsolationDomainPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3IsolationDomainPatchProperties.

func (*L3IsolationDomainPatchProperties) UnmarshalJSON 

func (l *L3IsolationDomainPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3IsolationDomainPatchProperties.

type L3IsolationDomainProperties 

type L3IsolationDomainProperties struct {
	// REQUIRED; ARM Resource ID of the Network Fabric.
	NetworkFabricID *string

	// Aggregate route configurations.
	AggregateRouteConfiguration *AggregateRouteConfiguration

	// Switch configuration description.
	Annotation *string

	// Connected Subnet RoutePolicy
	ConnectedSubnetRoutePolicy *ConnectedSubnetRoutePolicy

	// Advertise Connected Subnets. Ex: "True" | "False".
	RedistributeConnectedSubnets *RedistributeConnectedSubnets

	// Advertise Static Routes. Ex: "True" | "False".
	RedistributeStaticRoutes *RedistributeStaticRoutes

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

L3IsolationDomainProperties - L3 Isolation Domain Properties defines the properties of the resource.

func (L3IsolationDomainProperties) MarshalJSON 

func (l L3IsolationDomainProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3IsolationDomainProperties.

func (*L3IsolationDomainProperties) UnmarshalJSON 

func (l *L3IsolationDomainProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3IsolationDomainProperties.

type L3IsolationDomainsClient 

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

L3IsolationDomainsClient contains the methods for the L3IsolationDomains group. Don't use this type directly, use NewL3IsolationDomainsClient() instead.

func NewL3IsolationDomainsClient 

func NewL3IsolationDomainsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*L3IsolationDomainsClient, error)

NewL3IsolationDomainsClient creates a new instance of L3IsolationDomainsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*L3IsolationDomainsClient) BeginCommitConfiguration 

func (client *L3IsolationDomainsClient) BeginCommitConfiguration(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, options *L3IsolationDomainsClientBeginCommitConfigurationOptions) (*runtime.Poller[L3IsolationDomainsClientCommitConfigurationResponse], error)

BeginCommitConfiguration - Commits the configuration of the given resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • options - L3IsolationDomainsClientBeginCommitConfigurationOptions contains the optional parameters for the L3IsolationDomainsClient.BeginCommitConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_CommitConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL3IsolationDomainsClient().BeginCommitConfiguration(ctx, "example-rg", "example-l3domain", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*L3IsolationDomainsClient) BeginCreate 

func (client *L3IsolationDomainsClient) BeginCreate(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, body L3IsolationDomain, options *L3IsolationDomainsClientBeginCreateOptions) (*runtime.Poller[L3IsolationDomainsClientCreateResponse], error)

BeginCreate - Create isolation domain resources for layer 3 connectivity between compute nodes and for communication with external services .This configuration is applied on the devices only after the creation of networks is completed and isolation domain is enabled. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • body - Request payload.
  • options - L3IsolationDomainsClientBeginCreateOptions contains the optional parameters for the L3IsolationDomainsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL3IsolationDomainsClient().BeginCreate(ctx, "example-rg", "example-l3domain", armmanagednetworkfabric.L3IsolationDomain{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.L3IsolationDomainProperties{
			Annotation: to.Ptr("annotation"),
			AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
				IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
					{
						Prefix: to.Ptr("10.0.0.0/24"),
					}},
				IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
					{
						Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
					}},
			},
			ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
				ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
					ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
					ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
				},
				ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
			RedistributeStaticRoutes:     to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
			NetworkFabricID:              to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		},
	}, 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.L3IsolationDomain = armmanagednetworkfabric.L3IsolationDomain{
	// 	Name: to.Ptr("example-l3domain"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3isolationdomains"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.L3IsolationDomainProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
	// 			IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
	// 				{
	// 					Prefix: to.Ptr("10.0.0.0/24"),
	// 			}},
	// 			IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
	// 				{
	// 					Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
	// 			}},
	// 		},
	// 		ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
	// 			ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
	// 				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			},
	// 			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
	// 		RedistributeStaticRoutes: to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*L3IsolationDomainsClient) BeginDelete 

func (client *L3IsolationDomainsClient) BeginDelete(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, options *L3IsolationDomainsClientBeginDeleteOptions) (*runtime.Poller[L3IsolationDomainsClientDeleteResponse], error)

BeginDelete - Deletes layer 3 connectivity between compute nodes by managed by named L3 Isolation name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • options - L3IsolationDomainsClientBeginDeleteOptions contains the optional parameters for the L3IsolationDomainsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL3IsolationDomainsClient().BeginDelete(ctx, "example-rg", "example-l3domain", 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)
	}
}

Output:

func (*L3IsolationDomainsClient) BeginUpdate 

func (client *L3IsolationDomainsClient) BeginUpdate(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, body L3IsolationDomainPatch, options *L3IsolationDomainsClientBeginUpdateOptions) (*runtime.Poller[L3IsolationDomainsClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the L3 Isolation Domain resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • body - API to update certain properties of the L3 Isolation Domain resource.
  • options - L3IsolationDomainsClientBeginUpdateOptions contains the optional parameters for the L3IsolationDomainsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL3IsolationDomainsClient().BeginUpdate(ctx, "example-rg", "example-l3domain", armmanagednetworkfabric.L3IsolationDomainPatch{
		Tags: map[string]*string{
			"key4953": to.Ptr("1234"),
		},
		Properties: &armmanagednetworkfabric.L3IsolationDomainPatchProperties{
			Annotation: to.Ptr("annotation1"),
			AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
				IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
					{
						Prefix: to.Ptr("10.0.0.0/24"),
					}},
				IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
					{
						Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
					}},
			},
			ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
				ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
					ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
					ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
				},
				ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
			},
			RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
			RedistributeStaticRoutes:     to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
		},
	}, 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.L3IsolationDomain = armmanagednetworkfabric.L3IsolationDomain{
	// 	Name: to.Ptr("example-l3domain"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3isolationdomains"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key4953": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.L3IsolationDomainProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
	// 			IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
	// 				{
	// 					Prefix: to.Ptr("10.0.0.0/24"),
	// 			}},
	// 			IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
	// 				{
	// 					Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
	// 			}},
	// 		},
	// 		ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
	// 			ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
	// 				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
	// 				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
	// 			},
	// 			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
	// 		RedistributeStaticRoutes: to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*L3IsolationDomainsClient) BeginUpdateAdministrativeState 

func (client *L3IsolationDomainsClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, body UpdateAdministrativeState, options *L3IsolationDomainsClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[L3IsolationDomainsClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Enables racks for this Isolation Domain. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • body - Request payload.
  • options - L3IsolationDomainsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the L3IsolationDomainsClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_updateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL3IsolationDomainsClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-l3domain", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForDeviceUpdate = armmanagednetworkfabric.CommonPostActionResponseForDeviceUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	FailedDevices: []*string{
	// 		to.Ptr("")},
	// 		SuccessfulDevices: []*string{
	// 			to.Ptr("")},
	// 		}
}

Output:

func (*L3IsolationDomainsClient) BeginValidateConfiguration 

func (client *L3IsolationDomainsClient) BeginValidateConfiguration(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, options *L3IsolationDomainsClientBeginValidateConfigurationOptions) (*runtime.Poller[L3IsolationDomainsClientValidateConfigurationResponse], error)

BeginValidateConfiguration - Validates the configuration of the resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • options - L3IsolationDomainsClientBeginValidateConfigurationOptions contains the optional parameters for the L3IsolationDomainsClient.BeginValidateConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_ValidateConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewL3IsolationDomainsClient().BeginValidateConfiguration(ctx, "example-rg", "example-l3domain", 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ActionDetails"),
	// }
}

Output:

func (*L3IsolationDomainsClient) Get 

func (client *L3IsolationDomainsClient) Get(ctx context.Context, resourceGroupName string, l3IsolationDomainName string, options *L3IsolationDomainsClientGetOptions) (L3IsolationDomainsClientGetResponse, error)

Get - Retrieves details of this L3 Isolation Domain. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • l3IsolationDomainName - Name of the L3 Isolation Domain.
  • options - L3IsolationDomainsClientGetOptions contains the optional parameters for the L3IsolationDomainsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewL3IsolationDomainsClient().Get(ctx, "example-rg", "example-l3domain", 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.L3IsolationDomain = armmanagednetworkfabric.L3IsolationDomain{
	// 	Name: to.Ptr("example-l3domain"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/l3isolationdomains"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("UserId"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.L3IsolationDomainProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
	// 			IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
	// 				{
	// 					Prefix: to.Ptr("10.0.0.0/24"),
	// 			}},
	// 			IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
	// 				{
	// 					Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
	// 			}},
	// 		},
	// 		ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
	// 			ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
	// 				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			},
	// 			ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
	// 		},
	// 		RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
	// 		RedistributeStaticRoutes: to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*L3IsolationDomainsClient) NewListByResourceGroupPager 

func (client *L3IsolationDomainsClient) NewListByResourceGroupPager(resourceGroupName string, options *L3IsolationDomainsClientListByResourceGroupOptions) *runtime.Pager[L3IsolationDomainsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Displays L3IsolationDomains list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - L3IsolationDomainsClientListByResourceGroupOptions contains the optional parameters for the L3IsolationDomainsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewL3IsolationDomainsClient().NewListByResourceGroupPager("example-rg", 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.L3IsolationDomainsListResult = armmanagednetworkfabric.L3IsolationDomainsListResult{
		// 	Value: []*armmanagednetworkfabric.L3IsolationDomain{
		// 		{
		// 			Name: to.Ptr("example-l3domain"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/l3isolationdomains"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("UserId"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.L3IsolationDomainProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
		// 					IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
		// 						{
		// 							Prefix: to.Ptr("10.0.0.0/24"),
		// 					}},
		// 					IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
		// 						{
		// 							Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
		// 					}},
		// 				},
		// 				ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
		// 					ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
		// 						ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 						ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 					},
		// 					ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				},
		// 				RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
		// 				RedistributeStaticRoutes: to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*L3IsolationDomainsClient) NewListBySubscriptionPager 

func (client *L3IsolationDomainsClient) NewListBySubscriptionPager(options *L3IsolationDomainsClientListBySubscriptionOptions) *runtime.Pager[L3IsolationDomainsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Displays L3IsolationDomains list by subscription GET method.

Generated from API version 2023-06-15

  • options - L3IsolationDomainsClientListBySubscriptionOptions contains the optional parameters for the L3IsolationDomainsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/L3IsolationDomains_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewL3IsolationDomainsClient().NewListBySubscriptionPager(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.L3IsolationDomainsListResult = armmanagednetworkfabric.L3IsolationDomainsListResult{
		// 	Value: []*armmanagednetworkfabric.L3IsolationDomain{
		// 		{
		// 			Name: to.Ptr("example-l3domain"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/l3isolationdomains"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3domain"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-05T18:37:10.310Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("UserId"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.L3IsolationDomainProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AggregateRouteConfiguration: &armmanagednetworkfabric.AggregateRouteConfiguration{
		// 					IPv4Routes: []*armmanagednetworkfabric.AggregateRoute{
		// 						{
		// 							Prefix: to.Ptr("10.0.0.0/24"),
		// 					}},
		// 					IPv6Routes: []*armmanagednetworkfabric.AggregateRoute{
		// 						{
		// 							Prefix: to.Ptr("3FFE:FFFF:0:CD30::a0/29"),
		// 					}},
		// 				},
		// 				ConnectedSubnetRoutePolicy: &armmanagednetworkfabric.ConnectedSubnetRoutePolicy{
		// 					ExportRoutePolicy: &armmanagednetworkfabric.L3ExportRoutePolicy{
		// 						ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 						ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 					},
		// 					ExportRoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/routePolicyName"),
		// 				},
		// 				RedistributeConnectedSubnets: to.Ptr(armmanagednetworkfabric.RedistributeConnectedSubnetsTrue),
		// 				RedistributeStaticRoutes: to.Ptr(armmanagednetworkfabric.RedistributeStaticRoutesFalse),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

type L3IsolationDomainsClientBeginCommitConfigurationOptions 

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

L3IsolationDomainsClientBeginCommitConfigurationOptions contains the optional parameters for the L3IsolationDomainsClient.BeginCommitConfiguration method.

type L3IsolationDomainsClientBeginCreateOptions 

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

L3IsolationDomainsClientBeginCreateOptions contains the optional parameters for the L3IsolationDomainsClient.BeginCreate method.

type L3IsolationDomainsClientBeginDeleteOptions 

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

L3IsolationDomainsClientBeginDeleteOptions contains the optional parameters for the L3IsolationDomainsClient.BeginDelete method.

type L3IsolationDomainsClientBeginUpdateAdministrativeStateOptions 

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

L3IsolationDomainsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the L3IsolationDomainsClient.BeginUpdateAdministrativeState method.

type L3IsolationDomainsClientBeginUpdateOptions 

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

L3IsolationDomainsClientBeginUpdateOptions contains the optional parameters for the L3IsolationDomainsClient.BeginUpdate method.

type L3IsolationDomainsClientBeginValidateConfigurationOptions 

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

L3IsolationDomainsClientBeginValidateConfigurationOptions contains the optional parameters for the L3IsolationDomainsClient.BeginValidateConfiguration method.

type L3IsolationDomainsClientCommitConfigurationResponse 

type L3IsolationDomainsClientCommitConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

L3IsolationDomainsClientCommitConfigurationResponse contains the response from method L3IsolationDomainsClient.BeginCommitConfiguration.

type L3IsolationDomainsClientCreateResponse 

type L3IsolationDomainsClientCreateResponse struct {
	// The L3 Isolation Domain resource definition.
	L3IsolationDomain
}

L3IsolationDomainsClientCreateResponse contains the response from method L3IsolationDomainsClient.BeginCreate.

type L3IsolationDomainsClientDeleteResponse 

type L3IsolationDomainsClientDeleteResponse struct {
}

L3IsolationDomainsClientDeleteResponse contains the response from method L3IsolationDomainsClient.BeginDelete.

type L3IsolationDomainsClientGetOptions 

type L3IsolationDomainsClientGetOptions struct {
}

L3IsolationDomainsClientGetOptions contains the optional parameters for the L3IsolationDomainsClient.Get method.

type L3IsolationDomainsClientGetResponse 

type L3IsolationDomainsClientGetResponse struct {
	// The L3 Isolation Domain resource definition.
	L3IsolationDomain
}

L3IsolationDomainsClientGetResponse contains the response from method L3IsolationDomainsClient.Get.

type L3IsolationDomainsClientListByResourceGroupOptions 

type L3IsolationDomainsClientListByResourceGroupOptions struct {
}

L3IsolationDomainsClientListByResourceGroupOptions contains the optional parameters for the L3IsolationDomainsClient.NewListByResourceGroupPager method.

type L3IsolationDomainsClientListByResourceGroupResponse 

type L3IsolationDomainsClientListByResourceGroupResponse struct {
	// List of L3 Isolation Domains.
	L3IsolationDomainsListResult
}

L3IsolationDomainsClientListByResourceGroupResponse contains the response from method L3IsolationDomainsClient.NewListByResourceGroupPager.

type L3IsolationDomainsClientListBySubscriptionOptions 

type L3IsolationDomainsClientListBySubscriptionOptions struct {
}

L3IsolationDomainsClientListBySubscriptionOptions contains the optional parameters for the L3IsolationDomainsClient.NewListBySubscriptionPager method.

type L3IsolationDomainsClientListBySubscriptionResponse 

type L3IsolationDomainsClientListBySubscriptionResponse struct {
	// List of L3 Isolation Domains.
	L3IsolationDomainsListResult
}

L3IsolationDomainsClientListBySubscriptionResponse contains the response from method L3IsolationDomainsClient.NewListBySubscriptionPager.

type L3IsolationDomainsClientUpdateAdministrativeStateResponse 

type L3IsolationDomainsClientUpdateAdministrativeStateResponse struct {
	// Common response for device updates.
	CommonPostActionResponseForDeviceUpdate
}

L3IsolationDomainsClientUpdateAdministrativeStateResponse contains the response from method L3IsolationDomainsClient.BeginUpdateAdministrativeState.

type L3IsolationDomainsClientUpdateResponse 

type L3IsolationDomainsClientUpdateResponse struct {
	// The L3 Isolation Domain resource definition.
	L3IsolationDomain
}

L3IsolationDomainsClientUpdateResponse contains the response from method L3IsolationDomainsClient.BeginUpdate.

type L3IsolationDomainsClientValidateConfigurationResponse 

type L3IsolationDomainsClientValidateConfigurationResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

L3IsolationDomainsClientValidateConfigurationResponse contains the response from method L3IsolationDomainsClient.BeginValidateConfiguration.

type L3IsolationDomainsListResult 

type L3IsolationDomainsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of L3 Isolation Domain resources.
	Value []*L3IsolationDomain
}

L3IsolationDomainsListResult - List of L3 Isolation Domains.

func (L3IsolationDomainsListResult) MarshalJSON 

func (l L3IsolationDomainsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3IsolationDomainsListResult.

func (*L3IsolationDomainsListResult) UnmarshalJSON 

func (l *L3IsolationDomainsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3IsolationDomainsListResult.

type L3OptionBProperties 

type L3OptionBProperties struct {
	// RouteTargets to be applied. This is used for the backward compatibility.
	ExportRouteTargets []*string

	// RouteTargets to be applied. This is used for the backward compatibility.
	ImportRouteTargets []*string

	// RouteTargets to be applied.
	RouteTargets *RouteTargetInformation
}

L3OptionBProperties - Option B configuration.

func (L3OptionBProperties) MarshalJSON 

func (l L3OptionBProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type L3OptionBProperties.

func (*L3OptionBProperties) UnmarshalJSON 

func (l *L3OptionBProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type L3OptionBProperties.

type Layer2Configuration 

type Layer2Configuration struct {
	// List of network device interfaces resource IDs.
	Interfaces []*string

	// MTU of the packets between PE & CE.
	Mtu *int32
}

Layer2Configuration - Common properties for Layer2 Configuration.

func (Layer2Configuration) MarshalJSON 

func (l Layer2Configuration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Layer2Configuration.

func (*Layer2Configuration) UnmarshalJSON 

func (l *Layer2Configuration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Layer2Configuration.

type Layer4Protocol 

type Layer4Protocol string

Layer4Protocol - Layer4 protocol type that needs to be matched. 

const (
	Layer4ProtocolTCP Layer4Protocol = "TCP"
	Layer4ProtocolUDP Layer4Protocol = "UDP"
)

func PossibleLayer4ProtocolValues 

func PossibleLayer4ProtocolValues() []Layer4Protocol

PossibleLayer4ProtocolValues returns the possible values for the Layer4Protocol const type.

type ManagedResourceGroupConfiguration 

type ManagedResourceGroupConfiguration struct {
	// Managed resource group location.
	Location *string

	// The NFC service will be hosted in a Managed resource group.
	Name *string
}

ManagedResourceGroupConfiguration - Managed Resource Group configuration properties.

func (ManagedResourceGroupConfiguration) MarshalJSON 

func (m ManagedResourceGroupConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedResourceGroupConfiguration.

func (*ManagedResourceGroupConfiguration) UnmarshalJSON 

func (m *ManagedResourceGroupConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedResourceGroupConfiguration.

type ManagementNetworkConfigurationPatchableProperties 

type ManagementNetworkConfigurationPatchableProperties struct {
	// VPN Configuration properties.
	InfrastructureVPNConfiguration *VPNConfigurationPatchableProperties

	// VPN Configuration properties.
	WorkloadVPNConfiguration *VPNConfigurationPatchableProperties
}

ManagementNetworkConfigurationPatchableProperties - Configuration to be used to setup the management network.

func (ManagementNetworkConfigurationPatchableProperties) MarshalJSON 

func (m ManagementNetworkConfigurationPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagementNetworkConfigurationPatchableProperties.

func (*ManagementNetworkConfigurationPatchableProperties) UnmarshalJSON 

func (m *ManagementNetworkConfigurationPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagementNetworkConfigurationPatchableProperties.

type ManagementNetworkConfigurationProperties 

type ManagementNetworkConfigurationProperties struct {
	// REQUIRED; VPN Configuration properties.
	InfrastructureVPNConfiguration *VPNConfigurationProperties

	// REQUIRED; VPN Configuration properties.
	WorkloadVPNConfiguration *VPNConfigurationProperties
}

ManagementNetworkConfigurationProperties - Configuration to be used to setup the management network.

func (ManagementNetworkConfigurationProperties) MarshalJSON 

func (m ManagementNetworkConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagementNetworkConfigurationProperties.

func (*ManagementNetworkConfigurationProperties) UnmarshalJSON 

func (m *ManagementNetworkConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagementNetworkConfigurationProperties.

type NeighborAddress 

type NeighborAddress struct {
	// IP Address.
	Address *string

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState
}

NeighborAddress - Neighbor Address properties.

func (NeighborAddress) MarshalJSON 

func (n NeighborAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborAddress.

func (*NeighborAddress) UnmarshalJSON 

func (n *NeighborAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborAddress.

type NeighborGroup 

type NeighborGroup struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NeighborGroupProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NeighborGroup - Defines the Neighbor Group.

func (NeighborGroup) MarshalJSON 

func (n NeighborGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborGroup.

func (*NeighborGroup) UnmarshalJSON 

func (n *NeighborGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborGroup.

type NeighborGroupDestination 

type NeighborGroupDestination struct {
	// Array of IPv4 Addresses.
	IPv4Addresses []*string

	// Array of IPv6 Addresses.
	IPv6Addresses []*string
}

NeighborGroupDestination - An array of destination IPv4 Addresses or IPv6 Addresses.

func (NeighborGroupDestination) MarshalJSON 

func (n NeighborGroupDestination) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborGroupDestination.

func (*NeighborGroupDestination) UnmarshalJSON 

func (n *NeighborGroupDestination) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborGroupDestination.

type NeighborGroupPatch 

type NeighborGroupPatch struct {
	// Neighbor Group Patch properties.
	Properties *NeighborGroupPatchProperties

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

NeighborGroupPatch - The Neighbor Group Patch definition.

func (NeighborGroupPatch) MarshalJSON 

func (n NeighborGroupPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborGroupPatch.

func (*NeighborGroupPatch) UnmarshalJSON 

func (n *NeighborGroupPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborGroupPatch.

type NeighborGroupPatchProperties 

type NeighborGroupPatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// An array of destination IPv4 Addresses or IPv6 Addresses.
	Destination *NeighborGroupDestination
}

NeighborGroupPatchProperties - Neighbor Group Patch properties.

func (NeighborGroupPatchProperties) MarshalJSON 

func (n NeighborGroupPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborGroupPatchProperties.

func (*NeighborGroupPatchProperties) UnmarshalJSON 

func (n *NeighborGroupPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborGroupPatchProperties.

type NeighborGroupProperties 

type NeighborGroupProperties struct {
	// Switch configuration description.
	Annotation *string

	// An array of destination IPv4 Addresses or IPv6 Addresses.
	Destination *NeighborGroupDestination

	// READ-ONLY; List of NetworkTap IDs where neighbor group is associated.
	NetworkTapIDs []*string

	// READ-ONLY; List of Network Tap Rule IDs where neighbor group is associated.
	NetworkTapRuleIDs []*string

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

NeighborGroupProperties - Neighbor Group Properties defines the properties of the resource.

func (NeighborGroupProperties) MarshalJSON 

func (n NeighborGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborGroupProperties.

func (*NeighborGroupProperties) UnmarshalJSON 

func (n *NeighborGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborGroupProperties.

type NeighborGroupsClient 

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

NeighborGroupsClient contains the methods for the NeighborGroups group. Don't use this type directly, use NewNeighborGroupsClient() instead.

func NewNeighborGroupsClient 

func NewNeighborGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NeighborGroupsClient, error)

NewNeighborGroupsClient creates a new instance of NeighborGroupsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NeighborGroupsClient) BeginCreate 

func (client *NeighborGroupsClient) BeginCreate(ctx context.Context, resourceGroupName string, neighborGroupName string, body NeighborGroup, options *NeighborGroupsClientBeginCreateOptions) (*runtime.Poller[NeighborGroupsClientCreateResponse], error)

BeginCreate - Implements the Neighbor Group PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • neighborGroupName - Name of the Neighbor Group.
  • body - Request payload.
  • options - NeighborGroupsClientBeginCreateOptions contains the optional parameters for the NeighborGroupsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NeighborGroups_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNeighborGroupsClient().BeginCreate(ctx, "example-rg", "example-neighborGroup", armmanagednetworkfabric.NeighborGroup{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"key8107": to.Ptr("1234"),
		},
		Properties: &armmanagednetworkfabric.NeighborGroupProperties{
			Annotation: to.Ptr("annotation"),
			Destination: &armmanagednetworkfabric.NeighborGroupDestination{
				IPv4Addresses: []*string{
					to.Ptr("10.10.10.10"),
					to.Ptr("20.10.10.10"),
					to.Ptr("30.10.10.10"),
					to.Ptr("40.10.10.10"),
					to.Ptr("50.10.10.10"),
					to.Ptr("60.10.10.10"),
					to.Ptr("70.10.10.10"),
					to.Ptr("80.10.10.10"),
					to.Ptr("90.10.10.10")},
				IPv6Addresses: []*string{
					to.Ptr("2F::/100")},
			},
		},
	}, 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.NeighborGroup = armmanagednetworkfabric.NeighborGroup{
	// 	Name: to.Ptr("example-neighborGroup"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/neighborGroups"),
	// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.193Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.194Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NeighborGroupProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Destination: &armmanagednetworkfabric.NeighborGroupDestination{
	// 			IPv4Addresses: []*string{
	// 				to.Ptr("10.10.10.10"),
	// 				to.Ptr("20.10.10.10"),
	// 				to.Ptr("30.10.10.10"),
	// 				to.Ptr("40.10.10.10"),
	// 				to.Ptr("50.10.10.10"),
	// 				to.Ptr("60.10.10.10"),
	// 				to.Ptr("70.10.10.10"),
	// 				to.Ptr("80.10.10.10"),
	// 				to.Ptr("90.10.10.10")},
	// 				IPv6Addresses: []*string{
	// 					to.Ptr("2F::/100")},
	// 				},
	// 				NetworkTapIDs: []*string{
	// 					to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
	// 					NetworkTapRuleIDs: []*string{
	// 						to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-networkTapRule")},
	// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					},
	// 				}
}

Output:

func (*NeighborGroupsClient) BeginDelete 

func (client *NeighborGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, neighborGroupName string, options *NeighborGroupsClientBeginDeleteOptions) (*runtime.Poller[NeighborGroupsClientDeleteResponse], error)

BeginDelete - Implements Neighbor Group DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • neighborGroupName - Name of the Neighbor Group.
  • options - NeighborGroupsClientBeginDeleteOptions contains the optional parameters for the NeighborGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NeighborGroups_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNeighborGroupsClient().BeginDelete(ctx, "example-rg", "example-neighborGroup", 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)
	}
}

Output:

func (*NeighborGroupsClient) BeginUpdate 

func (client *NeighborGroupsClient) BeginUpdate(ctx context.Context, resourceGroupName string, neighborGroupName string, body NeighborGroupPatch, options *NeighborGroupsClientBeginUpdateOptions) (*runtime.Poller[NeighborGroupsClientUpdateResponse], error)

BeginUpdate - Updates the Neighbor Group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • neighborGroupName - Name of the Neighbor Group.
  • body - Neighbor Group properties to update. Only annotations are supported.
  • options - NeighborGroupsClientBeginUpdateOptions contains the optional parameters for the NeighborGroupsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NeighborGroups_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNeighborGroupsClient().BeginUpdate(ctx, "example-rg", "example-neighborGroup", armmanagednetworkfabric.NeighborGroupPatch{
		Tags: map[string]*string{
			"key8107": to.Ptr("2345"),
		},
		Properties: &armmanagednetworkfabric.NeighborGroupPatchProperties{
			Annotation: to.Ptr("Updating"),
			Destination: &armmanagednetworkfabric.NeighborGroupDestination{
				IPv4Addresses: []*string{
					to.Ptr("10.10.10.10"),
					to.Ptr("20.10.10.10"),
					to.Ptr("30.10.10.10"),
					to.Ptr("40.10.10.10"),
					to.Ptr("50.10.10.10"),
					to.Ptr("60.10.10.10"),
					to.Ptr("70.10.10.10"),
					to.Ptr("80.10.10.10"),
					to.Ptr("90.10.10.10")},
				IPv6Addresses: []*string{
					to.Ptr("2F::/100")},
			},
		},
	}, 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.NeighborGroup = armmanagednetworkfabric.NeighborGroup{
	// 	Name: to.Ptr("example-neighborGroup"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/neighborGroups"),
	// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.193Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.194Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key8107": to.Ptr("2345"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NeighborGroupProperties{
	// 		Annotation: to.Ptr("ivjs"),
	// 		Destination: &armmanagednetworkfabric.NeighborGroupDestination{
	// 			IPv4Addresses: []*string{
	// 				to.Ptr("10.10.10.10"),
	// 				to.Ptr("20.10.10.10"),
	// 				to.Ptr("30.10.10.10"),
	// 				to.Ptr("40.10.10.10"),
	// 				to.Ptr("50.10.10.10"),
	// 				to.Ptr("60.10.10.10"),
	// 				to.Ptr("70.10.10.10"),
	// 				to.Ptr("80.10.10.10"),
	// 				to.Ptr("90.10.10.10")},
	// 				IPv6Addresses: []*string{
	// 					to.Ptr("2F::/100")},
	// 				},
	// 				NetworkTapIDs: []*string{
	// 					to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
	// 					NetworkTapRuleIDs: []*string{
	// 						to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-networkTapRule")},
	// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					},
	// 				}
}

Output:

func (*NeighborGroupsClient) Get 

func (client *NeighborGroupsClient) Get(ctx context.Context, resourceGroupName string, neighborGroupName string, options *NeighborGroupsClientGetOptions) (NeighborGroupsClientGetResponse, error)

Get - Gets the Neighbor Group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • neighborGroupName - Name of the Neighbor Group.
  • options - NeighborGroupsClientGetOptions contains the optional parameters for the NeighborGroupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NeighborGroups_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNeighborGroupsClient().Get(ctx, "example-rg", "example-neighborGroup", 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.NeighborGroup = armmanagednetworkfabric.NeighborGroup{
	// 	Name: to.Ptr("example-neighborGroup"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/neighborGroups"),
	// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.193Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.194Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NeighborGroupProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Destination: &armmanagednetworkfabric.NeighborGroupDestination{
	// 			IPv4Addresses: []*string{
	// 				to.Ptr("10.10.10.10"),
	// 				to.Ptr("20.10.10.10"),
	// 				to.Ptr("30.10.10.10"),
	// 				to.Ptr("40.10.10.10"),
	// 				to.Ptr("50.10.10.10"),
	// 				to.Ptr("60.10.10.10"),
	// 				to.Ptr("70.10.10.10"),
	// 				to.Ptr("80.10.10.10"),
	// 				to.Ptr("90.10.10.10")},
	// 				IPv6Addresses: []*string{
	// 					to.Ptr("2F::/100")},
	// 				},
	// 				NetworkTapIDs: []*string{
	// 					to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
	// 					NetworkTapRuleIDs: []*string{
	// 						to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-networkTapRule")},
	// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					},
	// 				}
}

Output:

func (*NeighborGroupsClient) NewListByResourceGroupPager 

func (client *NeighborGroupsClient) NewListByResourceGroupPager(resourceGroupName string, options *NeighborGroupsClientListByResourceGroupOptions) *runtime.Pager[NeighborGroupsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Displays NeighborGroups list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NeighborGroupsClientListByResourceGroupOptions contains the optional parameters for the NeighborGroupsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NeighborGroups_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNeighborGroupsClient().NewListByResourceGroupPager("example-rg", 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.NeighborGroupsListResult = armmanagednetworkfabric.NeighborGroupsListResult{
		// 	Value: []*armmanagednetworkfabric.NeighborGroup{
		// 		{
		// 			Name: to.Ptr("example-neighborGroup"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/neighborGroups"),
		// 			ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.193Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.194Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NeighborGroupProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				Destination: &armmanagednetworkfabric.NeighborGroupDestination{
		// 					IPv4Addresses: []*string{
		// 						to.Ptr("10.10.10.10"),
		// 						to.Ptr("20.10.10.10"),
		// 						to.Ptr("30.10.10.10"),
		// 						to.Ptr("40.10.10.10"),
		// 						to.Ptr("50.10.10.10"),
		// 						to.Ptr("60.10.10.10"),
		// 						to.Ptr("70.10.10.10"),
		// 						to.Ptr("80.10.10.10"),
		// 						to.Ptr("90.10.10.10")},
		// 						IPv6Addresses: []*string{
		// 							to.Ptr("2F::/100")},
		// 						},
		// 						NetworkTapIDs: []*string{
		// 							to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
		// 							NetworkTapRuleIDs: []*string{
		// 								to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-networkTapRule")},
		// 								ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 							},
		// 					}},
		// 				}
	}
}

Output:

func (*NeighborGroupsClient) NewListBySubscriptionPager 

func (client *NeighborGroupsClient) NewListBySubscriptionPager(options *NeighborGroupsClientListBySubscriptionOptions) *runtime.Pager[NeighborGroupsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Displays NeighborGroups list by subscription GET method.

Generated from API version 2023-06-15

  • options - NeighborGroupsClientListBySubscriptionOptions contains the optional parameters for the NeighborGroupsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NeighborGroups_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNeighborGroupsClient().NewListBySubscriptionPager(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.NeighborGroupsListResult = armmanagednetworkfabric.NeighborGroupsListResult{
		// 	Value: []*armmanagednetworkfabric.NeighborGroup{
		// 		{
		// 			Name: to.Ptr("example-neighborGroup"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/neighborGroups"),
		// 			ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.193Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-23T05:49:59.194Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NeighborGroupProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				Destination: &armmanagednetworkfabric.NeighborGroupDestination{
		// 					IPv4Addresses: []*string{
		// 						to.Ptr("10.10.10.10"),
		// 						to.Ptr("20.10.10.10"),
		// 						to.Ptr("30.10.10.10"),
		// 						to.Ptr("40.10.10.10"),
		// 						to.Ptr("50.10.10.10"),
		// 						to.Ptr("60.10.10.10"),
		// 						to.Ptr("70.10.10.10"),
		// 						to.Ptr("80.10.10.10"),
		// 						to.Ptr("90.10.10.10")},
		// 						IPv6Addresses: []*string{
		// 							to.Ptr("2F::/100")},
		// 						},
		// 						NetworkTapIDs: []*string{
		// 							to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
		// 							NetworkTapRuleIDs: []*string{
		// 								to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-networkTapRule")},
		// 								ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 							},
		// 					}},
		// 				}
	}
}

Output:

type NeighborGroupsClientBeginCreateOptions 

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

NeighborGroupsClientBeginCreateOptions contains the optional parameters for the NeighborGroupsClient.BeginCreate method.

type NeighborGroupsClientBeginDeleteOptions 

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

NeighborGroupsClientBeginDeleteOptions contains the optional parameters for the NeighborGroupsClient.BeginDelete method.

type NeighborGroupsClientBeginUpdateOptions 

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

NeighborGroupsClientBeginUpdateOptions contains the optional parameters for the NeighborGroupsClient.BeginUpdate method.

type NeighborGroupsClientCreateResponse 

type NeighborGroupsClientCreateResponse struct {
	// Defines the Neighbor Group.
	NeighborGroup
}

NeighborGroupsClientCreateResponse contains the response from method NeighborGroupsClient.BeginCreate.

type NeighborGroupsClientDeleteResponse 

type NeighborGroupsClientDeleteResponse struct {
}

NeighborGroupsClientDeleteResponse contains the response from method NeighborGroupsClient.BeginDelete.

type NeighborGroupsClientGetOptions 

type NeighborGroupsClientGetOptions struct {
}

NeighborGroupsClientGetOptions contains the optional parameters for the NeighborGroupsClient.Get method.

type NeighborGroupsClientGetResponse 

type NeighborGroupsClientGetResponse struct {
	// Defines the Neighbor Group.
	NeighborGroup
}

NeighborGroupsClientGetResponse contains the response from method NeighborGroupsClient.Get.

type NeighborGroupsClientListByResourceGroupOptions 

type NeighborGroupsClientListByResourceGroupOptions struct {
}

NeighborGroupsClientListByResourceGroupOptions contains the optional parameters for the NeighborGroupsClient.NewListByResourceGroupPager method.

type NeighborGroupsClientListByResourceGroupResponse 

type NeighborGroupsClientListByResourceGroupResponse struct {
	// List of Neighbor Group.
	NeighborGroupsListResult
}

NeighborGroupsClientListByResourceGroupResponse contains the response from method NeighborGroupsClient.NewListByResourceGroupPager.

type NeighborGroupsClientListBySubscriptionOptions 

type NeighborGroupsClientListBySubscriptionOptions struct {
}

NeighborGroupsClientListBySubscriptionOptions contains the optional parameters for the NeighborGroupsClient.NewListBySubscriptionPager method.

type NeighborGroupsClientListBySubscriptionResponse 

type NeighborGroupsClientListBySubscriptionResponse struct {
	// List of Neighbor Group.
	NeighborGroupsListResult
}

NeighborGroupsClientListBySubscriptionResponse contains the response from method NeighborGroupsClient.NewListBySubscriptionPager.

type NeighborGroupsClientUpdateResponse 

type NeighborGroupsClientUpdateResponse struct {
	// Defines the Neighbor Group.
	NeighborGroup
}

NeighborGroupsClientUpdateResponse contains the response from method NeighborGroupsClient.BeginUpdate.

type NeighborGroupsListResult 

type NeighborGroupsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Neighbor Group resources.
	Value []*NeighborGroup
}

NeighborGroupsListResult - List of Neighbor Group.

func (NeighborGroupsListResult) MarshalJSON 

func (n NeighborGroupsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NeighborGroupsListResult.

func (*NeighborGroupsListResult) UnmarshalJSON 

func (n *NeighborGroupsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NeighborGroupsListResult.

type NetworkDevice 

type NetworkDevice struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkDeviceProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkDevice - The Network Device resource definition.

func (NetworkDevice) MarshalJSON 

func (n NetworkDevice) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDevice.

func (*NetworkDevice) UnmarshalJSON 

func (n *NetworkDevice) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDevice.

type NetworkDevicePatchParameters 

type NetworkDevicePatchParameters struct {
	// Network Device Patch properties.
	Properties *NetworkDevicePatchParametersProperties

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

NetworkDevicePatchParameters - The Network Device Patch Parameters defines the patch parameters of the resource.

func (NetworkDevicePatchParameters) MarshalJSON 

func (n NetworkDevicePatchParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDevicePatchParameters.

func (*NetworkDevicePatchParameters) UnmarshalJSON 

func (n *NetworkDevicePatchParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDevicePatchParameters.

type NetworkDevicePatchParametersProperties 

type NetworkDevicePatchParametersProperties struct {
	// Switch configuration description.
	Annotation *string

	// The host name of the device.
	HostName *string

	// Serial number of the device. Format of serial Number - Make;Model;HardwareRevisionId;SerialNumber.
	SerialNumber *string
}

NetworkDevicePatchParametersProperties - Network Device Patch properties.

func (NetworkDevicePatchParametersProperties) MarshalJSON 

func (n NetworkDevicePatchParametersProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDevicePatchParametersProperties.

func (*NetworkDevicePatchParametersProperties) UnmarshalJSON 

func (n *NetworkDevicePatchParametersProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDevicePatchParametersProperties.

type NetworkDeviceProperties 

type NetworkDeviceProperties struct {
	// Switch configuration description.
	Annotation *string

	// The host name of the device.
	HostName *string

	// Network Device SKU name.
	NetworkDeviceSKU *string

	// Serial number of the device. Format of serial Number - Make;Model;HardwareRevisionId;SerialNumber.
	SerialNumber *string

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Management IPv4 Address.
	ManagementIPv4Address *string

	// READ-ONLY; Management IPv6 Address.
	ManagementIPv6Address *string

	// READ-ONLY; NetworkDeviceRole is the device role: Example: CE | ToR.
	NetworkDeviceRole *NetworkDeviceRole

	// READ-ONLY; Reference to network rack resource id.
	NetworkRackID *string

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

	// READ-ONLY; Current version of the device as defined in SKU.
	Version *string
}

NetworkDeviceProperties - Network Device Properties defines the properties of the resource.

func (NetworkDeviceProperties) MarshalJSON 

func (n NetworkDeviceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDeviceProperties.

func (*NetworkDeviceProperties) UnmarshalJSON 

func (n *NetworkDeviceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDeviceProperties.

type NetworkDeviceRole 

type NetworkDeviceRole string

NetworkDeviceRole - NetworkDeviceRole is the device role: Example: CE | ToR. 

const (
	NetworkDeviceRoleCE         NetworkDeviceRole = "CE"
	NetworkDeviceRoleManagement NetworkDeviceRole = "Management"
	NetworkDeviceRoleNPB        NetworkDeviceRole = "NPB"
	NetworkDeviceRoleTS         NetworkDeviceRole = "TS"
	NetworkDeviceRoleToR        NetworkDeviceRole = "ToR"
)

func PossibleNetworkDeviceRoleValues 

func PossibleNetworkDeviceRoleValues() []NetworkDeviceRole

PossibleNetworkDeviceRoleValues returns the possible values for the NetworkDeviceRole const type.

type NetworkDeviceRoleName 

type NetworkDeviceRoleName string

NetworkDeviceRoleName - Available roles for the network device. 

const (
	NetworkDeviceRoleNameCE         NetworkDeviceRoleName = "CE"
	NetworkDeviceRoleNameManagement NetworkDeviceRoleName = "Management"
	NetworkDeviceRoleNameNPB        NetworkDeviceRoleName = "NPB"
	NetworkDeviceRoleNameTS         NetworkDeviceRoleName = "TS"
	NetworkDeviceRoleNameToR        NetworkDeviceRoleName = "ToR"
)

func PossibleNetworkDeviceRoleNameValues 

func PossibleNetworkDeviceRoleNameValues() []NetworkDeviceRoleName

PossibleNetworkDeviceRoleNameValues returns the possible values for the NetworkDeviceRoleName const type.

type NetworkDeviceSKU 

type NetworkDeviceSKU struct {
	// REQUIRED; Resource properties.
	Properties *NetworkDeviceSKUProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkDeviceSKU - The NetworkDeviceSku resource definition.

func (NetworkDeviceSKU) MarshalJSON 

func (n NetworkDeviceSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDeviceSKU.

func (*NetworkDeviceSKU) UnmarshalJSON 

func (n *NetworkDeviceSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDeviceSKU.

type NetworkDeviceSKUProperties 

type NetworkDeviceSKUProperties struct {
	// REQUIRED; Model of the network device.
	Model *string

	// List of network device interfaces.
	Interfaces []*DeviceInterfaceProperties

	// Manufacturer of the network device.
	Manufacturer *string

	// Available roles for the network device.
	SupportedRoleTypes []*NetworkDeviceRoleName

	// List of supported version details of network device.
	SupportedVersions []*SupportedVersionProperties

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

NetworkDeviceSKUProperties - Network Device SKU Properties defines the properties of the resource.

func (NetworkDeviceSKUProperties) MarshalJSON 

func (n NetworkDeviceSKUProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDeviceSKUProperties.

func (*NetworkDeviceSKUProperties) UnmarshalJSON 

func (n *NetworkDeviceSKUProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDeviceSKUProperties.

type NetworkDeviceSKUsClient 

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

NetworkDeviceSKUsClient contains the methods for the NetworkDeviceSKUs group. Don't use this type directly, use NewNetworkDeviceSKUsClient() instead.

func NewNetworkDeviceSKUsClient 

func NewNetworkDeviceSKUsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkDeviceSKUsClient, error)

NewNetworkDeviceSKUsClient creates a new instance of NetworkDeviceSKUsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkDeviceSKUsClient) Get 

func (client *NetworkDeviceSKUsClient) Get(ctx context.Context, networkDeviceSKUName string, options *NetworkDeviceSKUsClientGetOptions) (NetworkDeviceSKUsClientGetResponse, error)

Get - Get a Network Device SKU details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • networkDeviceSKUName - Name of the Network Device SKU.
  • options - NetworkDeviceSKUsClientGetOptions contains the optional parameters for the NetworkDeviceSKUsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDeviceSkus_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkDeviceSKUsClient().Get(ctx, "example-deviceSku", 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.NetworkDeviceSKU = armmanagednetworkfabric.NetworkDeviceSKU{
	// 	Name: to.Ptr("example-deviceSku"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkDeviceSkus"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/providers/Microsoft.ManagedNetworkFabric/networkDeviceSkus/example-deviceSku"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:55:43.467Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:55:43.467Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkDeviceSKUProperties{
	// 		Interfaces: []*armmanagednetworkfabric.DeviceInterfaceProperties{
	// 			{
	// 				Identifier: to.Ptr("HundredGigE0/0"),
	// 				InterfaceType: to.Ptr("type1"),
	// 				SupportedConnectorTypes: []*armmanagednetworkfabric.SupportedConnectorProperties{
	// 					{
	// 						ConnectorType: to.Ptr("Optical"),
	// 						MaxSpeedInMbps: to.Ptr[int32](100),
	// 				}},
	// 		}},
	// 		Manufacturer: to.Ptr("Arista"),
	// 		Model: to.Ptr("model1"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		SupportedRoleTypes: []*armmanagednetworkfabric.NetworkDeviceRoleName{
	// 			to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleNameCE)},
	// 			SupportedVersions: []*armmanagednetworkfabric.SupportedVersionProperties{
	// 				{
	// 					IsDefault: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 					VendorFirmwareVersion: to.Ptr("11.2"),
	// 					VendorOsVersion: to.Ptr("2.0"),
	// 					Version: to.Ptr("1.0.0"),
	// 			}},
	// 		},
	// 	}
}

Output:

func (*NetworkDeviceSKUsClient) NewListBySubscriptionPager 

func (client *NetworkDeviceSKUsClient) NewListBySubscriptionPager(options *NetworkDeviceSKUsClientListBySubscriptionOptions) *runtime.Pager[NetworkDeviceSKUsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List Network Device SKUs for the given subscription.

Generated from API version 2023-06-15

  • options - NetworkDeviceSKUsClientListBySubscriptionOptions contains the optional parameters for the NetworkDeviceSKUsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDeviceSkus_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkDeviceSKUsClient().NewListBySubscriptionPager(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.NetworkDeviceSKUsListResult = armmanagednetworkfabric.NetworkDeviceSKUsListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkDeviceSKU{
		// 		{
		// 			Name: to.Ptr("example-deviceSku"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkDeviceSkus"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/providers/Microsoft.ManagedNetworkFabric/networkDeviceSkus/example-deviceSku"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:55:43.467Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:55:43.467Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkDeviceSKUProperties{
		// 				Interfaces: []*armmanagednetworkfabric.DeviceInterfaceProperties{
		// 					{
		// 						Identifier: to.Ptr("HundredGigE0/0"),
		// 						InterfaceType: to.Ptr("type1"),
		// 						SupportedConnectorTypes: []*armmanagednetworkfabric.SupportedConnectorProperties{
		// 							{
		// 								ConnectorType: to.Ptr("Optical"),
		// 								MaxSpeedInMbps: to.Ptr[int32](100),
		// 						}},
		// 				}},
		// 				Manufacturer: to.Ptr("Arista"),
		// 				Model: to.Ptr("model1"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				SupportedRoleTypes: []*armmanagednetworkfabric.NetworkDeviceRoleName{
		// 					to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleNameCE)},
		// 					SupportedVersions: []*armmanagednetworkfabric.SupportedVersionProperties{
		// 						{
		// 							IsDefault: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
		// 							VendorFirmwareVersion: to.Ptr("11.2"),
		// 							VendorOsVersion: to.Ptr("2.0"),
		// 							Version: to.Ptr("1.0.0"),
		// 					}},
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type NetworkDeviceSKUsClientGetOptions 

type NetworkDeviceSKUsClientGetOptions struct {
}

NetworkDeviceSKUsClientGetOptions contains the optional parameters for the NetworkDeviceSKUsClient.Get method.

type NetworkDeviceSKUsClientGetResponse 

type NetworkDeviceSKUsClientGetResponse struct {
	// The NetworkDeviceSku resource definition.
	NetworkDeviceSKU
}

NetworkDeviceSKUsClientGetResponse contains the response from method NetworkDeviceSKUsClient.Get.

type NetworkDeviceSKUsClientListBySubscriptionOptions 

type NetworkDeviceSKUsClientListBySubscriptionOptions struct {
}

NetworkDeviceSKUsClientListBySubscriptionOptions contains the optional parameters for the NetworkDeviceSKUsClient.NewListBySubscriptionPager method.

type NetworkDeviceSKUsClientListBySubscriptionResponse 

type NetworkDeviceSKUsClientListBySubscriptionResponse struct {
	// List of Network Device SKUs.
	NetworkDeviceSKUsListResult
}

NetworkDeviceSKUsClientListBySubscriptionResponse contains the response from method NetworkDeviceSKUsClient.NewListBySubscriptionPager.

type NetworkDeviceSKUsListResult 

type NetworkDeviceSKUsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Network Device SKU resources.
	Value []*NetworkDeviceSKU
}

NetworkDeviceSKUsListResult - List of Network Device SKUs.

func (NetworkDeviceSKUsListResult) MarshalJSON 

func (n NetworkDeviceSKUsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDeviceSKUsListResult.

func (*NetworkDeviceSKUsListResult) UnmarshalJSON 

func (n *NetworkDeviceSKUsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDeviceSKUsListResult.

type NetworkDevicesClient 

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

NetworkDevicesClient contains the methods for the NetworkDevices group. Don't use this type directly, use NewNetworkDevicesClient() instead.

func NewNetworkDevicesClient 

func NewNetworkDevicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkDevicesClient, error)

NewNetworkDevicesClient creates a new instance of NetworkDevicesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkDevicesClient) BeginCreate 

func (client *NetworkDevicesClient) BeginCreate(ctx context.Context, resourceGroupName string, networkDeviceName string, body NetworkDevice, options *NetworkDevicesClientBeginCreateOptions) (*runtime.Poller[NetworkDevicesClientCreateResponse], error)

BeginCreate - Create a Network Device resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • body - Request payload.
  • options - NetworkDevicesClientBeginCreateOptions contains the optional parameters for the NetworkDevicesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginCreate(ctx, "example-rg", "example-device", armmanagednetworkfabric.NetworkDevice{
		Location: to.Ptr("eastuseuap"),
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkDeviceProperties{
			Annotation:       to.Ptr("annotation"),
			HostName:         to.Ptr("NFA-Device"),
			SerialNumber:     to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
			NetworkDeviceSKU: to.Ptr("DeviceSku"),
		},
	}, 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.NetworkDevice = armmanagednetworkfabric.NetworkDevice{
	// 	Name: to.Ptr("example-device"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkdevices"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkDeviceProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		HostName: to.Ptr("NFA-Device"),
	// 		SerialNumber: to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		ManagementIPv4Address: to.Ptr("10.10.10.10"),
	// 		ManagementIPv6Address: to.Ptr("2F::1/100"),
	// 		NetworkDeviceRole: to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleCE),
	// 		NetworkDeviceSKU: to.Ptr("DeviceSku"),
	// 		NetworkRackID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		Version: to.Ptr("1.0"),
	// 	},
	// }
}

Output:

func (*NetworkDevicesClient) BeginDelete 

func (client *NetworkDevicesClient) BeginDelete(ctx context.Context, resourceGroupName string, networkDeviceName string, options *NetworkDevicesClientBeginDeleteOptions) (*runtime.Poller[NetworkDevicesClientDeleteResponse], error)

BeginDelete - Delete the Network Device resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • options - NetworkDevicesClientBeginDeleteOptions contains the optional parameters for the NetworkDevicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginDelete(ctx, "example-rg", "example-device", 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)
	}
}

Output:

func (*NetworkDevicesClient) BeginReboot 

func (client *NetworkDevicesClient) BeginReboot(ctx context.Context, resourceGroupName string, networkDeviceName string, body RebootProperties, options *NetworkDevicesClientBeginRebootOptions) (*runtime.Poller[NetworkDevicesClientRebootResponse], error)

BeginReboot - Reboot the Network Device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • body - Request payload.
  • options - NetworkDevicesClientBeginRebootOptions contains the optional parameters for the NetworkDevicesClient.BeginReboot method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_Reboot_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginReboot(ctx, "example-rg", "example-device", armmanagednetworkfabric.RebootProperties{
		RebootType: to.Ptr(armmanagednetworkfabric.RebootTypeGracefulRebootWithZTP),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkDevicesClient) BeginRefreshConfiguration 

func (client *NetworkDevicesClient) BeginRefreshConfiguration(ctx context.Context, resourceGroupName string, networkDeviceName string, options *NetworkDevicesClientBeginRefreshConfigurationOptions) (*runtime.Poller[NetworkDevicesClientRefreshConfigurationResponse], error)

BeginRefreshConfiguration - Refreshes the configuration the Network Device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • options - NetworkDevicesClientBeginRefreshConfigurationOptions contains the optional parameters for the NetworkDevicesClient.BeginRefreshConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_RefreshConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginRefreshConfiguration(ctx, "example-rg", "example-device", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkDevicesClient) BeginUpdate 

func (client *NetworkDevicesClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkDeviceName string, body NetworkDevicePatchParameters, options *NetworkDevicesClientBeginUpdateOptions) (*runtime.Poller[NetworkDevicesClientUpdateResponse], error)

BeginUpdate - Update certain properties of the Network Device resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • body - Network Device properties to update.
  • options - NetworkDevicesClientBeginUpdateOptions contains the optional parameters for the NetworkDevicesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginUpdate(ctx, "example-rg", "example-device", armmanagednetworkfabric.NetworkDevicePatchParameters{
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkDevicePatchParametersProperties{
			Annotation:   to.Ptr("annotation"),
			HostName:     to.Ptr("NFA-Device"),
			SerialNumber: to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
		},
	}, 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.NetworkDevice = armmanagednetworkfabric.NetworkDevice{
	// 	Name: to.Ptr("example-device"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkdevices"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkDeviceProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		HostName: to.Ptr("NFA-Device"),
	// 		SerialNumber: to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		ManagementIPv4Address: to.Ptr("10.10.10.10"),
	// 		ManagementIPv6Address: to.Ptr("2F::1/100"),
	// 		NetworkDeviceRole: to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleCE),
	// 		NetworkDeviceSKU: to.Ptr("DeviceSku"),
	// 		NetworkRackID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		Version: to.Ptr("1.0"),
	// 	},
	// }
}

Output:

func (*NetworkDevicesClient) BeginUpdateAdministrativeState 

func (client *NetworkDevicesClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, networkDeviceName string, body UpdateDeviceAdministrativeState, options *NetworkDevicesClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[NetworkDevicesClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Updates the Administrative state of the Network Device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • body - Request payload.
  • options - NetworkDevicesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkDevicesClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-device", armmanagednetworkfabric.UpdateDeviceAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.DeviceAdministrativeStateRMA),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkDevicesClient) BeginUpgrade 

func (client *NetworkDevicesClient) BeginUpgrade(ctx context.Context, resourceGroupName string, networkDeviceName string, body UpdateVersion, options *NetworkDevicesClientBeginUpgradeOptions) (*runtime.Poller[NetworkDevicesClientUpgradeResponse], error)

BeginUpgrade - Upgrades the version of the Network Device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • body - Request payload.
  • options - NetworkDevicesClientBeginUpgradeOptions contains the optional parameters for the NetworkDevicesClient.BeginUpgrade method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_Upgrade_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkDevicesClient().BeginUpgrade(ctx, "example-rg", "example-device", armmanagednetworkfabric.UpdateVersion{
		Version: to.Ptr("1.0.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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkDevicesClient) Get 

func (client *NetworkDevicesClient) Get(ctx context.Context, resourceGroupName string, networkDeviceName string, options *NetworkDevicesClientGetOptions) (NetworkDevicesClientGetResponse, error)

Get - Gets the Network Device resource details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • options - NetworkDevicesClientGetOptions contains the optional parameters for the NetworkDevicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkDevicesClient().Get(ctx, "example-rg", "example-device", 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.NetworkDevice = armmanagednetworkfabric.NetworkDevice{
	// 	Name: to.Ptr("example-device"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkdevices"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkDeviceProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		HostName: to.Ptr("NFA-Device"),
	// 		SerialNumber: to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		ManagementIPv4Address: to.Ptr("10.10.10.10"),
	// 		ManagementIPv6Address: to.Ptr("2F::1/100"),
	// 		NetworkDeviceRole: to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleCE),
	// 		NetworkDeviceSKU: to.Ptr("DeviceSku"),
	// 		NetworkRackID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		Version: to.Ptr("1.0"),
	// 	},
	// }
}

Output:

func (*NetworkDevicesClient) NewListByResourceGroupPager 

func (client *NetworkDevicesClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkDevicesClientListByResourceGroupOptions) *runtime.Pager[NetworkDevicesClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all the Network Device resources in a given resource group.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkDevicesClientListByResourceGroupOptions contains the optional parameters for the NetworkDevicesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkDevicesClient().NewListByResourceGroupPager("example-rg", 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.NetworkDevicesListResult = armmanagednetworkfabric.NetworkDevicesListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkDevice{
		// 		{
		// 			Name: to.Ptr("example-device"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkdevices"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkDeviceProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				HostName: to.Ptr("NFA-Device"),
		// 				SerialNumber: to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				ManagementIPv4Address: to.Ptr("10.10.10.10"),
		// 				ManagementIPv6Address: to.Ptr("2F::1/100"),
		// 				NetworkDeviceRole: to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleCE),
		// 				NetworkDeviceSKU: to.Ptr("DeviceSku"),
		// 				NetworkRackID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				Version: to.Ptr("1.0"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*NetworkDevicesClient) NewListBySubscriptionPager 

func (client *NetworkDevicesClient) NewListBySubscriptionPager(options *NetworkDevicesClientListBySubscriptionOptions) *runtime.Pager[NetworkDevicesClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all the Network Device resources in a given subscription.

Generated from API version 2023-06-15

  • options - NetworkDevicesClientListBySubscriptionOptions contains the optional parameters for the NetworkDevicesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkDevices_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkDevicesClient().NewListBySubscriptionPager(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.NetworkDevicesListResult = armmanagednetworkfabric.NetworkDevicesListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkDevice{
		// 		{
		// 			Name: to.Ptr("example-device"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkdevices"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkDeviceProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				HostName: to.Ptr("NFA-Device"),
		// 				SerialNumber: to.Ptr("Vendor;DCS-7280XXX-24;12.05;JPE2111XXXX"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				ManagementIPv4Address: to.Ptr("10.10.10.10"),
		// 				ManagementIPv6Address: to.Ptr("2F::1/100"),
		// 				NetworkDeviceRole: to.Ptr(armmanagednetworkfabric.NetworkDeviceRoleCE),
		// 				NetworkDeviceSKU: to.Ptr("DeviceSku"),
		// 				NetworkRackID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				Version: to.Ptr("1.0"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type NetworkDevicesClientBeginCreateOptions 

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

NetworkDevicesClientBeginCreateOptions contains the optional parameters for the NetworkDevicesClient.BeginCreate method.

type NetworkDevicesClientBeginDeleteOptions 

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

NetworkDevicesClientBeginDeleteOptions contains the optional parameters for the NetworkDevicesClient.BeginDelete method.

type NetworkDevicesClientBeginRebootOptions 

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

NetworkDevicesClientBeginRebootOptions contains the optional parameters for the NetworkDevicesClient.BeginReboot method.

type NetworkDevicesClientBeginRefreshConfigurationOptions 

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

NetworkDevicesClientBeginRefreshConfigurationOptions contains the optional parameters for the NetworkDevicesClient.BeginRefreshConfiguration method.

type NetworkDevicesClientBeginUpdateAdministrativeStateOptions 

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

NetworkDevicesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkDevicesClient.BeginUpdateAdministrativeState method.

type NetworkDevicesClientBeginUpdateOptions 

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

NetworkDevicesClientBeginUpdateOptions contains the optional parameters for the NetworkDevicesClient.BeginUpdate method.

type NetworkDevicesClientBeginUpgradeOptions 

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

NetworkDevicesClientBeginUpgradeOptions contains the optional parameters for the NetworkDevicesClient.BeginUpgrade method.

type NetworkDevicesClientCreateResponse 

type NetworkDevicesClientCreateResponse struct {
	// The Network Device resource definition.
	NetworkDevice
}

NetworkDevicesClientCreateResponse contains the response from method NetworkDevicesClient.BeginCreate.

type NetworkDevicesClientDeleteResponse 

type NetworkDevicesClientDeleteResponse struct {
}

NetworkDevicesClientDeleteResponse contains the response from method NetworkDevicesClient.BeginDelete.

type NetworkDevicesClientGetOptions 

type NetworkDevicesClientGetOptions struct {
}

NetworkDevicesClientGetOptions contains the optional parameters for the NetworkDevicesClient.Get method.

type NetworkDevicesClientGetResponse 

type NetworkDevicesClientGetResponse struct {
	// The Network Device resource definition.
	NetworkDevice
}

NetworkDevicesClientGetResponse contains the response from method NetworkDevicesClient.Get.

type NetworkDevicesClientListByResourceGroupOptions 

type NetworkDevicesClientListByResourceGroupOptions struct {
}

NetworkDevicesClientListByResourceGroupOptions contains the optional parameters for the NetworkDevicesClient.NewListByResourceGroupPager method.

type NetworkDevicesClientListByResourceGroupResponse 

type NetworkDevicesClientListByResourceGroupResponse struct {
	// List of NetworkDevices.
	NetworkDevicesListResult
}

NetworkDevicesClientListByResourceGroupResponse contains the response from method NetworkDevicesClient.NewListByResourceGroupPager.

type NetworkDevicesClientListBySubscriptionOptions 

type NetworkDevicesClientListBySubscriptionOptions struct {
}

NetworkDevicesClientListBySubscriptionOptions contains the optional parameters for the NetworkDevicesClient.NewListBySubscriptionPager method.

type NetworkDevicesClientListBySubscriptionResponse 

type NetworkDevicesClientListBySubscriptionResponse struct {
	// List of NetworkDevices.
	NetworkDevicesListResult
}

NetworkDevicesClientListBySubscriptionResponse contains the response from method NetworkDevicesClient.NewListBySubscriptionPager.

type NetworkDevicesClientRebootResponse 

type NetworkDevicesClientRebootResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkDevicesClientRebootResponse contains the response from method NetworkDevicesClient.BeginReboot.

type NetworkDevicesClientRefreshConfigurationResponse 

type NetworkDevicesClientRefreshConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkDevicesClientRefreshConfigurationResponse contains the response from method NetworkDevicesClient.BeginRefreshConfiguration.

type NetworkDevicesClientUpdateAdministrativeStateResponse 

type NetworkDevicesClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkDevicesClientUpdateAdministrativeStateResponse contains the response from method NetworkDevicesClient.BeginUpdateAdministrativeState.

type NetworkDevicesClientUpdateResponse 

type NetworkDevicesClientUpdateResponse struct {
	// The Network Device resource definition.
	NetworkDevice
}

NetworkDevicesClientUpdateResponse contains the response from method NetworkDevicesClient.BeginUpdate.

type NetworkDevicesClientUpgradeResponse 

type NetworkDevicesClientUpgradeResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkDevicesClientUpgradeResponse contains the response from method NetworkDevicesClient.BeginUpgrade.

type NetworkDevicesListResult 

type NetworkDevicesListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of NetworkDevice resources.
	Value []*NetworkDevice
}

NetworkDevicesListResult - List of NetworkDevices.

func (NetworkDevicesListResult) MarshalJSON 

func (n NetworkDevicesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkDevicesListResult.

func (*NetworkDevicesListResult) UnmarshalJSON 

func (n *NetworkDevicesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkDevicesListResult.

type NetworkFabric 

type NetworkFabric struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkFabricProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkFabric - The Network Fabric resource definition.

func (NetworkFabric) MarshalJSON 

func (n NetworkFabric) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabric.

func (*NetworkFabric) UnmarshalJSON 

func (n *NetworkFabric) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabric.

type NetworkFabricController 

type NetworkFabricController struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkFabricControllerProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkFabricController - The Network Fabric Controller resource definition.

func (NetworkFabricController) MarshalJSON 

func (n NetworkFabricController) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricController.

func (*NetworkFabricController) UnmarshalJSON 

func (n *NetworkFabricController) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricController.

type NetworkFabricControllerPatch 

type NetworkFabricControllerPatch struct {
	// Network Fabric Controller patch properties.
	Properties *NetworkFabricControllerPatchableProperties

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

NetworkFabricControllerPatch - The Network Fabric Controller Patch payload definition.

func (NetworkFabricControllerPatch) MarshalJSON 

func (n NetworkFabricControllerPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricControllerPatch.

func (*NetworkFabricControllerPatch) UnmarshalJSON 

func (n *NetworkFabricControllerPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricControllerPatch.

type NetworkFabricControllerPatchableProperties 

type NetworkFabricControllerPatchableProperties struct {
	// As part of an update, the Infrastructure ExpressRoute CircuitID should be provided to create and Provision a NFC. This
	// Express route is dedicated for Infrastructure services. (This is a Mandatory
	// attribute)
	InfrastructureExpressRouteConnections []*ExpressRouteConnectionInformation

	// As part of an update, the workload ExpressRoute CircuitID should be provided to create and Provision a NFC. This Express
	// route is dedicated for Workload services. (This is a Mandatory attribute).
	WorkloadExpressRouteConnections []*ExpressRouteConnectionInformation
}

NetworkFabricControllerPatchableProperties - Network Fabric Controller updatable properties

func (NetworkFabricControllerPatchableProperties) MarshalJSON 

func (n NetworkFabricControllerPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricControllerPatchableProperties.

func (*NetworkFabricControllerPatchableProperties) UnmarshalJSON 

func (n *NetworkFabricControllerPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricControllerPatchableProperties.

type NetworkFabricControllerProperties 

type NetworkFabricControllerProperties struct {
	// Switch configuration description.
	Annotation *string

	// IPv4 Network Fabric Controller Address Space.
	IPv4AddressSpace *string

	// IPv6 Network Fabric Controller Address Space.
	IPv6AddressSpace *string

	// As part of an update, the Infrastructure ExpressRoute CircuitID should be provided to create and Provision a NFC. This
	// Express route is dedicated for Infrastructure services. (This is a Mandatory
	// attribute)
	InfrastructureExpressRouteConnections []*ExpressRouteConnectionInformation

	// A workload management network is required for all the tenant (workload) traffic. This traffic is only dedicated for Tenant
	// workloads which are required to access internet or any other MSFT/Public
	// endpoints.
	IsWorkloadManagementNetworkEnabled *IsWorkloadManagementNetworkEnabled

	// Managed Resource Group configuration properties.
	ManagedResourceGroupConfiguration *ManagedResourceGroupConfiguration

	// Network Fabric Controller SKU.
	NfcSKU *NfcSKU

	// As part of an update, the workload ExpressRoute CircuitID should be provided to create and Provision a NFC. This Express
	// route is dedicated for Workload services. (This is a Mandatory attribute).
	WorkloadExpressRouteConnections []*ExpressRouteConnectionInformation

	// READ-ONLY; InfrastructureServices IP ranges.
	InfrastructureServices *ControllerServices

	// READ-ONLY; The NF-ID will be an input parameter used by the NF to link and get associated with the parent NFC Service.
	NetworkFabricIDs []*string

	// READ-ONLY; Provides you the latest status of the NFC service, whether it is Accepted, updating, Succeeded or Failed. During
	// this process, the states keep changing based on the status of NFC provisioning.
	ProvisioningState *ProvisioningState

	// READ-ONLY; List of tenant InternetGateway resource IDs
	TenantInternetGatewayIDs []*string

	// READ-ONLY; A workload management network is required for all the tenant (workload) traffic. This traffic is only dedicated
	// for Tenant workloads which are required to access internet or any other MSFT/Public
	// endpoints. This is used for the backward compatibility.
	WorkloadManagementNetwork *bool

	// READ-ONLY; WorkloadServices IP ranges.
	WorkloadServices *ControllerServices
}

NetworkFabricControllerProperties defines the resource properties.

func (NetworkFabricControllerProperties) MarshalJSON 

func (n NetworkFabricControllerProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricControllerProperties.

func (*NetworkFabricControllerProperties) UnmarshalJSON 

func (n *NetworkFabricControllerProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricControllerProperties.

type NetworkFabricControllersClient 

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

NetworkFabricControllersClient contains the methods for the NetworkFabricControllers group. Don't use this type directly, use NewNetworkFabricControllersClient() instead.

func NewNetworkFabricControllersClient 

func NewNetworkFabricControllersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkFabricControllersClient, error)

NewNetworkFabricControllersClient creates a new instance of NetworkFabricControllersClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkFabricControllersClient) BeginCreate 

func (client *NetworkFabricControllersClient) BeginCreate(ctx context.Context, resourceGroupName string, networkFabricControllerName string, body NetworkFabricController, options *NetworkFabricControllersClientBeginCreateOptions) (*runtime.Poller[NetworkFabricControllersClientCreateResponse], error)

BeginCreate - Creates a Network Fabric Controller. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricControllerName - Name of the Network Fabric Controller.
  • body - Request payload.
  • options - NetworkFabricControllersClientBeginCreateOptions contains the optional parameters for the NetworkFabricControllersClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricControllers_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricControllersClient().BeginCreate(ctx, "example-rg", "example-networkController", armmanagednetworkfabric.NetworkFabricController{
		Location: to.Ptr("eastus"),
		Properties: &armmanagednetworkfabric.NetworkFabricControllerProperties{
			Annotation: to.Ptr("annotation"),
			InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
				{
					ExpressRouteAuthorizationKey: to.Ptr("1234ABCD-0A1B-1234-5678-123456ABCDEF"),
					ExpressRouteCircuitID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
				}},
			WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
				{
					ExpressRouteAuthorizationKey: to.Ptr("xxxxx"),
					ExpressRouteCircuitID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
				}},
			IPv4AddressSpace:                   to.Ptr("172.253.0.0/19"),
			IPv6AddressSpace:                   to.Ptr("::/60"),
			IsWorkloadManagementNetworkEnabled: to.Ptr(armmanagednetworkfabric.IsWorkloadManagementNetworkEnabledTrue),
			ManagedResourceGroupConfiguration: &armmanagednetworkfabric.ManagedResourceGroupConfiguration{
				Name:     to.Ptr("managedResourceGroupName"),
				Location: to.Ptr("eastus"),
			},
			NfcSKU: to.Ptr(armmanagednetworkfabric.NfcSKUStandard),
		},
	}, 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.NetworkFabricController = armmanagednetworkfabric.NetworkFabricController{
	// 	Name: to.Ptr("example-networkController"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkfabriccontrollers"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkController"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Properties: &armmanagednetworkfabric.NetworkFabricControllerProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
	// 			{
	// 				ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
	// 		}},
	// 		WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
	// 			{
	// 				ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
	// 		}},
	// 		InfrastructureServices: &armmanagednetworkfabric.ControllerServices{
	// 			IPv4AddressSpaces: []*string{
	// 				to.Ptr("172.253.0.0/19")},
	// 				IPv6AddressSpaces: []*string{
	// 				},
	// 			},
	// 			IPv4AddressSpace: to.Ptr("172.253.0.0/19"),
	// 			IPv6AddressSpace: to.Ptr("::/60"),
	// 			IsWorkloadManagementNetworkEnabled: to.Ptr(armmanagednetworkfabric.IsWorkloadManagementNetworkEnabledTrue),
	// 			ManagedResourceGroupConfiguration: &armmanagednetworkfabric.ManagedResourceGroupConfiguration{
	// 				Name: to.Ptr("managedResourceGroupName"),
	// 				Location: to.Ptr("eastus"),
	// 			},
	// 			NetworkFabricIDs: []*string{
	// 				to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/networkFabrics/eaxmple-fabric")},
	// 				NfcSKU: to.Ptr(armmanagednetworkfabric.NfcSKUStandard),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 				TenantInternetGatewayIDs: []*string{
	// 					to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
	// 					WorkloadManagementNetwork: to.Ptr(true),
	// 					WorkloadServices: &armmanagednetworkfabric.ControllerServices{
	// 						IPv4AddressSpaces: []*string{
	// 							to.Ptr("172.253.28.0/22")},
	// 							IPv6AddressSpaces: []*string{
	// 							},
	// 						},
	// 					},
	// 				}
}

Output:

func (*NetworkFabricControllersClient) BeginDelete 

func (client *NetworkFabricControllersClient) BeginDelete(ctx context.Context, resourceGroupName string, networkFabricControllerName string, options *NetworkFabricControllersClientBeginDeleteOptions) (*runtime.Poller[NetworkFabricControllersClientDeleteResponse], error)

BeginDelete - Deletes the Network Fabric Controller resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricControllerName - Name of the Network Fabric Controller.
  • options - NetworkFabricControllersClientBeginDeleteOptions contains the optional parameters for the NetworkFabricControllersClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricControllers_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricControllersClient().BeginDelete(ctx, "example-rg", "example-networkController", 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)
	}
}

Output:

func (*NetworkFabricControllersClient) BeginUpdate 

func (client *NetworkFabricControllersClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkFabricControllerName string, body NetworkFabricControllerPatch, options *NetworkFabricControllersClientBeginUpdateOptions) (*runtime.Poller[NetworkFabricControllersClientUpdateResponse], error)

BeginUpdate - Updates are currently not supported for the Network Fabric Controller resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricControllerName - Name of the Network Fabric Controller.
  • body - Network Fabric Controller properties to update.
  • options - NetworkFabricControllersClientBeginUpdateOptions contains the optional parameters for the NetworkFabricControllersClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricControllers_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricControllersClient().BeginUpdate(ctx, "example-rg", "example-networkController", armmanagednetworkfabric.NetworkFabricControllerPatch{
		Properties: &armmanagednetworkfabric.NetworkFabricControllerPatchableProperties{
			InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
				{
					ExpressRouteAuthorizationKey: to.Ptr("xxxxxxx"),
					ExpressRouteCircuitID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
				}},
			WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
				{
					ExpressRouteAuthorizationKey: to.Ptr("xxxxxxx"),
					ExpressRouteCircuitID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
				}},
		},
	}, 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.NetworkFabricController = armmanagednetworkfabric.NetworkFabricController{
	// 	Name: to.Ptr("example-networkController"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkfabriccontrollers"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkController"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Properties: &armmanagednetworkfabric.NetworkFabricControllerProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
	// 			{
	// 				ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
	// 		}},
	// 		WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
	// 			{
	// 				ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
	// 		}},
	// 		InfrastructureServices: &armmanagednetworkfabric.ControllerServices{
	// 			IPv4AddressSpaces: []*string{
	// 				to.Ptr("172.253.0.0/19")},
	// 				IPv6AddressSpaces: []*string{
	// 				},
	// 			},
	// 			IPv4AddressSpace: to.Ptr("172.253.0.0/19"),
	// 			IPv6AddressSpace: to.Ptr("::/60"),
	// 			IsWorkloadManagementNetworkEnabled: to.Ptr(armmanagednetworkfabric.IsWorkloadManagementNetworkEnabledTrue),
	// 			ManagedResourceGroupConfiguration: &armmanagednetworkfabric.ManagedResourceGroupConfiguration{
	// 				Name: to.Ptr("managedResourceGroupName"),
	// 				Location: to.Ptr("eastus"),
	// 			},
	// 			NetworkFabricIDs: []*string{
	// 				to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/networkFabrics/eaxmple-fabric")},
	// 				NfcSKU: to.Ptr(armmanagednetworkfabric.NfcSKUStandard),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 				TenantInternetGatewayIDs: []*string{
	// 					to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
	// 					WorkloadManagementNetwork: to.Ptr(true),
	// 					WorkloadServices: &armmanagednetworkfabric.ControllerServices{
	// 						IPv4AddressSpaces: []*string{
	// 							to.Ptr("172.253.28.0/22")},
	// 							IPv6AddressSpaces: []*string{
	// 							},
	// 						},
	// 					},
	// 				}
}

Output:

func (*NetworkFabricControllersClient) Get 

func (client *NetworkFabricControllersClient) Get(ctx context.Context, resourceGroupName string, networkFabricControllerName string, options *NetworkFabricControllersClientGetOptions) (NetworkFabricControllersClientGetResponse, error)

Get - Shows the provisioning status of Network Fabric Controller. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricControllerName - Name of the Network Fabric Controller.
  • options - NetworkFabricControllersClientGetOptions contains the optional parameters for the NetworkFabricControllersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricControllers_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkFabricControllersClient().Get(ctx, "example-rg", "example-networkController", 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.NetworkFabricController = armmanagednetworkfabric.NetworkFabricController{
	// 	Name: to.Ptr("example-networkController"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkfabriccontrollers"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkController"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Properties: &armmanagednetworkfabric.NetworkFabricControllerProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
	// 			{
	// 				ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
	// 		}},
	// 		WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
	// 			{
	// 				ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
	// 		}},
	// 		InfrastructureServices: &armmanagednetworkfabric.ControllerServices{
	// 			IPv4AddressSpaces: []*string{
	// 				to.Ptr("172.253.0.0/19")},
	// 				IPv6AddressSpaces: []*string{
	// 				},
	// 			},
	// 			IPv4AddressSpace: to.Ptr("172.253.0.0/19"),
	// 			IPv6AddressSpace: to.Ptr("::/60"),
	// 			IsWorkloadManagementNetworkEnabled: to.Ptr(armmanagednetworkfabric.IsWorkloadManagementNetworkEnabledTrue),
	// 			ManagedResourceGroupConfiguration: &armmanagednetworkfabric.ManagedResourceGroupConfiguration{
	// 				Name: to.Ptr("managedResourceGroupName"),
	// 				Location: to.Ptr("eastus"),
	// 			},
	// 			NetworkFabricIDs: []*string{
	// 				to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/networkFabrics/eaxmple-fabric")},
	// 				NfcSKU: to.Ptr(armmanagednetworkfabric.NfcSKUStandard),
	// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 				TenantInternetGatewayIDs: []*string{
	// 					to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
	// 					WorkloadManagementNetwork: to.Ptr(true),
	// 					WorkloadServices: &armmanagednetworkfabric.ControllerServices{
	// 						IPv4AddressSpaces: []*string{
	// 							to.Ptr("172.253.28.0/22")},
	// 							IPv6AddressSpaces: []*string{
	// 							},
	// 						},
	// 					},
	// 				}
}

Output:

func (*NetworkFabricControllersClient) NewListByResourceGroupPager 

func (client *NetworkFabricControllersClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkFabricControllersClientListByResourceGroupOptions) *runtime.Pager[NetworkFabricControllersClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists all the NetworkFabricControllers thats available in the resource group.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkFabricControllersClientListByResourceGroupOptions contains the optional parameters for the NetworkFabricControllersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricControllers_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkFabricControllersClient().NewListByResourceGroupPager("example-rg", 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.NetworkFabricControllersListResult = armmanagednetworkfabric.NetworkFabricControllersListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkFabricController{
		// 		{
		// 			Name: to.Ptr("example-networkController"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkfabriccontrollers"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkController"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Properties: &armmanagednetworkfabric.NetworkFabricControllerProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
		// 					{
		// 						ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
		// 				}},
		// 				WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
		// 					{
		// 						ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
		// 				}},
		// 				InfrastructureServices: &armmanagednetworkfabric.ControllerServices{
		// 					IPv4AddressSpaces: []*string{
		// 						to.Ptr("172.253.0.0/19")},
		// 						IPv6AddressSpaces: []*string{
		// 						},
		// 					},
		// 					IPv4AddressSpace: to.Ptr("172.253.0.0/19"),
		// 					IPv6AddressSpace: to.Ptr("::/60"),
		// 					IsWorkloadManagementNetworkEnabled: to.Ptr(armmanagednetworkfabric.IsWorkloadManagementNetworkEnabledTrue),
		// 					ManagedResourceGroupConfiguration: &armmanagednetworkfabric.ManagedResourceGroupConfiguration{
		// 						Name: to.Ptr("managedResourceGroupName"),
		// 						Location: to.Ptr("eastus"),
		// 					},
		// 					NetworkFabricIDs: []*string{
		// 						to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/networkFabrics/eaxmple-fabric")},
		// 						NfcSKU: to.Ptr(armmanagednetworkfabric.NfcSKUStandard),
		// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 						TenantInternetGatewayIDs: []*string{
		// 							to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
		// 							WorkloadManagementNetwork: to.Ptr(true),
		// 							WorkloadServices: &armmanagednetworkfabric.ControllerServices{
		// 								IPv4AddressSpaces: []*string{
		// 									to.Ptr("172.253.28.0/22")},
		// 									IPv6AddressSpaces: []*string{
		// 									},
		// 								},
		// 							},
		// 					}},
		// 				}
	}
}

Output:

func (*NetworkFabricControllersClient) NewListBySubscriptionPager 

func (client *NetworkFabricControllersClient) NewListBySubscriptionPager(options *NetworkFabricControllersClientListBySubscriptionOptions) *runtime.Pager[NetworkFabricControllersClientListBySubscriptionResponse]

NewListBySubscriptionPager - Lists all the NetworkFabricControllers by subscription.

Generated from API version 2023-06-15

  • options - NetworkFabricControllersClientListBySubscriptionOptions contains the optional parameters for the NetworkFabricControllersClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricControllers_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkFabricControllersClient().NewListBySubscriptionPager(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.NetworkFabricControllersListResult = armmanagednetworkfabric.NetworkFabricControllersListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkFabricController{
		// 		{
		// 			Name: to.Ptr("example-networkController"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkfabriccontrollers"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-networkController"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-29T05:17:40.665Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Properties: &armmanagednetworkfabric.NetworkFabricControllerProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				InfrastructureExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
		// 					{
		// 						ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
		// 				}},
		// 				WorkloadExpressRouteConnections: []*armmanagednetworkfabric.ExpressRouteConnectionInformation{
		// 					{
		// 						ExpressRouteCircuitID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.Network/expressRouteCircuits/expressRouteCircuitName"),
		// 				}},
		// 				InfrastructureServices: &armmanagednetworkfabric.ControllerServices{
		// 					IPv4AddressSpaces: []*string{
		// 						to.Ptr("172.253.0.0/19")},
		// 						IPv6AddressSpaces: []*string{
		// 						},
		// 					},
		// 					IPv4AddressSpace: to.Ptr("172.253.0.0/19"),
		// 					IPv6AddressSpace: to.Ptr("::/60"),
		// 					IsWorkloadManagementNetworkEnabled: to.Ptr(armmanagednetworkfabric.IsWorkloadManagementNetworkEnabledTrue),
		// 					ManagedResourceGroupConfiguration: &armmanagednetworkfabric.ManagedResourceGroupConfiguration{
		// 						Name: to.Ptr("managedResourceGroupName"),
		// 						Location: to.Ptr("eastus"),
		// 					},
		// 					NetworkFabricIDs: []*string{
		// 						to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/networkFabrics/eaxmple-fabric")},
		// 						NfcSKU: to.Ptr(armmanagednetworkfabric.NfcSKUStandard),
		// 						ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 						TenantInternetGatewayIDs: []*string{
		// 							to.Ptr("/subscriptions/xxxxxx/resourceGroups/resourcegroupname/providers/Microsoft.ManagedNetworkFabric/internetGateways/example-internetGateway")},
		// 							WorkloadManagementNetwork: to.Ptr(true),
		// 							WorkloadServices: &armmanagednetworkfabric.ControllerServices{
		// 								IPv4AddressSpaces: []*string{
		// 									to.Ptr("172.253.28.0/22")},
		// 									IPv6AddressSpaces: []*string{
		// 									},
		// 								},
		// 							},
		// 					}},
		// 				}
	}
}

Output:

type NetworkFabricControllersClientBeginCreateOptions 

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

NetworkFabricControllersClientBeginCreateOptions contains the optional parameters for the NetworkFabricControllersClient.BeginCreate method.

type NetworkFabricControllersClientBeginDeleteOptions 

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

NetworkFabricControllersClientBeginDeleteOptions contains the optional parameters for the NetworkFabricControllersClient.BeginDelete method.

type NetworkFabricControllersClientBeginUpdateOptions 

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

NetworkFabricControllersClientBeginUpdateOptions contains the optional parameters for the NetworkFabricControllersClient.BeginUpdate method.

type NetworkFabricControllersClientCreateResponse 

type NetworkFabricControllersClientCreateResponse struct {
	// The Network Fabric Controller resource definition.
	NetworkFabricController
}

NetworkFabricControllersClientCreateResponse contains the response from method NetworkFabricControllersClient.BeginCreate.

type NetworkFabricControllersClientDeleteResponse 

type NetworkFabricControllersClientDeleteResponse struct {
}

NetworkFabricControllersClientDeleteResponse contains the response from method NetworkFabricControllersClient.BeginDelete.

type NetworkFabricControllersClientGetOptions 

type NetworkFabricControllersClientGetOptions struct {
}

NetworkFabricControllersClientGetOptions contains the optional parameters for the NetworkFabricControllersClient.Get method.

type NetworkFabricControllersClientGetResponse 

type NetworkFabricControllersClientGetResponse struct {
	// The Network Fabric Controller resource definition.
	NetworkFabricController
}

NetworkFabricControllersClientGetResponse contains the response from method NetworkFabricControllersClient.Get.

type NetworkFabricControllersClientListByResourceGroupOptions 

type NetworkFabricControllersClientListByResourceGroupOptions struct {
}

NetworkFabricControllersClientListByResourceGroupOptions contains the optional parameters for the NetworkFabricControllersClient.NewListByResourceGroupPager method.

type NetworkFabricControllersClientListByResourceGroupResponse 

type NetworkFabricControllersClientListByResourceGroupResponse struct {
	// List of Network Fabric Controllers.
	NetworkFabricControllersListResult
}

NetworkFabricControllersClientListByResourceGroupResponse contains the response from method NetworkFabricControllersClient.NewListByResourceGroupPager.

type NetworkFabricControllersClientListBySubscriptionOptions 

type NetworkFabricControllersClientListBySubscriptionOptions struct {
}

NetworkFabricControllersClientListBySubscriptionOptions contains the optional parameters for the NetworkFabricControllersClient.NewListBySubscriptionPager method.

type NetworkFabricControllersClientListBySubscriptionResponse 

type NetworkFabricControllersClientListBySubscriptionResponse struct {
	// List of Network Fabric Controllers.
	NetworkFabricControllersListResult
}

NetworkFabricControllersClientListBySubscriptionResponse contains the response from method NetworkFabricControllersClient.NewListBySubscriptionPager.

type NetworkFabricControllersClientUpdateResponse 

type NetworkFabricControllersClientUpdateResponse struct {
	// The Network Fabric Controller resource definition.
	NetworkFabricController
}

NetworkFabricControllersClientUpdateResponse contains the response from method NetworkFabricControllersClient.BeginUpdate.

type NetworkFabricControllersListResult 

type NetworkFabricControllersListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Network Fabric Controller resources.
	Value []*NetworkFabricController
}

NetworkFabricControllersListResult - List of Network Fabric Controllers.

func (NetworkFabricControllersListResult) MarshalJSON 

func (n NetworkFabricControllersListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricControllersListResult.

func (*NetworkFabricControllersListResult) UnmarshalJSON 

func (n *NetworkFabricControllersListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricControllersListResult.

type NetworkFabricPatch 

type NetworkFabricPatch struct {
	// Network Fabric Patch properties.
	Properties *NetworkFabricPatchProperties

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

NetworkFabricPatch - The Network Fabric resource definition.

func (NetworkFabricPatch) MarshalJSON 

func (n NetworkFabricPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricPatch.

func (*NetworkFabricPatch) UnmarshalJSON 

func (n *NetworkFabricPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricPatch.

type NetworkFabricPatchProperties 

type NetworkFabricPatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// ASN of CE devices for CE/PE connectivity.
	FabricASN *int64

	// IPv4Prefix for Management Network. Example: 10.1.0.0/19.
	IPv4Prefix *string

	// IPv6Prefix for Management Network. Example: 3FFE:FFFF:0:CD40::/59.
	IPv6Prefix *string

	// Configuration to be used to setup the management network.
	ManagementNetworkConfiguration *ManagementNetworkConfigurationPatchableProperties

	// Number of compute racks associated to Network Fabric.
	RackCount *int32

	// Number of servers.Possible values are from 1-16.
	ServerCountPerRack *int32

	// Network and credentials configuration already applied to terminal server.
	TerminalServerConfiguration *NetworkFabricPatchablePropertiesTerminalServerConfiguration
}

NetworkFabricPatchProperties - Network Fabric Patch properties.

func (NetworkFabricPatchProperties) MarshalJSON 

func (n NetworkFabricPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricPatchProperties.

func (*NetworkFabricPatchProperties) UnmarshalJSON 

func (n *NetworkFabricPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricPatchProperties.

type NetworkFabricPatchablePropertiesTerminalServerConfiguration 

type NetworkFabricPatchablePropertiesTerminalServerConfiguration struct {
	// Password for the terminal server connection.
	Password *string

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// Serial Number of Terminal server.
	SerialNumber *string

	// Username for the terminal server connection.
	Username *string
}

NetworkFabricPatchablePropertiesTerminalServerConfiguration - Network and credentials configuration already applied to terminal server.

func (NetworkFabricPatchablePropertiesTerminalServerConfiguration) MarshalJSON 

func (n NetworkFabricPatchablePropertiesTerminalServerConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricPatchablePropertiesTerminalServerConfiguration.

func (*NetworkFabricPatchablePropertiesTerminalServerConfiguration) UnmarshalJSON 

func (n *NetworkFabricPatchablePropertiesTerminalServerConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricPatchablePropertiesTerminalServerConfiguration.

type NetworkFabricProperties 

type NetworkFabricProperties struct {
	// REQUIRED; ASN of CE devices for CE/PE connectivity.
	FabricASN *int64

	// REQUIRED; IPv4Prefix for Management Network. Example: 10.1.0.0/19.
	IPv4Prefix *string

	// REQUIRED; Configuration to be used to setup the management network.
	ManagementNetworkConfiguration *ManagementNetworkConfigurationProperties

	// REQUIRED; Azure resource ID for the NetworkFabricController the NetworkFabric belongs.
	NetworkFabricControllerID *string

	// REQUIRED; Supported Network Fabric SKU.Example: Compute / Aggregate racks. Once the user chooses a particular SKU, only
	// supported racks can be added to the Network Fabric. The SKU determines whether it is a
	// single / multi rack Network Fabric.
	NetworkFabricSKU *string

	// REQUIRED; Number of servers.Possible values are from 1-16.
	ServerCountPerRack *int32

	// REQUIRED; Network and credentials configuration currently applied to terminal server.
	TerminalServerConfiguration *TerminalServerConfiguration

	// Switch configuration description.
	Annotation *string

	// IPv6Prefix for Management Network. Example: 3FFE:FFFF:0:CD40::/59
	IPv6Prefix *string

	// Number of compute racks associated to Network Fabric.
	RackCount *int32

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; The version of Network Fabric.
	FabricVersion *string

	// READ-ONLY; List of L2 Isolation Domain resource IDs under the Network Fabric.
	L2IsolationDomains []*string

	// READ-ONLY; List of L3 Isolation Domain resource IDs under the Network Fabric.
	L3IsolationDomains []*string

	// READ-ONLY; Provides you the latest status of the NFC service, whether it is Accepted, updating, Succeeded or Failed. During
	// this process, the states keep changing based on the status of NFC provisioning.
	ProvisioningState *ProvisioningState

	// READ-ONLY; List of NetworkRack resource IDs under the Network Fabric. The number of racks allowed depends on the Network
	// Fabric SKU.
	Racks []*string

	// READ-ONLY; Array of router IDs.
	RouterIDs []*string
}

NetworkFabricProperties - Network Fabric Properties defines the properties of the resource.

func (NetworkFabricProperties) MarshalJSON 

func (n NetworkFabricProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricProperties.

func (*NetworkFabricProperties) UnmarshalJSON 

func (n *NetworkFabricProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricProperties.

type NetworkFabricSKU 

type NetworkFabricSKU struct {
	// REQUIRED; Resource properties.
	Properties *NetworkFabricSKUProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkFabricSKU - The Network Fabric SKU resource definition.

func (NetworkFabricSKU) MarshalJSON 

func (n NetworkFabricSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricSKU.

func (*NetworkFabricSKU) UnmarshalJSON 

func (n *NetworkFabricSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricSKU.

type NetworkFabricSKUProperties 

type NetworkFabricSKUProperties struct {
	// Maximum number of compute racks available for this Network Fabric SKU. The value of max count racks is 4 for 4 rack SKU
	// and 8 for 8 rack SKU.
	MaxComputeRacks *int32

	// Maximum number of servers available for this Network Fabric SKU.
	MaximumServerCount *int32

	// READ-ONLY; URL providing detailed configuration of the fabric SKU.
	Details *string

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

	// READ-ONLY; List of supported Network Fabric SKU versions.
	SupportedVersions []*string

	// READ-ONLY; Type of Network Fabric SKU.
	Type *FabricSKUType
}

NetworkFabricSKUProperties - Network Fabric SKU Properties define properties of the resource.

func (NetworkFabricSKUProperties) MarshalJSON 

func (n NetworkFabricSKUProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricSKUProperties.

func (*NetworkFabricSKUProperties) UnmarshalJSON 

func (n *NetworkFabricSKUProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricSKUProperties.

type NetworkFabricSKUsClient 

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

NetworkFabricSKUsClient contains the methods for the NetworkFabricSKUs group. Don't use this type directly, use NewNetworkFabricSKUsClient() instead.

func NewNetworkFabricSKUsClient 

func NewNetworkFabricSKUsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkFabricSKUsClient, error)

NewNetworkFabricSKUsClient creates a new instance of NetworkFabricSKUsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkFabricSKUsClient) Get 

func (client *NetworkFabricSKUsClient) Get(ctx context.Context, networkFabricSKUName string, options *NetworkFabricSKUsClientGetOptions) (NetworkFabricSKUsClientGetResponse, error)

Get - Implements Network Fabric SKU GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • networkFabricSKUName - Name of the Network Fabric SKU.
  • options - NetworkFabricSKUsClientGetOptions contains the optional parameters for the NetworkFabricSKUsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricSkus_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkFabricSKUsClient().Get(ctx, "example-fabricsku", 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.NetworkFabricSKU = armmanagednetworkfabric.NetworkFabricSKU{
	// 	Name: to.Ptr("example-fabricsku"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkFabricSkus"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/providers/Microsoft.ManagedNetworkFabric/networkFabricSkus/example-fabricsku"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:44:43.644Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:44:43.644Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("User@email.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkFabricSKUProperties{
	// 		Type: to.Ptr(armmanagednetworkfabric.FabricSKUTypeSingleRack),
	// 		MaxComputeRacks: to.Ptr[int32](4),
	// 		MaximumServerCount: to.Ptr[int32](9),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		SupportedVersions: []*string{
	// 			to.Ptr("1.0.0")},
	// 			Details: to.Ptr("https://azure/fabricskuDetails"),
	// 		},
	// 	}
}

Output:

func (*NetworkFabricSKUsClient) NewListBySubscriptionPager 

func (client *NetworkFabricSKUsClient) NewListBySubscriptionPager(options *NetworkFabricSKUsClientListBySubscriptionOptions) *runtime.Pager[NetworkFabricSKUsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Implements Network Fabric SKUs list by subscription GET method.

Generated from API version 2023-06-15

  • options - NetworkFabricSKUsClientListBySubscriptionOptions contains the optional parameters for the NetworkFabricSKUsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabricSkus_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkFabricSKUsClient().NewListBySubscriptionPager(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.NetworkFabricSKUsListResult = armmanagednetworkfabric.NetworkFabricSKUsListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkFabricSKU{
		// 		{
		// 			Name: to.Ptr("example-fabricsku"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkFabricSkus"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/providers/Microsoft.ManagedNetworkFabric/networkFabricSkus/example-fabricsku"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:44:43.644Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:44:43.644Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("User@email.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkFabricSKUProperties{
		// 				Type: to.Ptr(armmanagednetworkfabric.FabricSKUTypeSingleRack),
		// 				MaxComputeRacks: to.Ptr[int32](4),
		// 				MaximumServerCount: to.Ptr[int32](9),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				SupportedVersions: []*string{
		// 					to.Ptr("1.0.0")},
		// 					Details: to.Ptr("https://azure/fabricskuDetails"),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type NetworkFabricSKUsClientGetOptions 

type NetworkFabricSKUsClientGetOptions struct {
}

NetworkFabricSKUsClientGetOptions contains the optional parameters for the NetworkFabricSKUsClient.Get method.

type NetworkFabricSKUsClientGetResponse 

type NetworkFabricSKUsClientGetResponse struct {
	// The Network Fabric SKU resource definition.
	NetworkFabricSKU
}

NetworkFabricSKUsClientGetResponse contains the response from method NetworkFabricSKUsClient.Get.

type NetworkFabricSKUsClientListBySubscriptionOptions 

type NetworkFabricSKUsClientListBySubscriptionOptions struct {
}

NetworkFabricSKUsClientListBySubscriptionOptions contains the optional parameters for the NetworkFabricSKUsClient.NewListBySubscriptionPager method.

type NetworkFabricSKUsClientListBySubscriptionResponse 

type NetworkFabricSKUsClientListBySubscriptionResponse struct {
	// List of Network Fabric SKUs.
	NetworkFabricSKUsListResult
}

NetworkFabricSKUsClientListBySubscriptionResponse contains the response from method NetworkFabricSKUsClient.NewListBySubscriptionPager.

type NetworkFabricSKUsListResult 

type NetworkFabricSKUsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Network Fabric SKU resources.
	Value []*NetworkFabricSKU
}

NetworkFabricSKUsListResult - List of Network Fabric SKUs.

func (NetworkFabricSKUsListResult) MarshalJSON 

func (n NetworkFabricSKUsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricSKUsListResult.

func (*NetworkFabricSKUsListResult) UnmarshalJSON 

func (n *NetworkFabricSKUsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricSKUsListResult.

type NetworkFabricsClient 

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

NetworkFabricsClient contains the methods for the NetworkFabrics group. Don't use this type directly, use NewNetworkFabricsClient() instead.

func NewNetworkFabricsClient 

func NewNetworkFabricsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkFabricsClient, error)

NewNetworkFabricsClient creates a new instance of NetworkFabricsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkFabricsClient) BeginCommitConfiguration 

func (client *NetworkFabricsClient) BeginCommitConfiguration(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientBeginCommitConfigurationOptions) (*runtime.Poller[NetworkFabricsClientCommitConfigurationResponse], error)

BeginCommitConfiguration - Atomic update of the given Network Fabric instance. Sync update of NFA resources at Fabric level. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientBeginCommitConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginCommitConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_CommitConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginCommitConfiguration(ctx, "example-rg", "example-fabric", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr("202"),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkFabricsClient) BeginCreate 

func (client *NetworkFabricsClient) BeginCreate(ctx context.Context, resourceGroupName string, networkFabricName string, body NetworkFabric, options *NetworkFabricsClientBeginCreateOptions) (*runtime.Poller[NetworkFabricsClientCreateResponse], error)

BeginCreate - Create Network Fabric resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • body - Request payload.
  • options - NetworkFabricsClientBeginCreateOptions contains the optional parameters for the NetworkFabricsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginCreate(ctx, "example-rg", "example-fabric", armmanagednetworkfabric.NetworkFabric{
		Location: to.Ptr("eastuseuap"),
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkFabricProperties{
			Annotation: to.Ptr("annotation"),
			FabricASN:  to.Ptr[int64](29249),
			IPv4Prefix: to.Ptr("10.18.0.0/19"),
			IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/59"),
			ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationProperties{
				InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
					NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
					OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
						PrimaryIPv4Prefix:   to.Ptr("10.0.0.12/30"),
						PrimaryIPv6Prefix:   to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
						SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
						SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
						BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
							IntervalInMilliSeconds: to.Ptr[int32](300),
							Multiplier:             to.Ptr[int32](10),
						},
						Mtu:     to.Ptr[int32](1501),
						PeerASN: to.Ptr[int64](1235),
						VlanID:  to.Ptr[int32](3001),
					},
					OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
						ExportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						ImportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
							ExportIPv4RouteTargets: []*string{
								to.Ptr("65046:10039")},
							ExportIPv6RouteTargets: []*string{
								to.Ptr("65046:10039")},
							ImportIPv4RouteTargets: []*string{
								to.Ptr("65046:10039")},
							ImportIPv6RouteTargets: []*string{
								to.Ptr("65046:10039")},
						},
					},
					PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
				},
				WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
					NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
					OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
						PrimaryIPv4Prefix:   to.Ptr("10.0.0.14/30"),
						PrimaryIPv6Prefix:   to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
						SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
						SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
						BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
							IntervalInMilliSeconds: to.Ptr[int32](300),
							Multiplier:             to.Ptr[int32](5),
						},
						Mtu:     to.Ptr[int32](1500),
						PeerASN: to.Ptr[int64](61234),
						VlanID:  to.Ptr[int32](3000),
					},
					OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
						ExportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						ImportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
							ExportIPv4RouteTargets: []*string{
								to.Ptr("65046:10039")},
							ExportIPv6RouteTargets: []*string{
								to.Ptr("65046:10039")},
							ImportIPv4RouteTargets: []*string{
								to.Ptr("65046:10039")},
							ImportIPv6RouteTargets: []*string{
								to.Ptr("65046:10039")},
						},
					},
					PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
				},
			},
			NetworkFabricControllerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-fabricController"),
			NetworkFabricSKU:          to.Ptr("M4-A400-A100-C16-aa"),
			RackCount:                 to.Ptr[int32](4),
			ServerCountPerRack:        to.Ptr[int32](8),
			TerminalServerConfiguration: &armmanagednetworkfabric.TerminalServerConfiguration{
				PrimaryIPv4Prefix:   to.Ptr("10.0.0.12/30"),
				PrimaryIPv6Prefix:   to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
				SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
				SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
				Password:            to.Ptr("xxxx"),
				SerialNumber:        to.Ptr("123456"),
				Username:            to.Ptr("username"),
			},
		},
	}, 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.NetworkFabric = armmanagednetworkfabric.NetworkFabric{
	// 	Name: to.Ptr("example-fabric"),
	// 	Type: to.Ptr("Microsoft.ManagedNetworkFabric/networkFabrics"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@email.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkFabricProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		FabricASN: to.Ptr[int64](29249),
	// 		FabricVersion: to.Ptr("version1"),
	// 		IPv4Prefix: to.Ptr("10.18.0.0/19"),
	// 		IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/59"),
	// 		L2IsolationDomains: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2Domain")},
	// 			L3IsolationDomains: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3Domain")},
	// 				ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationProperties{
	// 					InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
	// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 						NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 						OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
	// 							PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 							PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 							SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
	// 							SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 							BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 								AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 								IntervalInMilliSeconds: to.Ptr[int32](300),
	// 								Multiplier: to.Ptr[int32](10),
	// 							},
	// 							Mtu: to.Ptr[int32](1501),
	// 							PeerASN: to.Ptr[int64](1235),
	// 							VlanID: to.Ptr[int32](3001),
	// 						},
	// 						OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
	// 							ExportRouteTargets: []*string{
	// 								to.Ptr("65046:10050")},
	// 								ImportRouteTargets: []*string{
	// 									to.Ptr("65046:10050")},
	// 									RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 										ExportIPv4RouteTargets: []*string{
	// 											to.Ptr("65046:10050")},
	// 											ExportIPv6RouteTargets: []*string{
	// 												to.Ptr("65046:10050")},
	// 												ImportIPv4RouteTargets: []*string{
	// 													to.Ptr("65046:10050")},
	// 													ImportIPv6RouteTargets: []*string{
	// 														to.Ptr("65046:10050")},
	// 													},
	// 												},
	// 												PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 											},
	// 											WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
	// 												AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 												NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 												OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
	// 													PrimaryIPv4Prefix: to.Ptr("10.0.0.14/30"),
	// 													PrimaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
	// 													SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
	// 													SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
	// 													BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 														IntervalInMilliSeconds: to.Ptr[int32](300),
	// 														Multiplier: to.Ptr[int32](5),
	// 													},
	// 													Mtu: to.Ptr[int32](1500),
	// 													PeerASN: to.Ptr[int64](61234),
	// 													VlanID: to.Ptr[int32](3000),
	// 												},
	// 												OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
	// 													ExportRouteTargets: []*string{
	// 														to.Ptr("65046:10050")},
	// 														ImportRouteTargets: []*string{
	// 															to.Ptr("65046:10050")},
	// 															RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 																ExportIPv4RouteTargets: []*string{
	// 																	to.Ptr("65046:10050")},
	// 																	ExportIPv6RouteTargets: []*string{
	// 																		to.Ptr("65046:10050")},
	// 																		ImportIPv4RouteTargets: []*string{
	// 																			to.Ptr("65046:10050")},
	// 																			ImportIPv6RouteTargets: []*string{
	// 																				to.Ptr("65046:10050")},
	// 																			},
	// 																		},
	// 																		PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 																	},
	// 																},
	// 																NetworkFabricControllerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-fabricController"),
	// 																NetworkFabricSKU: to.Ptr("M4-A400-A100-C16-aa"),
	// 																ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 																RackCount: to.Ptr[int32](4),
	// 																Racks: []*string{
	// 																	to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-networkRack")},
	// 																	RouterIDs: []*string{
	// 																		to.Ptr("routerId")},
	// 																		ServerCountPerRack: to.Ptr[int32](8),
	// 																		TerminalServerConfiguration: &armmanagednetworkfabric.TerminalServerConfiguration{
	// 																			PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 																			PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 																			SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
	// 																			SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 																			SerialNumber: to.Ptr("123456"),
	// 																			Username: to.Ptr("username"),
	// 																			NetworkDeviceID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice"),
	// 																		},
	// 																	},
	// 																}
}

Output:

func (*NetworkFabricsClient) BeginDelete 

func (client *NetworkFabricsClient) BeginDelete(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientBeginDeleteOptions) (*runtime.Poller[NetworkFabricsClientDeleteResponse], error)

BeginDelete - Delete Network Fabric resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientBeginDeleteOptions contains the optional parameters for the NetworkFabricsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginDelete(ctx, "example-rg", "example-fabric", 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)
	}
}

Output:

func (*NetworkFabricsClient) BeginDeprovision 

func (client *NetworkFabricsClient) BeginDeprovision(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientBeginDeprovisionOptions) (*runtime.Poller[NetworkFabricsClientDeprovisionResponse], error)

BeginDeprovision - Deprovisions the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientBeginDeprovisionOptions contains the optional parameters for the NetworkFabricsClient.BeginDeprovision method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_deprovision_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginDeprovision(ctx, "example-rg", "example-fabric", 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.CommonPostActionResponseForDeviceUpdate = armmanagednetworkfabric.CommonPostActionResponseForDeviceUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr("200"),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	FailedDevices: []*string{
	// 		to.Ptr("")},
	// 		SuccessfulDevices: []*string{
	// 			to.Ptr("")},
	// 		}
}

Output:

func (*NetworkFabricsClient) BeginGetTopology 

func (client *NetworkFabricsClient) BeginGetTopology(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientBeginGetTopologyOptions) (*runtime.Poller[NetworkFabricsClientGetTopologyResponse], error)

BeginGetTopology - Gets Topology of the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientBeginGetTopologyOptions contains the optional parameters for the NetworkFabricsClient.BeginGetTopology method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_GetTopology_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginGetTopology(ctx, "example-rg", "example-fabric", 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ActionDetails"),
	// }
}

Output:

func (*NetworkFabricsClient) BeginProvision 

func (client *NetworkFabricsClient) BeginProvision(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientBeginProvisionOptions) (*runtime.Poller[NetworkFabricsClientProvisionResponse], error)

BeginProvision - Provisions the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientBeginProvisionOptions contains the optional parameters for the NetworkFabricsClient.BeginProvision method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_provision_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginProvision(ctx, "example-rg", "example-fabric", 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.CommonPostActionResponseForDeviceUpdate = armmanagednetworkfabric.CommonPostActionResponseForDeviceUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	FailedDevices: []*string{
	// 		to.Ptr("")},
	// 		SuccessfulDevices: []*string{
	// 			to.Ptr("")},
	// 		}
}

Output:

func (*NetworkFabricsClient) BeginRefreshConfiguration 

func (client *NetworkFabricsClient) BeginRefreshConfiguration(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientBeginRefreshConfigurationOptions) (*runtime.Poller[NetworkFabricsClientRefreshConfigurationResponse], error)

BeginRefreshConfiguration - Refreshes the configuration of the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientBeginRefreshConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginRefreshConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_refreshConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginRefreshConfiguration(ctx, "example-rg", "example-fabric", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr("lvazqudujtegfmv"),
	// 		}},
	// 		Code: to.Ptr("utdowavxlslkhmy"),
	// 		Message: to.Ptr("otosyssdlaizpidtzcmiwvesc"),
	// 		Target: to.Ptr("kht"),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkFabricsClient) BeginUpdate 

func (client *NetworkFabricsClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkFabricName string, body NetworkFabricPatch, options *NetworkFabricsClientBeginUpdateOptions) (*runtime.Poller[NetworkFabricsClientUpdateResponse], error)

BeginUpdate - Update certain properties of the Network Fabric resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • body - Network Fabric properties to update.
  • options - NetworkFabricsClientBeginUpdateOptions contains the optional parameters for the NetworkFabricsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginUpdate(ctx, "example-rg", "example-fabric", armmanagednetworkfabric.NetworkFabricPatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("KeyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkFabricPatchProperties{
			Annotation: to.Ptr("annotation1"),
			FabricASN:  to.Ptr[int64](12345),
			IPv4Prefix: to.Ptr("10.18.0.0/17"),
			IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/60"),
			ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationPatchableProperties{
				InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationPatchableProperties{
					NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
					OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPatchablePropertiesOptionAProperties{
						PrimaryIPv4Prefix:   to.Ptr("10.0.0.12/30"),
						PrimaryIPv6Prefix:   to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
						SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
						SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
						BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
							IntervalInMilliSeconds: to.Ptr[int32](300),
							Multiplier:             to.Ptr[int32](10),
						},
						Mtu:     to.Ptr[int32](1501),
						PeerASN: to.Ptr[int64](1235),
						VlanID:  to.Ptr[int32](3001),
					},
					OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
						ExportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						ImportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
							ExportIPv4RouteTargets: []*string{
								to.Ptr("65046:10050")},
							ExportIPv6RouteTargets: []*string{
								to.Ptr("65046:10050")},
							ImportIPv4RouteTargets: []*string{
								to.Ptr("65046:10050")},
							ImportIPv6RouteTargets: []*string{
								to.Ptr("65046:10050")},
						},
					},
					PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionB),
				},
				WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationPatchableProperties{
					NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
					OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPatchablePropertiesOptionAProperties{
						PrimaryIPv4Prefix:   to.Ptr("10.0.0.14/30"),
						PrimaryIPv6Prefix:   to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
						SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
						SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
						BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
							IntervalInMilliSeconds: to.Ptr[int32](300),
							Multiplier:             to.Ptr[int32](5),
						},
						Mtu:     to.Ptr[int32](1500),
						PeerASN: to.Ptr[int64](61234),
						VlanID:  to.Ptr[int32](3000),
					},
					OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
						ExportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						ImportRouteTargets: []*string{
							to.Ptr("65046:10050")},
						RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
							ExportIPv4RouteTargets: []*string{
								to.Ptr("65046:10050")},
							ExportIPv6RouteTargets: []*string{
								to.Ptr("65046:10050")},
							ImportIPv4RouteTargets: []*string{
								to.Ptr("65046:10050")},
							ImportIPv6RouteTargets: []*string{
								to.Ptr("65046:10050")},
						},
					},
					PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
				},
			},
			RackCount:          to.Ptr[int32](6),
			ServerCountPerRack: to.Ptr[int32](10),
			TerminalServerConfiguration: &armmanagednetworkfabric.NetworkFabricPatchablePropertiesTerminalServerConfiguration{
				PrimaryIPv4Prefix:   to.Ptr("10.0.0.12/30"),
				PrimaryIPv6Prefix:   to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
				SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
				SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
				Password:            to.Ptr("xxxxxxxx"),
				SerialNumber:        to.Ptr("1234567"),
				Username:            to.Ptr("username1"),
			},
		},
	}, 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.NetworkFabric = armmanagednetworkfabric.NetworkFabric{
	// 	Name: to.Ptr("example-fabric"),
	// 	Type: to.Ptr("Microsoft.ManagedNetworkFabric/networkFabrics"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@email.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkFabricProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		FabricASN: to.Ptr[int64](12345),
	// 		FabricVersion: to.Ptr("version1"),
	// 		IPv4Prefix: to.Ptr("10.18.0.0/17"),
	// 		IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/60"),
	// 		L2IsolationDomains: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2Domain")},
	// 			L3IsolationDomains: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3Domain")},
	// 				ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationProperties{
	// 					InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
	// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 						NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 						OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
	// 							PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 							PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 							SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
	// 							SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 							BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 								AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 								IntervalInMilliSeconds: to.Ptr[int32](300),
	// 								Multiplier: to.Ptr[int32](10),
	// 							},
	// 							Mtu: to.Ptr[int32](1501),
	// 							PeerASN: to.Ptr[int64](1235),
	// 							VlanID: to.Ptr[int32](3001),
	// 						},
	// 						OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
	// 							ExportRouteTargets: []*string{
	// 								to.Ptr("65046:10050")},
	// 								ImportRouteTargets: []*string{
	// 									to.Ptr("65046:10050")},
	// 									RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 										ExportIPv4RouteTargets: []*string{
	// 											to.Ptr("65046:10050")},
	// 											ExportIPv6RouteTargets: []*string{
	// 												to.Ptr("65046:10050")},
	// 												ImportIPv4RouteTargets: []*string{
	// 													to.Ptr("65046:10050")},
	// 													ImportIPv6RouteTargets: []*string{
	// 														to.Ptr("65046:10050")},
	// 													},
	// 												},
	// 												PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionB),
	// 											},
	// 											WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
	// 												AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 												NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 												OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
	// 													PrimaryIPv4Prefix: to.Ptr("10.0.0.14/30"),
	// 													PrimaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
	// 													SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
	// 													SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
	// 													BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 														IntervalInMilliSeconds: to.Ptr[int32](300),
	// 														Multiplier: to.Ptr[int32](5),
	// 													},
	// 													Mtu: to.Ptr[int32](1500),
	// 													PeerASN: to.Ptr[int64](61234),
	// 													VlanID: to.Ptr[int32](3000),
	// 												},
	// 												OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
	// 													ExportRouteTargets: []*string{
	// 														to.Ptr("65046:10050")},
	// 														ImportRouteTargets: []*string{
	// 															to.Ptr("65046:10050")},
	// 															RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 																ExportIPv4RouteTargets: []*string{
	// 																	to.Ptr("65046:10050")},
	// 																	ExportIPv6RouteTargets: []*string{
	// 																		to.Ptr("65046:10050")},
	// 																		ImportIPv4RouteTargets: []*string{
	// 																			to.Ptr("65046:10050")},
	// 																			ImportIPv6RouteTargets: []*string{
	// 																				to.Ptr("65046:10050")},
	// 																			},
	// 																		},
	// 																		PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 																	},
	// 																},
	// 																NetworkFabricControllerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-fabricController"),
	// 																NetworkFabricSKU: to.Ptr("M4-A400-A100-C16-aa"),
	// 																ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 																RackCount: to.Ptr[int32](6),
	// 																Racks: []*string{
	// 																	to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-networkRack")},
	// 																	RouterIDs: []*string{
	// 																		to.Ptr("routerId")},
	// 																		ServerCountPerRack: to.Ptr[int32](10),
	// 																		TerminalServerConfiguration: &armmanagednetworkfabric.TerminalServerConfiguration{
	// 																			PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 																			PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 																			SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
	// 																			SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 																			SerialNumber: to.Ptr("1234567"),
	// 																			Username: to.Ptr("username1"),
	// 																			NetworkDeviceID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice"),
	// 																		},
	// 																	},
	// 																}
}

Output:

func (*NetworkFabricsClient) BeginUpdateInfraManagementBfdConfiguration 

func (client *NetworkFabricsClient) BeginUpdateInfraManagementBfdConfiguration(ctx context.Context, resourceGroupName string, networkFabricName string, body UpdateAdministrativeState, options *NetworkFabricsClientBeginUpdateInfraManagementBfdConfigurationOptions) (*runtime.Poller[NetworkFabricsClientUpdateInfraManagementBfdConfigurationResponse], error)

BeginUpdateInfraManagementBfdConfiguration - Updates the Infra Management BFD Configuration of the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • body - Request payload.
  • options - NetworkFabricsClientBeginUpdateInfraManagementBfdConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginUpdateInfraManagementBfdConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_UpdateInfraManagementBfdConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginUpdateInfraManagementBfdConfiguration(ctx, "example-rg", "example-fabric", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkFabricsClient) BeginUpdateWorkloadManagementBfdConfiguration 

func (client *NetworkFabricsClient) BeginUpdateWorkloadManagementBfdConfiguration(ctx context.Context, resourceGroupName string, networkFabricName string, body UpdateAdministrativeState, options *NetworkFabricsClientBeginUpdateWorkloadManagementBfdConfigurationOptions) (*runtime.Poller[NetworkFabricsClientUpdateWorkloadManagementBfdConfigurationResponse], error)

BeginUpdateWorkloadManagementBfdConfiguration - Updates the Workload Management BFD Configuration of the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • body - Request payload.
  • options - NetworkFabricsClientBeginUpdateWorkloadManagementBfdConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginUpdateWorkloadManagementBfdConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_UpdateWorkloadManagementBfdConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginUpdateWorkloadManagementBfdConfiguration(ctx, "example-rg", "example-fabric", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkFabricsClient) BeginUpgrade 

func (client *NetworkFabricsClient) BeginUpgrade(ctx context.Context, resourceGroupName string, networkFabricName string, body UpdateVersion, options *NetworkFabricsClientBeginUpgradeOptions) (*runtime.Poller[NetworkFabricsClientUpgradeResponse], error)

BeginUpgrade - Upgrades the version of the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • body - Network Fabric properties to update.
  • options - NetworkFabricsClientBeginUpgradeOptions contains the optional parameters for the NetworkFabricsClient.BeginUpgrade method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_upgrade_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginUpgrade(ctx, "example-rg", "example-fabric", armmanagednetworkfabric.UpdateVersion{
		Version: to.Ptr("version1"),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkFabricsClient) BeginValidateConfiguration 

func (client *NetworkFabricsClient) BeginValidateConfiguration(ctx context.Context, resourceGroupName string, networkFabricName string, body ValidateConfigurationProperties, options *NetworkFabricsClientBeginValidateConfigurationOptions) (*runtime.Poller[NetworkFabricsClientValidateConfigurationResponse], error)

BeginValidateConfiguration - Validates the configuration of the underlying resources in the given Network Fabric instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • body - Validate configuration properties.
  • options - NetworkFabricsClientBeginValidateConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginValidateConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_ValidateConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkFabricsClient().BeginValidateConfiguration(ctx, "example-rg", "example-fabric", armmanagednetworkfabric.ValidateConfigurationProperties{
		ValidateAction: to.Ptr(armmanagednetworkfabric.ValidateActionCabling),
	}, 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ActionDetails"),
	// }
}

Output:

func (*NetworkFabricsClient) Get 

func (client *NetworkFabricsClient) Get(ctx context.Context, resourceGroupName string, networkFabricName string, options *NetworkFabricsClientGetOptions) (NetworkFabricsClientGetResponse, error)

Get - Get Network Fabric resource details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkFabricsClientGetOptions contains the optional parameters for the NetworkFabricsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkFabricsClient().Get(ctx, "example-rg", "example-fabric", 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.NetworkFabric = armmanagednetworkfabric.NetworkFabric{
	// 	Name: to.Ptr("example-fabric"),
	// 	Type: to.Ptr("Microsoft.ManagedNetworkFabric/networkFabrics"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@email.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("KeyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkFabricProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		FabricASN: to.Ptr[int64](29249),
	// 		FabricVersion: to.Ptr("version1"),
	// 		IPv4Prefix: to.Ptr("10.18.0.0/19"),
	// 		IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/59"),
	// 		L2IsolationDomains: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2Domain")},
	// 			L3IsolationDomains: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3Domain")},
	// 				ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationProperties{
	// 					InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
	// 						AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 						NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 						OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
	// 							PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 							PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 							SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
	// 							SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 							BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 								AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 								IntervalInMilliSeconds: to.Ptr[int32](300),
	// 								Multiplier: to.Ptr[int32](10),
	// 							},
	// 							Mtu: to.Ptr[int32](1501),
	// 							PeerASN: to.Ptr[int64](1235),
	// 							VlanID: to.Ptr[int32](3001),
	// 						},
	// 						OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
	// 							ExportRouteTargets: []*string{
	// 								to.Ptr("65046:10050")},
	// 								ImportRouteTargets: []*string{
	// 									to.Ptr("65046:10050")},
	// 									RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 										ExportIPv4RouteTargets: []*string{
	// 											to.Ptr("65046:10050")},
	// 											ExportIPv6RouteTargets: []*string{
	// 												to.Ptr("65046:10050")},
	// 												ImportIPv4RouteTargets: []*string{
	// 													to.Ptr("65046:10050")},
	// 													ImportIPv6RouteTargets: []*string{
	// 														to.Ptr("65046:10050")},
	// 													},
	// 												},
	// 												PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 											},
	// 											WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
	// 												AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 												NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 												OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
	// 													PrimaryIPv4Prefix: to.Ptr("10.0.0.14/30"),
	// 													PrimaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
	// 													SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
	// 													SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
	// 													BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 														IntervalInMilliSeconds: to.Ptr[int32](300),
	// 														Multiplier: to.Ptr[int32](5),
	// 													},
	// 													Mtu: to.Ptr[int32](1500),
	// 													PeerASN: to.Ptr[int64](61234),
	// 													VlanID: to.Ptr[int32](3000),
	// 												},
	// 												OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
	// 													ExportRouteTargets: []*string{
	// 														to.Ptr("65046:10050")},
	// 														ImportRouteTargets: []*string{
	// 															to.Ptr("65046:10050")},
	// 															RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
	// 																ExportIPv4RouteTargets: []*string{
	// 																	to.Ptr("65046:10050")},
	// 																	ExportIPv6RouteTargets: []*string{
	// 																		to.Ptr("65046:10050")},
	// 																		ImportIPv4RouteTargets: []*string{
	// 																			to.Ptr("65046:10050")},
	// 																			ImportIPv6RouteTargets: []*string{
	// 																				to.Ptr("65046:10050")},
	// 																			},
	// 																		},
	// 																		PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
	// 																	},
	// 																},
	// 																NetworkFabricControllerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-fabricController"),
	// 																NetworkFabricSKU: to.Ptr("M4-A400-A100-C16-aa"),
	// 																ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 																RackCount: to.Ptr[int32](4),
	// 																Racks: []*string{
	// 																	to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-networkRack")},
	// 																	RouterIDs: []*string{
	// 																		to.Ptr("routerId")},
	// 																		ServerCountPerRack: to.Ptr[int32](8),
	// 																		TerminalServerConfiguration: &armmanagednetworkfabric.TerminalServerConfiguration{
	// 																			PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 																			PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 																			SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
	// 																			SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 																			SerialNumber: to.Ptr("123456"),
	// 																			Username: to.Ptr("username"),
	// 																			NetworkDeviceID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice"),
	// 																		},
	// 																	},
	// 																}
}

Output:

func (*NetworkFabricsClient) NewListByResourceGroupPager 

func (client *NetworkFabricsClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkFabricsClientListByResourceGroupOptions) *runtime.Pager[NetworkFabricsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all the Network Fabric resources in the given resource group.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkFabricsClientListByResourceGroupOptions contains the optional parameters for the NetworkFabricsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkFabricsClient().NewListByResourceGroupPager("example-rg", 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.NetworkFabricsListResult = armmanagednetworkfabric.NetworkFabricsListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkFabric{
		// 		{
		// 			Name: to.Ptr("example-fabric"),
		// 			Type: to.Ptr("Microsoft.ManagedNetworkFabric/networkFabrics"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@email.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkFabricProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				FabricASN: to.Ptr[int64](29249),
		// 				FabricVersion: to.Ptr("version1"),
		// 				IPv4Prefix: to.Ptr("10.18.0.0/19"),
		// 				IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/59"),
		// 				L2IsolationDomains: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2Domain")},
		// 					L3IsolationDomains: []*string{
		// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3Domain")},
		// 						ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationProperties{
		// 							InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
		// 								AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 								NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
		// 								OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
		// 									PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
		// 									PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
		// 									SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
		// 									SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
		// 									BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 										AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 										IntervalInMilliSeconds: to.Ptr[int32](300),
		// 										Multiplier: to.Ptr[int32](10),
		// 									},
		// 									Mtu: to.Ptr[int32](1501),
		// 									PeerASN: to.Ptr[int64](1235),
		// 									VlanID: to.Ptr[int32](3001),
		// 								},
		// 								OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
		// 									ExportRouteTargets: []*string{
		// 										to.Ptr("65046:10050")},
		// 										ImportRouteTargets: []*string{
		// 											to.Ptr("65046:10050")},
		// 											RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
		// 												ExportIPv4RouteTargets: []*string{
		// 													to.Ptr("65046:10050")},
		// 													ExportIPv6RouteTargets: []*string{
		// 														to.Ptr("65046:10050")},
		// 														ImportIPv4RouteTargets: []*string{
		// 															to.Ptr("65046:10050")},
		// 															ImportIPv6RouteTargets: []*string{
		// 																to.Ptr("65046:10050")},
		// 															},
		// 														},
		// 														PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		// 													},
		// 													WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
		// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 														NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
		// 														OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
		// 															PrimaryIPv4Prefix: to.Ptr("10.0.0.14/30"),
		// 															PrimaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
		// 															SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
		// 															SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
		// 															BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 																AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 																IntervalInMilliSeconds: to.Ptr[int32](300),
		// 																Multiplier: to.Ptr[int32](5),
		// 															},
		// 															Mtu: to.Ptr[int32](1500),
		// 															PeerASN: to.Ptr[int64](61234),
		// 															VlanID: to.Ptr[int32](3000),
		// 														},
		// 														OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
		// 															ExportRouteTargets: []*string{
		// 																to.Ptr("65046:10050")},
		// 																ImportRouteTargets: []*string{
		// 																	to.Ptr("65046:10050")},
		// 																	RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
		// 																		ExportIPv4RouteTargets: []*string{
		// 																			to.Ptr("65046:10050")},
		// 																			ExportIPv6RouteTargets: []*string{
		// 																				to.Ptr("65046:10050")},
		// 																				ImportIPv4RouteTargets: []*string{
		// 																					to.Ptr("65046:10050")},
		// 																					ImportIPv6RouteTargets: []*string{
		// 																						to.Ptr("65046:10050")},
		// 																					},
		// 																				},
		// 																				PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		// 																			},
		// 																		},
		// 																		NetworkFabricControllerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-fabricController"),
		// 																		NetworkFabricSKU: to.Ptr("M4-A400-A100-C16-aa"),
		// 																		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 																		RackCount: to.Ptr[int32](4),
		// 																		Racks: []*string{
		// 																			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-networkRack")},
		// 																			RouterIDs: []*string{
		// 																				to.Ptr("routerId")},
		// 																				ServerCountPerRack: to.Ptr[int32](8),
		// 																				TerminalServerConfiguration: &armmanagednetworkfabric.TerminalServerConfiguration{
		// 																					PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
		// 																					PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
		// 																					SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
		// 																					SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
		// 																					SerialNumber: to.Ptr("123456"),
		// 																					Username: to.Ptr("username"),
		// 																					NetworkDeviceID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice"),
		// 																				},
		// 																			},
		// 																	}},
		// 																}
	}
}

Output:

func (*NetworkFabricsClient) NewListBySubscriptionPager 

func (client *NetworkFabricsClient) NewListBySubscriptionPager(options *NetworkFabricsClientListBySubscriptionOptions) *runtime.Pager[NetworkFabricsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all the Network Fabric resources in the given subscription.

Generated from API version 2023-06-15

  • options - NetworkFabricsClientListBySubscriptionOptions contains the optional parameters for the NetworkFabricsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkFabrics_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkFabricsClient().NewListBySubscriptionPager(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.NetworkFabricsListResult = armmanagednetworkfabric.NetworkFabricsListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkFabric{
		// 		{
		// 			Name: to.Ptr("example-fabric"),
		// 			Type: to.Ptr("Microsoft.ManagedNetworkFabric/networkFabrics"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@email.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("KeyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkFabricProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				FabricASN: to.Ptr[int64](29249),
		// 				FabricVersion: to.Ptr("version1"),
		// 				IPv4Prefix: to.Ptr("10.18.0.0/19"),
		// 				IPv6Prefix: to.Ptr("3FFE:FFFF:0:CD40::/59"),
		// 				L2IsolationDomains: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l2IsolationDomains/example-l2Domain")},
		// 					L3IsolationDomains: []*string{
		// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/example-l3Domain")},
		// 						ManagementNetworkConfiguration: &armmanagednetworkfabric.ManagementNetworkConfigurationProperties{
		// 							InfrastructureVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
		// 								AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 								NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
		// 								OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
		// 									PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
		// 									PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
		// 									SecondaryIPv4Prefix: to.Ptr("20.0.0.13/30"),
		// 									SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
		// 									BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 										AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 										IntervalInMilliSeconds: to.Ptr[int32](300),
		// 										Multiplier: to.Ptr[int32](10),
		// 									},
		// 									Mtu: to.Ptr[int32](1501),
		// 									PeerASN: to.Ptr[int64](1235),
		// 									VlanID: to.Ptr[int32](3001),
		// 								},
		// 								OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
		// 									ExportRouteTargets: []*string{
		// 										to.Ptr("65046:10050")},
		// 										ImportRouteTargets: []*string{
		// 											to.Ptr("65046:10050")},
		// 											RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
		// 												ExportIPv4RouteTargets: []*string{
		// 													to.Ptr("65046:10050")},
		// 													ExportIPv6RouteTargets: []*string{
		// 														to.Ptr("65046:10050")},
		// 														ImportIPv4RouteTargets: []*string{
		// 															to.Ptr("65046:10050")},
		// 															ImportIPv6RouteTargets: []*string{
		// 																to.Ptr("65046:10050")},
		// 															},
		// 														},
		// 														PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		// 													},
		// 													WorkloadVPNConfiguration: &armmanagednetworkfabric.VPNConfigurationProperties{
		// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 														NetworkToNetworkInterconnectID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
		// 														OptionAProperties: &armmanagednetworkfabric.VPNConfigurationPropertiesOptionAProperties{
		// 															PrimaryIPv4Prefix: to.Ptr("10.0.0.14/30"),
		// 															PrimaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::a7/126"),
		// 															SecondaryIPv4Prefix: to.Ptr("10.0.0.15/30"),
		// 															SecondaryIPv6Prefix: to.Ptr("2FFE:FFFF:0:CD30::ac/126"),
		// 															BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 																AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 																IntervalInMilliSeconds: to.Ptr[int32](300),
		// 																Multiplier: to.Ptr[int32](5),
		// 															},
		// 															Mtu: to.Ptr[int32](1500),
		// 															PeerASN: to.Ptr[int64](61234),
		// 															VlanID: to.Ptr[int32](3000),
		// 														},
		// 														OptionBProperties: &armmanagednetworkfabric.OptionBProperties{
		// 															ExportRouteTargets: []*string{
		// 																to.Ptr("65046:10050")},
		// 																ImportRouteTargets: []*string{
		// 																	to.Ptr("65046:10050")},
		// 																	RouteTargets: &armmanagednetworkfabric.RouteTargetInformation{
		// 																		ExportIPv4RouteTargets: []*string{
		// 																			to.Ptr("65046:10050")},
		// 																			ExportIPv6RouteTargets: []*string{
		// 																				to.Ptr("65046:10050")},
		// 																				ImportIPv4RouteTargets: []*string{
		// 																					to.Ptr("65046:10050")},
		// 																					ImportIPv6RouteTargets: []*string{
		// 																						to.Ptr("65046:10050")},
		// 																					},
		// 																				},
		// 																				PeeringOption: to.Ptr(armmanagednetworkfabric.PeeringOptionOptionA),
		// 																			},
		// 																		},
		// 																		NetworkFabricControllerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabricControllers/example-fabricController"),
		// 																		NetworkFabricSKU: to.Ptr("M4-A400-A100-C16-aa"),
		// 																		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 																		RackCount: to.Ptr[int32](4),
		// 																		Racks: []*string{
		// 																			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-networkRack")},
		// 																			RouterIDs: []*string{
		// 																				to.Ptr("routerId")},
		// 																				ServerCountPerRack: to.Ptr[int32](8),
		// 																				TerminalServerConfiguration: &armmanagednetworkfabric.TerminalServerConfiguration{
		// 																					PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
		// 																					PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
		// 																					SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
		// 																					SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
		// 																					SerialNumber: to.Ptr("123456"),
		// 																					Username: to.Ptr("username"),
		// 																					NetworkDeviceID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice"),
		// 																				},
		// 																			},
		// 																	}},
		// 																}
	}
}

Output:

type NetworkFabricsClientBeginCommitConfigurationOptions 

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

NetworkFabricsClientBeginCommitConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginCommitConfiguration method.

type NetworkFabricsClientBeginCreateOptions 

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

NetworkFabricsClientBeginCreateOptions contains the optional parameters for the NetworkFabricsClient.BeginCreate method.

type NetworkFabricsClientBeginDeleteOptions 

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

NetworkFabricsClientBeginDeleteOptions contains the optional parameters for the NetworkFabricsClient.BeginDelete method.

type NetworkFabricsClientBeginDeprovisionOptions 

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

NetworkFabricsClientBeginDeprovisionOptions contains the optional parameters for the NetworkFabricsClient.BeginDeprovision method.

type NetworkFabricsClientBeginGetTopologyOptions 

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

NetworkFabricsClientBeginGetTopologyOptions contains the optional parameters for the NetworkFabricsClient.BeginGetTopology method.

type NetworkFabricsClientBeginProvisionOptions 

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

NetworkFabricsClientBeginProvisionOptions contains the optional parameters for the NetworkFabricsClient.BeginProvision method.

type NetworkFabricsClientBeginRefreshConfigurationOptions 

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

NetworkFabricsClientBeginRefreshConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginRefreshConfiguration method.

type NetworkFabricsClientBeginUpdateInfraManagementBfdConfigurationOptions 

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

NetworkFabricsClientBeginUpdateInfraManagementBfdConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginUpdateInfraManagementBfdConfiguration method.

type NetworkFabricsClientBeginUpdateOptions 

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

NetworkFabricsClientBeginUpdateOptions contains the optional parameters for the NetworkFabricsClient.BeginUpdate method.

type NetworkFabricsClientBeginUpdateWorkloadManagementBfdConfigurationOptions 

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

NetworkFabricsClientBeginUpdateWorkloadManagementBfdConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginUpdateWorkloadManagementBfdConfiguration method.

type NetworkFabricsClientBeginUpgradeOptions 

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

NetworkFabricsClientBeginUpgradeOptions contains the optional parameters for the NetworkFabricsClient.BeginUpgrade method.

type NetworkFabricsClientBeginValidateConfigurationOptions 

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

NetworkFabricsClientBeginValidateConfigurationOptions contains the optional parameters for the NetworkFabricsClient.BeginValidateConfiguration method.

type NetworkFabricsClientCommitConfigurationResponse 

type NetworkFabricsClientCommitConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkFabricsClientCommitConfigurationResponse contains the response from method NetworkFabricsClient.BeginCommitConfiguration.

type NetworkFabricsClientCreateResponse 

type NetworkFabricsClientCreateResponse struct {
	// The Network Fabric resource definition.
	NetworkFabric
}

NetworkFabricsClientCreateResponse contains the response from method NetworkFabricsClient.BeginCreate.

type NetworkFabricsClientDeleteResponse 

type NetworkFabricsClientDeleteResponse struct {
}

NetworkFabricsClientDeleteResponse contains the response from method NetworkFabricsClient.BeginDelete.

type NetworkFabricsClientDeprovisionResponse 

type NetworkFabricsClientDeprovisionResponse struct {
	// Common response for device updates.
	CommonPostActionResponseForDeviceUpdate
}

NetworkFabricsClientDeprovisionResponse contains the response from method NetworkFabricsClient.BeginDeprovision.

type NetworkFabricsClientGetOptions 

type NetworkFabricsClientGetOptions struct {
}

NetworkFabricsClientGetOptions contains the optional parameters for the NetworkFabricsClient.Get method.

type NetworkFabricsClientGetResponse 

type NetworkFabricsClientGetResponse struct {
	// The Network Fabric resource definition.
	NetworkFabric
}

NetworkFabricsClientGetResponse contains the response from method NetworkFabricsClient.Get.

type NetworkFabricsClientGetTopologyResponse 

type NetworkFabricsClientGetTopologyResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

NetworkFabricsClientGetTopologyResponse contains the response from method NetworkFabricsClient.BeginGetTopology.

type NetworkFabricsClientListByResourceGroupOptions 

type NetworkFabricsClientListByResourceGroupOptions struct {
}

NetworkFabricsClientListByResourceGroupOptions contains the optional parameters for the NetworkFabricsClient.NewListByResourceGroupPager method.

type NetworkFabricsClientListByResourceGroupResponse 

type NetworkFabricsClientListByResourceGroupResponse struct {
	// List of Network Fabrics.
	NetworkFabricsListResult
}

NetworkFabricsClientListByResourceGroupResponse contains the response from method NetworkFabricsClient.NewListByResourceGroupPager.

type NetworkFabricsClientListBySubscriptionOptions 

type NetworkFabricsClientListBySubscriptionOptions struct {
}

NetworkFabricsClientListBySubscriptionOptions contains the optional parameters for the NetworkFabricsClient.NewListBySubscriptionPager method.

type NetworkFabricsClientListBySubscriptionResponse 

type NetworkFabricsClientListBySubscriptionResponse struct {
	// List of Network Fabrics.
	NetworkFabricsListResult
}

NetworkFabricsClientListBySubscriptionResponse contains the response from method NetworkFabricsClient.NewListBySubscriptionPager.

type NetworkFabricsClientProvisionResponse 

type NetworkFabricsClientProvisionResponse struct {
	// Common response for device updates.
	CommonPostActionResponseForDeviceUpdate
}

NetworkFabricsClientProvisionResponse contains the response from method NetworkFabricsClient.BeginProvision.

type NetworkFabricsClientRefreshConfigurationResponse 

type NetworkFabricsClientRefreshConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkFabricsClientRefreshConfigurationResponse contains the response from method NetworkFabricsClient.BeginRefreshConfiguration.

type NetworkFabricsClientUpdateInfraManagementBfdConfigurationResponse 

type NetworkFabricsClientUpdateInfraManagementBfdConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkFabricsClientUpdateInfraManagementBfdConfigurationResponse contains the response from method NetworkFabricsClient.BeginUpdateInfraManagementBfdConfiguration.

type NetworkFabricsClientUpdateResponse 

type NetworkFabricsClientUpdateResponse struct {
	// The Network Fabric resource definition.
	NetworkFabric
}

NetworkFabricsClientUpdateResponse contains the response from method NetworkFabricsClient.BeginUpdate.

type NetworkFabricsClientUpdateWorkloadManagementBfdConfigurationResponse 

type NetworkFabricsClientUpdateWorkloadManagementBfdConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkFabricsClientUpdateWorkloadManagementBfdConfigurationResponse contains the response from method NetworkFabricsClient.BeginUpdateWorkloadManagementBfdConfiguration.

type NetworkFabricsClientUpgradeResponse 

type NetworkFabricsClientUpgradeResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkFabricsClientUpgradeResponse contains the response from method NetworkFabricsClient.BeginUpgrade.

type NetworkFabricsClientValidateConfigurationResponse 

type NetworkFabricsClientValidateConfigurationResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

NetworkFabricsClientValidateConfigurationResponse contains the response from method NetworkFabricsClient.BeginValidateConfiguration.

type NetworkFabricsListResult 

type NetworkFabricsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Network Fabric resources.
	Value []*NetworkFabric
}

NetworkFabricsListResult - List of Network Fabrics.

func (NetworkFabricsListResult) MarshalJSON 

func (n NetworkFabricsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkFabricsListResult.

func (*NetworkFabricsListResult) UnmarshalJSON 

func (n *NetworkFabricsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkFabricsListResult.

type NetworkInterface 

type NetworkInterface struct {
	// REQUIRED; Resource properties.
	Properties *NetworkInterfaceProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkInterface - Defines the NetworkInterface resource.

func (NetworkInterface) MarshalJSON 

func (n NetworkInterface) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkInterface.

func (*NetworkInterface) UnmarshalJSON 

func (n *NetworkInterface) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterface.

type NetworkInterfacePatch 

type NetworkInterfacePatch struct {
	// Network Interface Patch properties.
	Properties *NetworkInterfacePatchProperties
}

NetworkInterfacePatch - The NetworkInterfacePatch resource definition.

func (NetworkInterfacePatch) MarshalJSON 

func (n NetworkInterfacePatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkInterfacePatch.

func (*NetworkInterfacePatch) UnmarshalJSON 

func (n *NetworkInterfacePatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterfacePatch.

type NetworkInterfacePatchProperties 

type NetworkInterfacePatchProperties struct {
	// Switch configuration description.
	Annotation *string
}

NetworkInterfacePatchProperties - Network Interface Patch properties.

func (NetworkInterfacePatchProperties) MarshalJSON 

func (n NetworkInterfacePatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkInterfacePatchProperties.

func (*NetworkInterfacePatchProperties) UnmarshalJSON 

func (n *NetworkInterfacePatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterfacePatchProperties.

type NetworkInterfaceProperties 

type NetworkInterfaceProperties struct {
	// Switch configuration description.
	Annotation *string

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; The ARM resource id of the interface or compute server its connected to.
	ConnectedTo *string

	// READ-ONLY; IPv4Address of the interface.
	IPv4Address *string

	// READ-ONLY; IPv6Address of the interface.
	IPv6Address *string

	// READ-ONLY; The Interface Type. Example: Management/Data
	InterfaceType *InterfaceType

	// READ-ONLY; Physical Identifier of the network interface.
	PhysicalIdentifier *string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

NetworkInterfaceProperties - Network Interface Properties defines the properties of the resource.

func (NetworkInterfaceProperties) MarshalJSON 

func (n NetworkInterfaceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkInterfaceProperties.

func (*NetworkInterfaceProperties) UnmarshalJSON 

func (n *NetworkInterfaceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterfaceProperties.

type NetworkInterfacesClient 

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

NetworkInterfacesClient contains the methods for the NetworkInterfaces group. Don't use this type directly, use NewNetworkInterfacesClient() instead.

func NewNetworkInterfacesClient 

func NewNetworkInterfacesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkInterfacesClient, error)

NewNetworkInterfacesClient creates a new instance of NetworkInterfacesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkInterfacesClient) BeginCreate 

func (client *NetworkInterfacesClient) BeginCreate(ctx context.Context, resourceGroupName string, networkDeviceName string, networkInterfaceName string, body NetworkInterface, options *NetworkInterfacesClientBeginCreateOptions) (*runtime.Poller[NetworkInterfacesClientCreateResponse], error)

BeginCreate - Create a Network Interface resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • networkInterfaceName - Name of the Network Interface.
  • body - Request payload.
  • options - NetworkInterfacesClientBeginCreateOptions contains the optional parameters for the NetworkInterfacesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkInterfaces_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkInterfacesClient().BeginCreate(ctx, "example-rg", "example-device", "example-interface", armmanagednetworkfabric.NetworkInterface{
		Properties: &armmanagednetworkfabric.NetworkInterfaceProperties{
			Annotation: to.Ptr("annotation"),
		},
	}, 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.NetworkInterface = armmanagednetworkfabric.NetworkInterface{
	// 	Name: to.Ptr("example-interface"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkdevices/networkinterfaces"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device/networkInterfaces/example-interface"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkInterfaceProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConnectedTo: to.Ptr("external-interface"),
	// 		InterfaceType: to.Ptr(armmanagednetworkfabric.InterfaceTypeManagement),
	// 		IPv4Address: to.Ptr("10.2.2.8"),
	// 		IPv6Address: to.Ptr("10:2:0:0::"),
	// 		PhysicalIdentifier: to.Ptr("Id"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*NetworkInterfacesClient) BeginDelete 

func (client *NetworkInterfacesClient) BeginDelete(ctx context.Context, resourceGroupName string, networkDeviceName string, networkInterfaceName string, options *NetworkInterfacesClientBeginDeleteOptions) (*runtime.Poller[NetworkInterfacesClientDeleteResponse], error)

BeginDelete - Delete the Network Interface resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • networkInterfaceName - Name of the Network Interface.
  • options - NetworkInterfacesClientBeginDeleteOptions contains the optional parameters for the NetworkInterfacesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkInterfaces_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkInterfacesClient().BeginDelete(ctx, "rgNetworkDevices", "sjzd", "emrgu", 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)
	}
}

Output:

func (*NetworkInterfacesClient) BeginUpdate 

func (client *NetworkInterfacesClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkDeviceName string, networkInterfaceName string, body NetworkInterfacePatch, options *NetworkInterfacesClientBeginUpdateOptions) (*runtime.Poller[NetworkInterfacesClientUpdateResponse], error)

BeginUpdate - Update certain properties of the Network Interface resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • networkInterfaceName - Name of the Network Interface.
  • body - NetworkInterface properties to update. Only tags are supported.
  • options - NetworkInterfacesClientBeginUpdateOptions contains the optional parameters for the NetworkInterfacesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkInterfaces_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkInterfacesClient().BeginUpdate(ctx, "example-rg", "example-device", "example-interface", armmanagednetworkfabric.NetworkInterfacePatch{
		Properties: &armmanagednetworkfabric.NetworkInterfacePatchProperties{
			Annotation: to.Ptr("annotation"),
		},
	}, 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.NetworkInterface = armmanagednetworkfabric.NetworkInterface{
	// 	Name: to.Ptr("example-interface"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkdevices/networkinterfaces"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device/networkInterfaces/example-interface"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkInterfaceProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConnectedTo: to.Ptr("external-interface"),
	// 		InterfaceType: to.Ptr(armmanagednetworkfabric.InterfaceTypeManagement),
	// 		IPv4Address: to.Ptr("10.2.2.8"),
	// 		IPv6Address: to.Ptr("10:2:0:0::"),
	// 		PhysicalIdentifier: to.Ptr("Id"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*NetworkInterfacesClient) BeginUpdateAdministrativeState 

func (client *NetworkInterfacesClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, networkDeviceName string, networkInterfaceName string, body UpdateAdministrativeState, options *NetworkInterfacesClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[NetworkInterfacesClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Update the admin state of the Network Interface. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • networkInterfaceName - Name of the Network Interface.
  • body - Request payload.
  • options - NetworkInterfacesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkInterfacesClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkInterfaces_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkInterfacesClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-device", "example-interface", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkInterfacesClient) Get 

func (client *NetworkInterfacesClient) Get(ctx context.Context, resourceGroupName string, networkDeviceName string, networkInterfaceName string, options *NetworkInterfacesClientGetOptions) (NetworkInterfacesClientGetResponse, error)

Get - Get the Network Interface resource details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • networkInterfaceName - Name of the Network Interface.
  • options - NetworkInterfacesClientGetOptions contains the optional parameters for the NetworkInterfacesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkInterfaces_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkInterfacesClient().Get(ctx, "example-rg", "example-device", "example-interface", 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.NetworkInterface = armmanagednetworkfabric.NetworkInterface{
	// 	Name: to.Ptr("example-interface"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkdevices/networkinterfaces"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device/networkInterfaces/example-interface"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkInterfaceProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConnectedTo: to.Ptr("external-interface"),
	// 		InterfaceType: to.Ptr(armmanagednetworkfabric.InterfaceTypeManagement),
	// 		IPv4Address: to.Ptr("10.2.2.8"),
	// 		IPv6Address: to.Ptr("10:2:0:0::"),
	// 		PhysicalIdentifier: to.Ptr("Id"),
	// 		ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*NetworkInterfacesClient) NewListByNetworkDevicePager 

func (client *NetworkInterfacesClient) NewListByNetworkDevicePager(resourceGroupName string, networkDeviceName string, options *NetworkInterfacesClientListByNetworkDeviceOptions) *runtime.Pager[NetworkInterfacesClientListByNetworkDeviceResponse]

NewListByNetworkDevicePager - List all the Network Interface resources in a given resource group.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkDeviceName - Name of the Network Device.
  • options - NetworkInterfacesClientListByNetworkDeviceOptions contains the optional parameters for the NetworkInterfacesClient.NewListByNetworkDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkInterfaces_ListByNetworkDevice_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkInterfacesClient().NewListByNetworkDevicePager("example-rg", "example-device", 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.NetworkInterfacesList = armmanagednetworkfabric.NetworkInterfacesList{
		// 	Value: []*armmanagednetworkfabric.NetworkInterface{
		// 		{
		// 			Name: to.Ptr("example-interface"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkdevices/networkinterfaces"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-device/networkInterfaces/example-interface"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T16:02:19.538Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkInterfaceProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConnectedTo: to.Ptr("external-interface"),
		// 				InterfaceType: to.Ptr(armmanagednetworkfabric.InterfaceTypeManagement),
		// 				IPv4Address: to.Ptr("10.2.2.8"),
		// 				IPv6Address: to.Ptr("10:2:0:0::"),
		// 				PhysicalIdentifier: to.Ptr("Id"),
		// 				ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

type NetworkInterfacesClientBeginCreateOptions 

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

NetworkInterfacesClientBeginCreateOptions contains the optional parameters for the NetworkInterfacesClient.BeginCreate method.

type NetworkInterfacesClientBeginDeleteOptions 

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

NetworkInterfacesClientBeginDeleteOptions contains the optional parameters for the NetworkInterfacesClient.BeginDelete method.

type NetworkInterfacesClientBeginUpdateAdministrativeStateOptions 

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

NetworkInterfacesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkInterfacesClient.BeginUpdateAdministrativeState method.

type NetworkInterfacesClientBeginUpdateOptions 

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

NetworkInterfacesClientBeginUpdateOptions contains the optional parameters for the NetworkInterfacesClient.BeginUpdate method.

type NetworkInterfacesClientCreateResponse 

type NetworkInterfacesClientCreateResponse struct {
	// Defines the NetworkInterface resource.
	NetworkInterface
}

NetworkInterfacesClientCreateResponse contains the response from method NetworkInterfacesClient.BeginCreate.

type NetworkInterfacesClientDeleteResponse 

type NetworkInterfacesClientDeleteResponse struct {
}

NetworkInterfacesClientDeleteResponse contains the response from method NetworkInterfacesClient.BeginDelete.

type NetworkInterfacesClientGetOptions 

type NetworkInterfacesClientGetOptions struct {
}

NetworkInterfacesClientGetOptions contains the optional parameters for the NetworkInterfacesClient.Get method.

type NetworkInterfacesClientGetResponse 

type NetworkInterfacesClientGetResponse struct {
	// Defines the NetworkInterface resource.
	NetworkInterface
}

NetworkInterfacesClientGetResponse contains the response from method NetworkInterfacesClient.Get.

type NetworkInterfacesClientListByNetworkDeviceOptions 

type NetworkInterfacesClientListByNetworkDeviceOptions struct {
}

NetworkInterfacesClientListByNetworkDeviceOptions contains the optional parameters for the NetworkInterfacesClient.NewListByNetworkDevicePager method.

type NetworkInterfacesClientListByNetworkDeviceResponse 

type NetworkInterfacesClientListByNetworkDeviceResponse struct {
	// List of NetworkInterfaces.
	NetworkInterfacesList
}

NetworkInterfacesClientListByNetworkDeviceResponse contains the response from method NetworkInterfacesClient.NewListByNetworkDevicePager.

type NetworkInterfacesClientUpdateAdministrativeStateResponse 

type NetworkInterfacesClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkInterfacesClientUpdateAdministrativeStateResponse contains the response from method NetworkInterfacesClient.BeginUpdateAdministrativeState.

type NetworkInterfacesClientUpdateResponse 

type NetworkInterfacesClientUpdateResponse struct {
	// Defines the NetworkInterface resource.
	NetworkInterface
}

NetworkInterfacesClientUpdateResponse contains the response from method NetworkInterfacesClient.BeginUpdate.

type NetworkInterfacesList 

type NetworkInterfacesList struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of NetworkInterfaces resources.
	Value []*NetworkInterface
}

NetworkInterfacesList - List of NetworkInterfaces.

func (NetworkInterfacesList) MarshalJSON 

func (n NetworkInterfacesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkInterfacesList.

func (*NetworkInterfacesList) UnmarshalJSON 

func (n *NetworkInterfacesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterfacesList.

type NetworkPacketBroker 

type NetworkPacketBroker struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkPacketBrokerProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkPacketBroker - The NetworkPacketBroker resource definition.

func (NetworkPacketBroker) MarshalJSON 

func (n NetworkPacketBroker) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkPacketBroker.

func (*NetworkPacketBroker) UnmarshalJSON 

func (n *NetworkPacketBroker) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkPacketBroker.

type NetworkPacketBrokerPatch 

type NetworkPacketBrokerPatch struct {
	// Resource tags
	Tags map[string]*string
}

NetworkPacketBrokerPatch - The NetworkPacketBroker patch resource definition.

func (NetworkPacketBrokerPatch) MarshalJSON 

func (n NetworkPacketBrokerPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkPacketBrokerPatch.

func (*NetworkPacketBrokerPatch) UnmarshalJSON 

func (n *NetworkPacketBrokerPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkPacketBrokerPatch.

type NetworkPacketBrokerProperties 

type NetworkPacketBrokerProperties struct {
	// REQUIRED; ARM resource ID of the Network Fabric.
	NetworkFabricID *string

	// READ-ONLY; List of neighbor group IDs configured on NPB.
	NeighborGroupIDs []*string

	// READ-ONLY; List of ARM resource IDs of Network Devices [NPB].
	NetworkDeviceIDs []*string

	// READ-ONLY; List of network Tap IDs configured on NPB.
	NetworkTapIDs []*string

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

	// READ-ONLY; List of network interfaces across NPB devices that are used to mirror source traffic.
	SourceInterfaceIDs []*string
}

NetworkPacketBrokerProperties - Network Packet Broker Properties defines the properties of the resource.

func (NetworkPacketBrokerProperties) MarshalJSON 

func (n NetworkPacketBrokerProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkPacketBrokerProperties.

func (*NetworkPacketBrokerProperties) UnmarshalJSON 

func (n *NetworkPacketBrokerProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkPacketBrokerProperties.

type NetworkPacketBrokersClient 

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

NetworkPacketBrokersClient contains the methods for the NetworkPacketBrokers group. Don't use this type directly, use NewNetworkPacketBrokersClient() instead.

func NewNetworkPacketBrokersClient 

func NewNetworkPacketBrokersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkPacketBrokersClient, error)

NewNetworkPacketBrokersClient creates a new instance of NetworkPacketBrokersClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkPacketBrokersClient) BeginCreate 

func (client *NetworkPacketBrokersClient) BeginCreate(ctx context.Context, resourceGroupName string, networkPacketBrokerName string, body NetworkPacketBroker, options *NetworkPacketBrokersClientBeginCreateOptions) (*runtime.Poller[NetworkPacketBrokersClientCreateResponse], error)

BeginCreate - Creates a Network Packet Broker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkPacketBrokerName - Name of the Network Packet Broker.
  • body - Request payload.
  • options - NetworkPacketBrokersClientBeginCreateOptions contains the optional parameters for the NetworkPacketBrokersClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkPacketBrokers_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkPacketBrokersClient().BeginCreate(ctx, "example-rg", "example-networkPacketBroker", armmanagednetworkfabric.NetworkPacketBroker{
		Location: to.Ptr("eastuseuap"),
		Tags: map[string]*string{
			"key2806": to.Ptr("key"),
		},
		Properties: &armmanagednetworkfabric.NetworkPacketBrokerProperties{
			NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
		},
	}, 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.NetworkPacketBroker = armmanagednetworkfabric.NetworkPacketBroker{
	// 	Name: to.Ptr("example-networkPacketBroker"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkPacketBrokers"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"key2806": to.Ptr("key"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkPacketBrokerProperties{
	// 		NeighborGroupIDs: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
	// 			NetworkDeviceIDs: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
	// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
	// 				NetworkTapIDs: []*string{
	// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
	// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					SourceInterfaceIDs: []*string{
	// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
	// 					},
	// 				}
}

Output:

func (*NetworkPacketBrokersClient) BeginDelete 

func (client *NetworkPacketBrokersClient) BeginDelete(ctx context.Context, resourceGroupName string, networkPacketBrokerName string, options *NetworkPacketBrokersClientBeginDeleteOptions) (*runtime.Poller[NetworkPacketBrokersClientDeleteResponse], error)

BeginDelete - Deletes Network Packet Broker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkPacketBrokerName - Name of the Network Packet Broker.
  • options - NetworkPacketBrokersClientBeginDeleteOptions contains the optional parameters for the NetworkPacketBrokersClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkPacketBrokers_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkPacketBrokersClient().BeginDelete(ctx, "example-rg", "example-networkPacketBroker", 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)
	}
}

Output:

func (*NetworkPacketBrokersClient) BeginUpdate 

func (client *NetworkPacketBrokersClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkPacketBrokerName string, body NetworkPacketBrokerPatch, options *NetworkPacketBrokersClientBeginUpdateOptions) (*runtime.Poller[NetworkPacketBrokersClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the Network Packet Broker resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkPacketBrokerName - Name of the Network Packet Broker.
  • body - Network Packet Broker properties to update.
  • options - NetworkPacketBrokersClientBeginUpdateOptions contains the optional parameters for the NetworkPacketBrokersClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkPacketBrokers_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkPacketBrokersClient().BeginUpdate(ctx, "example-rg", "example-networkPacketBroker", armmanagednetworkfabric.NetworkPacketBrokerPatch{
		Tags: map[string]*string{
			"key8772": to.Ptr("1234"),
		},
	}, 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.NetworkPacketBroker = armmanagednetworkfabric.NetworkPacketBroker{
	// 	Name: to.Ptr("example-networkPacketBroker"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkPacketBrokers"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"key8772": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkPacketBrokerProperties{
	// 		NeighborGroupIDs: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
	// 			NetworkDeviceIDs: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
	// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
	// 				NetworkTapIDs: []*string{
	// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
	// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					SourceInterfaceIDs: []*string{
	// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
	// 					},
	// 				}
}

Output:

func (*NetworkPacketBrokersClient) Get 

func (client *NetworkPacketBrokersClient) Get(ctx context.Context, resourceGroupName string, networkPacketBrokerName string, options *NetworkPacketBrokersClientGetOptions) (NetworkPacketBrokersClientGetResponse, error)

Get - Retrieves details of this Network Packet Broker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkPacketBrokerName - Name of the Network Packet Broker.
  • options - NetworkPacketBrokersClientGetOptions contains the optional parameters for the NetworkPacketBrokersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkPacketBrokers_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkPacketBrokersClient().Get(ctx, "example-rg", "example-networkPacketBroker", 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.NetworkPacketBroker = armmanagednetworkfabric.NetworkPacketBroker{
	// 	Name: to.Ptr("example-networkPacketBroker"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkPacketBrokers"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"key2806": to.Ptr("key"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkPacketBrokerProperties{
	// 		NeighborGroupIDs: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
	// 			NetworkDeviceIDs: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
	// 				NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
	// 				NetworkTapIDs: []*string{
	// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
	// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					SourceInterfaceIDs: []*string{
	// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
	// 					},
	// 				}
}

Output:

func (*NetworkPacketBrokersClient) NewListByResourceGroupPager 

func (client *NetworkPacketBrokersClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkPacketBrokersClientListByResourceGroupOptions) *runtime.Pager[NetworkPacketBrokersClientListByResourceGroupResponse]

NewListByResourceGroupPager - Displays NetworkPacketBrokers list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkPacketBrokersClientListByResourceGroupOptions contains the optional parameters for the NetworkPacketBrokersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkPacketBrokers_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkPacketBrokersClient().NewListByResourceGroupPager("example-rg", 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.NetworkPacketBrokersListResult = armmanagednetworkfabric.NetworkPacketBrokersListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkPacketBroker{
		// 		{
		// 			Name: to.Ptr("example-networkPacketBroker"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkPacketBrokers"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"key2806": to.Ptr("key"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkPacketBrokerProperties{
		// 				NeighborGroupIDs: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
		// 					NetworkDeviceIDs: []*string{
		// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
		// 						NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
		// 						NetworkTapIDs: []*string{
		// 							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
		// 							ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 							SourceInterfaceIDs: []*string{
		// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
		// 							},
		// 					}},
		// 				}
	}
}

Output:

func (*NetworkPacketBrokersClient) NewListBySubscriptionPager 

func (client *NetworkPacketBrokersClient) NewListBySubscriptionPager(options *NetworkPacketBrokersClientListBySubscriptionOptions) *runtime.Pager[NetworkPacketBrokersClientListBySubscriptionResponse]

NewListBySubscriptionPager - Displays Network Packet Brokers list by subscription GET method.

Generated from API version 2023-06-15

  • options - NetworkPacketBrokersClientListBySubscriptionOptions contains the optional parameters for the NetworkPacketBrokersClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkPacketBrokers_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkPacketBrokersClient().NewListBySubscriptionPager(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.NetworkPacketBrokersListResult = armmanagednetworkfabric.NetworkPacketBrokersListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkPacketBroker{
		// 		{
		// 			Name: to.Ptr("example-networkPacketBroker"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkPacketBrokers"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-17T11:56:12.100Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"key2806": to.Ptr("key"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkPacketBrokerProperties{
		// 				NeighborGroupIDs: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
		// 					NetworkDeviceIDs: []*string{
		// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
		// 						NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
		// 						NetworkTapIDs: []*string{
		// 							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap")},
		// 							ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 							SourceInterfaceIDs: []*string{
		// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
		// 							},
		// 					}},
		// 				}
	}
}

Output:

type NetworkPacketBrokersClientBeginCreateOptions 

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

NetworkPacketBrokersClientBeginCreateOptions contains the optional parameters for the NetworkPacketBrokersClient.BeginCreate method.

type NetworkPacketBrokersClientBeginDeleteOptions 

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

NetworkPacketBrokersClientBeginDeleteOptions contains the optional parameters for the NetworkPacketBrokersClient.BeginDelete method.

type NetworkPacketBrokersClientBeginUpdateOptions 

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

NetworkPacketBrokersClientBeginUpdateOptions contains the optional parameters for the NetworkPacketBrokersClient.BeginUpdate method.

type NetworkPacketBrokersClientCreateResponse 

type NetworkPacketBrokersClientCreateResponse struct {
	// The NetworkPacketBroker resource definition.
	NetworkPacketBroker
}

NetworkPacketBrokersClientCreateResponse contains the response from method NetworkPacketBrokersClient.BeginCreate.

type NetworkPacketBrokersClientDeleteResponse 

type NetworkPacketBrokersClientDeleteResponse struct {
}

NetworkPacketBrokersClientDeleteResponse contains the response from method NetworkPacketBrokersClient.BeginDelete.

type NetworkPacketBrokersClientGetOptions 

type NetworkPacketBrokersClientGetOptions struct {
}

NetworkPacketBrokersClientGetOptions contains the optional parameters for the NetworkPacketBrokersClient.Get method.

type NetworkPacketBrokersClientGetResponse 

type NetworkPacketBrokersClientGetResponse struct {
	// The NetworkPacketBroker resource definition.
	NetworkPacketBroker
}

NetworkPacketBrokersClientGetResponse contains the response from method NetworkPacketBrokersClient.Get.

type NetworkPacketBrokersClientListByResourceGroupOptions 

type NetworkPacketBrokersClientListByResourceGroupOptions struct {
}

NetworkPacketBrokersClientListByResourceGroupOptions contains the optional parameters for the NetworkPacketBrokersClient.NewListByResourceGroupPager method.

type NetworkPacketBrokersClientListByResourceGroupResponse 

type NetworkPacketBrokersClientListByResourceGroupResponse struct {
	// List of NetworkPacketBrokers.
	NetworkPacketBrokersListResult
}

NetworkPacketBrokersClientListByResourceGroupResponse contains the response from method NetworkPacketBrokersClient.NewListByResourceGroupPager.

type NetworkPacketBrokersClientListBySubscriptionOptions 

type NetworkPacketBrokersClientListBySubscriptionOptions struct {
}

NetworkPacketBrokersClientListBySubscriptionOptions contains the optional parameters for the NetworkPacketBrokersClient.NewListBySubscriptionPager method.

type NetworkPacketBrokersClientListBySubscriptionResponse 

type NetworkPacketBrokersClientListBySubscriptionResponse struct {
	// List of NetworkPacketBrokers.
	NetworkPacketBrokersListResult
}

NetworkPacketBrokersClientListBySubscriptionResponse contains the response from method NetworkPacketBrokersClient.NewListBySubscriptionPager.

type NetworkPacketBrokersClientUpdateResponse 

type NetworkPacketBrokersClientUpdateResponse struct {
	// The NetworkPacketBroker resource definition.
	NetworkPacketBroker
}

NetworkPacketBrokersClientUpdateResponse contains the response from method NetworkPacketBrokersClient.BeginUpdate.

type NetworkPacketBrokersListResult 

type NetworkPacketBrokersListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of NetworkPacketBroker resources.
	Value []*NetworkPacketBroker
}

NetworkPacketBrokersListResult - List of NetworkPacketBrokers.

func (NetworkPacketBrokersListResult) MarshalJSON 

func (n NetworkPacketBrokersListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkPacketBrokersListResult.

func (*NetworkPacketBrokersListResult) UnmarshalJSON 

func (n *NetworkPacketBrokersListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkPacketBrokersListResult.

type NetworkRack 

type NetworkRack struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkRackProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkRack - The Network Rack resource definition.

func (NetworkRack) MarshalJSON 

func (n NetworkRack) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkRack.

func (*NetworkRack) UnmarshalJSON 

func (n *NetworkRack) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkRack.

type NetworkRackProperties 

type NetworkRackProperties struct {
	// REQUIRED; ARM resource ID of the Network Fabric.
	NetworkFabricID *string

	// Switch configuration description.
	Annotation *string

	// Network Rack SKU name.
	NetworkRackType *NetworkRackType

	// READ-ONLY; List of network device ARM resource IDs.
	NetworkDevices []*string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

NetworkRackProperties - Network Rack Properties defines the properties of the resource.

func (NetworkRackProperties) MarshalJSON 

func (n NetworkRackProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkRackProperties.

func (*NetworkRackProperties) UnmarshalJSON 

func (n *NetworkRackProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkRackProperties.

type NetworkRackType 

type NetworkRackType string

NetworkRackType - Network Rack SKU name. 

const (
	NetworkRackTypeAggregate NetworkRackType = "Aggregate"
	NetworkRackTypeCombined  NetworkRackType = "Combined"
	NetworkRackTypeCompute   NetworkRackType = "Compute"
)

func PossibleNetworkRackTypeValues 

func PossibleNetworkRackTypeValues() []NetworkRackType

PossibleNetworkRackTypeValues returns the possible values for the NetworkRackType const type.

type NetworkRacksClient 

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

NetworkRacksClient contains the methods for the NetworkRacks group. Don't use this type directly, use NewNetworkRacksClient() instead.

func NewNetworkRacksClient 

func NewNetworkRacksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkRacksClient, error)

NewNetworkRacksClient creates a new instance of NetworkRacksClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkRacksClient) BeginCreate 

func (client *NetworkRacksClient) BeginCreate(ctx context.Context, resourceGroupName string, networkRackName string, body NetworkRack, options *NetworkRacksClientBeginCreateOptions) (*runtime.Poller[NetworkRacksClientCreateResponse], error)

BeginCreate - Create Network Rack resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkRackName - Name of the Network Rack.
  • body - Request payload.
  • options - NetworkRacksClientBeginCreateOptions contains the optional parameters for the NetworkRacksClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkRacks_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkRacksClient().BeginCreate(ctx, "example-rg", "example-rack", armmanagednetworkfabric.NetworkRack{
		Location: to.Ptr("eastuseuap"),
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkRackProperties{
			Annotation:      to.Ptr("annotation"),
			NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
			NetworkRackType: to.Ptr(armmanagednetworkfabric.NetworkRackTypeAggregate),
		},
	}, 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.NetworkRack = armmanagednetworkfabric.NetworkRack{
	// 	Name: to.Ptr("example-rack"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkRacks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@email.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkRackProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		NetworkDevices: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
	// 			NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
	// 			NetworkRackType: to.Ptr(armmanagednetworkfabric.NetworkRackTypeAggregate),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		},
	// 	}
}

Output:

func (*NetworkRacksClient) BeginDelete 

func (client *NetworkRacksClient) BeginDelete(ctx context.Context, resourceGroupName string, networkRackName string, options *NetworkRacksClientBeginDeleteOptions) (*runtime.Poller[NetworkRacksClientDeleteResponse], error)

BeginDelete - Delete Network Rack resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkRackName - Name of the Network Rack.
  • options - NetworkRacksClientBeginDeleteOptions contains the optional parameters for the NetworkRacksClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkRacks_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkRacksClient().BeginDelete(ctx, "example-rg", "example-rack", 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)
	}
}

Output:

func (*NetworkRacksClient) BeginUpdate 

func (client *NetworkRacksClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkRackName string, body TagsUpdate, options *NetworkRacksClientBeginUpdateOptions) (*runtime.Poller[NetworkRacksClientUpdateResponse], error)

BeginUpdate - Update certain properties of the Network Rack resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkRackName - Name of the Network Rack.
  • body - Network Rack properties to update.
  • options - NetworkRacksClientBeginUpdateOptions contains the optional parameters for the NetworkRacksClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkRacks_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkRacksClient().BeginUpdate(ctx, "example-rg", "example-rack", armmanagednetworkfabric.TagsUpdate{
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
	}, 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.NetworkRack = armmanagednetworkfabric.NetworkRack{
	// 	Name: to.Ptr("example-rack"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkRacks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@email.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkRackProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		NetworkDevices: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
	// 			NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
	// 			NetworkRackType: to.Ptr(armmanagednetworkfabric.NetworkRackTypeAggregate),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		},
	// 	}
}

Output:

func (*NetworkRacksClient) Get 

func (client *NetworkRacksClient) Get(ctx context.Context, resourceGroupName string, networkRackName string, options *NetworkRacksClientGetOptions) (NetworkRacksClientGetResponse, error)

Get - Get Network Rack resource details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkRackName - Name of the Network Rack.
  • options - NetworkRacksClientGetOptions contains the optional parameters for the NetworkRacksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkRacks_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkRacksClient().Get(ctx, "example-rg", "example-rack", 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.NetworkRack = armmanagednetworkfabric.NetworkRack{
	// 	Name: to.Ptr("example-rack"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkRacks"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@email.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkRackProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		NetworkDevices: []*string{
	// 			to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
	// 			NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
	// 			NetworkRackType: to.Ptr(armmanagednetworkfabric.NetworkRackTypeAggregate),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 		},
	// 	}
}

Output:

func (*NetworkRacksClient) NewListByResourceGroupPager 

func (client *NetworkRacksClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkRacksClientListByResourceGroupOptions) *runtime.Pager[NetworkRacksClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all Network Rack resources in the given resource group.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkRacksClientListByResourceGroupOptions contains the optional parameters for the NetworkRacksClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkRacks_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkRacksClient().NewListByResourceGroupPager("example-rg", 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.NetworkRacksListResult = armmanagednetworkfabric.NetworkRacksListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkRack{
		// 		{
		// 			Name: to.Ptr("example-rack"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkRacks"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@email.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkRackProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				NetworkDevices: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
		// 					NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
		// 					NetworkRackType: to.Ptr(armmanagednetworkfabric.NetworkRackTypeAggregate),
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

func (*NetworkRacksClient) NewListBySubscriptionPager 

func (client *NetworkRacksClient) NewListBySubscriptionPager(options *NetworkRacksClientListBySubscriptionOptions) *runtime.Pager[NetworkRacksClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all Network Rack resources in the given subscription

Generated from API version 2023-06-15

  • options - NetworkRacksClientListBySubscriptionOptions contains the optional parameters for the NetworkRacksClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkRacks_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkRacksClient().NewListBySubscriptionPager(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.NetworkRacksListResult = armmanagednetworkfabric.NetworkRacksListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkRack{
		// 		{
		// 			Name: to.Ptr("example-rack"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkRacks"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkRacks/example-rack"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T06:00:50.441Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@email.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkRackProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				NetworkDevices: []*string{
		// 					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice")},
		// 					NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-networkFabric"),
		// 					NetworkRackType: to.Ptr(armmanagednetworkfabric.NetworkRackTypeAggregate),
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type NetworkRacksClientBeginCreateOptions 

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

NetworkRacksClientBeginCreateOptions contains the optional parameters for the NetworkRacksClient.BeginCreate method.

type NetworkRacksClientBeginDeleteOptions 

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

NetworkRacksClientBeginDeleteOptions contains the optional parameters for the NetworkRacksClient.BeginDelete method.

type NetworkRacksClientBeginUpdateOptions 

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

NetworkRacksClientBeginUpdateOptions contains the optional parameters for the NetworkRacksClient.BeginUpdate method.

type NetworkRacksClientCreateResponse 

type NetworkRacksClientCreateResponse struct {
	// The Network Rack resource definition.
	NetworkRack
}

NetworkRacksClientCreateResponse contains the response from method NetworkRacksClient.BeginCreate.

type NetworkRacksClientDeleteResponse 

type NetworkRacksClientDeleteResponse struct {
}

NetworkRacksClientDeleteResponse contains the response from method NetworkRacksClient.BeginDelete.

type NetworkRacksClientGetOptions 

type NetworkRacksClientGetOptions struct {
}

NetworkRacksClientGetOptions contains the optional parameters for the NetworkRacksClient.Get method.

type NetworkRacksClientGetResponse 

type NetworkRacksClientGetResponse struct {
	// The Network Rack resource definition.
	NetworkRack
}

NetworkRacksClientGetResponse contains the response from method NetworkRacksClient.Get.

type NetworkRacksClientListByResourceGroupOptions 

type NetworkRacksClientListByResourceGroupOptions struct {
}

NetworkRacksClientListByResourceGroupOptions contains the optional parameters for the NetworkRacksClient.NewListByResourceGroupPager method.

type NetworkRacksClientListByResourceGroupResponse 

type NetworkRacksClientListByResourceGroupResponse struct {
	// List of Network Racks.
	NetworkRacksListResult
}

NetworkRacksClientListByResourceGroupResponse contains the response from method NetworkRacksClient.NewListByResourceGroupPager.

type NetworkRacksClientListBySubscriptionOptions 

type NetworkRacksClientListBySubscriptionOptions struct {
}

NetworkRacksClientListBySubscriptionOptions contains the optional parameters for the NetworkRacksClient.NewListBySubscriptionPager method.

type NetworkRacksClientListBySubscriptionResponse 

type NetworkRacksClientListBySubscriptionResponse struct {
	// List of Network Racks.
	NetworkRacksListResult
}

NetworkRacksClientListBySubscriptionResponse contains the response from method NetworkRacksClient.NewListBySubscriptionPager.

type NetworkRacksClientUpdateResponse 

type NetworkRacksClientUpdateResponse struct {
	// The Network Rack resource definition.
	NetworkRack
}

NetworkRacksClientUpdateResponse contains the response from method NetworkRacksClient.BeginUpdate.

type NetworkRacksListResult 

type NetworkRacksListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of Network Rack resources.
	Value []*NetworkRack
}

NetworkRacksListResult - List of Network Racks.

func (NetworkRacksListResult) MarshalJSON 

func (n NetworkRacksListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkRacksListResult.

func (*NetworkRacksListResult) UnmarshalJSON 

func (n *NetworkRacksListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkRacksListResult.

type NetworkTap 

type NetworkTap struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkTapProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkTap - The Network Tap resource definition.

func (NetworkTap) MarshalJSON 

func (n NetworkTap) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTap.

func (*NetworkTap) UnmarshalJSON 

func (n *NetworkTap) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTap.

type NetworkTapPatch 

type NetworkTapPatch struct {
	// Resource properties.
	Properties *NetworkTapPatchableParameters

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

NetworkTapPatch - The NetworkFabric resource definition.

func (NetworkTapPatch) MarshalJSON 

func (n NetworkTapPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapPatch.

func (*NetworkTapPatch) UnmarshalJSON 

func (n *NetworkTapPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapPatch.

type NetworkTapPatchableParameters 

type NetworkTapPatchableParameters struct {
	// Switch configuration description.
	Annotation *string

	// List of destination properties to send the filter traffic.
	Destinations []*NetworkTapPatchableParametersDestinationsItem

	// Polling type.
	PollingType *PollingType
}

NetworkTapPatchableParameters - The Network Tap resource patch definition.

func (NetworkTapPatchableParameters) MarshalJSON 

func (n NetworkTapPatchableParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapPatchableParameters.

func (*NetworkTapPatchableParameters) UnmarshalJSON 

func (n *NetworkTapPatchableParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapPatchableParameters.

type NetworkTapPatchableParametersDestinationsItem 

type NetworkTapPatchableParametersDestinationsItem struct {
	// The destination Id. ARM Resource ID of either NNI or Internal Networks.
	DestinationID *string

	// ARM Resource ID of destination Tap Rule that contains match configurations.
	DestinationTapRuleID *string

	// Type of destination. Input can be IsolationDomain or Direct.
	DestinationType *DestinationType

	// Isolation Domain Properties.
	IsolationDomainProperties *IsolationDomainProperties

	// Destination name.
	Name *string
}

NetworkTapPatchableParametersDestinationsItem - Destination.

func (NetworkTapPatchableParametersDestinationsItem) MarshalJSON 

func (n NetworkTapPatchableParametersDestinationsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapPatchableParametersDestinationsItem.

func (*NetworkTapPatchableParametersDestinationsItem) UnmarshalJSON 

func (n *NetworkTapPatchableParametersDestinationsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapPatchableParametersDestinationsItem.

type NetworkTapProperties 

type NetworkTapProperties struct {
	// REQUIRED; List of destinations to send the filter traffic.
	Destinations []*NetworkTapPropertiesDestinationsItem

	// REQUIRED; ARM resource ID of the Network Packet Broker.
	NetworkPacketBrokerID *string

	// Switch configuration description.
	Annotation *string

	// Polling type.
	PollingType *PollingType

	// READ-ONLY; Administrative state of the resource. Example -Enabled/Disabled
	AdministrativeState *AdministrativeState

	// READ-ONLY; Gets the configurations state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provides you the latest status of the NFC service, whether it is Accepted, updating, Succeeded or Failed. During
	// this process, the states keep changing based on the status of Network Tap provisioning.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Source Tap Rule Id. ARM Resource ID of the Network Tap Rule.
	SourceTapRuleID *string
}

NetworkTapProperties - Network Tap Properties defines the properties of the resource.

func (NetworkTapProperties) MarshalJSON 

func (n NetworkTapProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapProperties.

func (*NetworkTapProperties) UnmarshalJSON 

func (n *NetworkTapProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapProperties.

type NetworkTapPropertiesDestinationsItem 

type NetworkTapPropertiesDestinationsItem struct {
	// The destination Id. ARM Resource ID of either NNI or Internal Networks.
	DestinationID *string

	// ARM Resource ID of destination Tap Rule that contains match configurations.
	DestinationTapRuleID *string

	// Type of destination. Input can be IsolationDomain or Direct.
	DestinationType *DestinationType

	// Isolation Domain Properties.
	IsolationDomainProperties *IsolationDomainProperties

	// Destination name.
	Name *string
}

NetworkTapPropertiesDestinationsItem - Destination.

func (NetworkTapPropertiesDestinationsItem) MarshalJSON 

func (n NetworkTapPropertiesDestinationsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapPropertiesDestinationsItem.

func (*NetworkTapPropertiesDestinationsItem) UnmarshalJSON 

func (n *NetworkTapPropertiesDestinationsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapPropertiesDestinationsItem.

type NetworkTapRule 

type NetworkTapRule struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *NetworkTapRuleProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkTapRule - The NetworkTapRule resource definition.

func (NetworkTapRule) MarshalJSON 

func (n NetworkTapRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRule.

func (*NetworkTapRule) UnmarshalJSON 

func (n *NetworkTapRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRule.

type NetworkTapRuleAction 

type NetworkTapRuleAction struct {
	// Destination Id. The ARM resource Id may be either Network To Network Interconnect or NeighborGroup.
	DestinationID *string

	// The parameter to enable or disable the timestamp.
	IsTimestampEnabled *BooleanEnumProperty

	// The name of the match configuration. This is used when Goto type is provided. If Goto type is selected and no match configuration
	// name is provided. It goes to next configuration.
	MatchConfigurationName *string

	// Truncate. 0 indicates do not truncate.
	Truncate *string

	// Type of actions that can be performed.
	Type *TapRuleActionType
}

NetworkTapRuleAction - Action that need to performed.

func (NetworkTapRuleAction) MarshalJSON 

func (n NetworkTapRuleAction) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRuleAction.

func (*NetworkTapRuleAction) UnmarshalJSON 

func (n *NetworkTapRuleAction) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRuleAction.

type NetworkTapRuleMatchCondition 

type NetworkTapRuleMatchCondition struct {
	// Encapsulation Type.
	EncapsulationType *EncapsulationType

	// IP condition that needs to be matched.
	IPCondition *IPMatchCondition

	// Defines the port condition that needs to be matched.
	PortCondition *PortCondition

	// List of the protocols that need to be matched.
	ProtocolTypes []*string

	// Vlan match condition that needs to be matched.
	VlanMatchCondition *VlanMatchCondition
}

NetworkTapRuleMatchCondition - Defines the match condition that is supported to filter the traffic.

func (NetworkTapRuleMatchCondition) MarshalJSON 

func (n NetworkTapRuleMatchCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRuleMatchCondition.

func (*NetworkTapRuleMatchCondition) UnmarshalJSON 

func (n *NetworkTapRuleMatchCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRuleMatchCondition.

type NetworkTapRuleMatchConfiguration 

type NetworkTapRuleMatchConfiguration struct {
	// List of actions that need to be performed for the matched conditions.
	Actions []*NetworkTapRuleAction

	// Type of IP Address. IPv4 or IPv6
	IPAddressType *IPAddressType

	// List of the match conditions.
	MatchConditions []*NetworkTapRuleMatchCondition

	// The name of the match configuration.
	MatchConfigurationName *string

	// Sequence Number of the match configuration..
	SequenceNumber *int64
}

NetworkTapRuleMatchConfiguration - Defines the match configuration that are supported to filter the traffic.

func (NetworkTapRuleMatchConfiguration) MarshalJSON 

func (n NetworkTapRuleMatchConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRuleMatchConfiguration.

func (*NetworkTapRuleMatchConfiguration) UnmarshalJSON 

func (n *NetworkTapRuleMatchConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRuleMatchConfiguration.

type NetworkTapRulePatch 

type NetworkTapRulePatch struct {
	// Network Tap Rule Patch properties.
	Properties *NetworkTapRulePatchProperties

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

NetworkTapRulePatch - The NetworkTapRule resource definition.

func (NetworkTapRulePatch) MarshalJSON 

func (n NetworkTapRulePatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRulePatch.

func (*NetworkTapRulePatch) UnmarshalJSON 

func (n *NetworkTapRulePatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRulePatch.

type NetworkTapRulePatchProperties 

type NetworkTapRulePatchProperties struct {
	// Switch configuration description.
	Annotation *string

	// Input method to configure Network Tap Rule.
	ConfigurationType *ConfigurationType

	// List of dynamic match configurations.
	DynamicMatchConfigurations []*CommonDynamicMatchConfiguration

	// List of match configurations.
	MatchConfigurations []*NetworkTapRuleMatchConfiguration

	// Network Tap Rules file URL.
	TapRulesURL *string
}

NetworkTapRulePatchProperties - Network Tap Rule Patch properties.

func (NetworkTapRulePatchProperties) MarshalJSON 

func (n NetworkTapRulePatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRulePatchProperties.

func (*NetworkTapRulePatchProperties) UnmarshalJSON 

func (n *NetworkTapRulePatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRulePatchProperties.

type NetworkTapRuleProperties 

type NetworkTapRuleProperties struct {
	// Switch configuration description.
	Annotation *string

	// Input method to configure Network Tap Rule.
	ConfigurationType *ConfigurationType

	// List of dynamic match configurations.
	DynamicMatchConfigurations []*CommonDynamicMatchConfiguration

	// List of match configurations.
	MatchConfigurations []*NetworkTapRuleMatchConfiguration

	// Polling interval in seconds.
	PollingIntervalInSeconds *PollingIntervalInSeconds

	// Network Tap Rules file URL.
	TapRulesURL *string

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; The last sync timestamp.
	LastSyncedTime *time.Time

	// READ-ONLY; The ARM resource Id of the NetworkTap.
	NetworkTapID *string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

NetworkTapRuleProperties - Network Tap Rule Properties defines the resource properties.

func (NetworkTapRuleProperties) MarshalJSON 

func (n NetworkTapRuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRuleProperties.

func (*NetworkTapRuleProperties) UnmarshalJSON 

func (n *NetworkTapRuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRuleProperties.

type NetworkTapRulesClient 

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

NetworkTapRulesClient contains the methods for the NetworkTapRules group. Don't use this type directly, use NewNetworkTapRulesClient() instead.

func NewNetworkTapRulesClient 

func NewNetworkTapRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkTapRulesClient, error)

NewNetworkTapRulesClient creates a new instance of NetworkTapRulesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkTapRulesClient) BeginCreate 

func (client *NetworkTapRulesClient) BeginCreate(ctx context.Context, resourceGroupName string, networkTapRuleName string, body NetworkTapRule, options *NetworkTapRulesClientBeginCreateOptions) (*runtime.Poller[NetworkTapRulesClientCreateResponse], error)

BeginCreate - Create Network Tap Rule resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • body - Request payload.
  • options - NetworkTapRulesClientBeginCreateOptions contains the optional parameters for the NetworkTapRulesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapRulesClient().BeginCreate(ctx, "example-rg", "example-tapRule", armmanagednetworkfabric.NetworkTapRule{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkTapRuleProperties{
			Annotation:        to.Ptr("annotation"),
			ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
			DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
				{
					IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
						{
							Name:          to.Ptr("example-ipGroup1"),
							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
							IPPrefixes: []*string{
								to.Ptr("10.10.10.10/30")},
						}},
					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
						{
							Name: to.Ptr("example-portGroup1"),
							Ports: []*string{
								to.Ptr("100-200")},
						},
						{
							Name: to.Ptr("example-portGroup2"),
							Ports: []*string{
								to.Ptr("900"),
								to.Ptr("1000-2000")},
						}},
					VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
						{
							Name: to.Ptr("exmaple-vlanGroup"),
							Vlans: []*string{
								to.Ptr("10"),
								to.Ptr("100-200")},
						}},
				}},
			MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
				{
					Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
						{
							Type:                   to.Ptr(armmanagednetworkfabric.TapRuleActionTypeDrop),
							DestinationID:          to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
							IsTimestampEnabled:     to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
							MatchConfigurationName: to.Ptr("match1"),
							Truncate:               to.Ptr("100"),
						}},
					IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
					MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
						{
							IPCondition: &armmanagednetworkfabric.IPMatchCondition{
								Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
								IPGroupNames: []*string{
									to.Ptr("example-ipGroup")},
								IPPrefixValues: []*string{
									to.Ptr("10.10.10.10/20")},
								PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
							},
							ProtocolTypes: []*string{
								to.Ptr("TCP")},
							VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
								InnerVlans: []*string{
									to.Ptr("11-20")},
								VlanGroupNames: []*string{
									to.Ptr("exmaple-vlanGroup")},
								Vlans: []*string{
									to.Ptr("10")},
							},
							EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
							PortCondition: &armmanagednetworkfabric.PortCondition{
								Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
								PortGroupNames: []*string{
									to.Ptr("example-portGroup1")},
								PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
								Ports: []*string{
									to.Ptr("100")},
							},
						}},
					MatchConfigurationName: to.Ptr("config1"),
					SequenceNumber:         to.Ptr[int64](10),
				}},
			TapRulesURL:              to.Ptr("https://microsoft.com/a"),
			PollingIntervalInSeconds: to.Ptr(armmanagednetworkfabric.PollingIntervalInSeconds(30)),
		},
	}, 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.NetworkTapRule = armmanagednetworkfabric.NetworkTapRule{
	// 	Name: to.Ptr("example-tapRule"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkTapRules"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-tapRule"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkTapRuleProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
	// 		DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
	// 			{
	// 				IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
	// 					{
	// 						Name: to.Ptr("example-ipGroup1"),
	// 						IPPrefixes: []*string{
	// 							to.Ptr("10.10.10.10/30")},
	// 					}},
	// 					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
	// 						{
	// 							Name: to.Ptr("example-portGroup1"),
	// 							Ports: []*string{
	// 								to.Ptr("100-200")},
	// 							},
	// 							{
	// 								Name: to.Ptr("example-portGroup2"),
	// 								Ports: []*string{
	// 									to.Ptr("900"),
	// 									to.Ptr("1000-2000")},
	// 							}},
	// 							VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
	// 								{
	// 									Name: to.Ptr("exmaple-vlanGroup"),
	// 									Vlans: []*string{
	// 										to.Ptr("10"),
	// 										to.Ptr("100-200")},
	// 								}},
	// 						}},
	// 						MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
	// 							{
	// 								Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
	// 									{
	// 										Type: to.Ptr(armmanagednetworkfabric.TapRuleActionTypeDrop),
	// 										DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
	// 										IsTimestampEnabled: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 										MatchConfigurationName: to.Ptr("match1"),
	// 										Truncate: to.Ptr("100"),
	// 								}},
	// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 								MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
	// 									{
	// 										IPCondition: &armmanagednetworkfabric.IPMatchCondition{
	// 											Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
	// 											IPGroupNames: []*string{
	// 												to.Ptr("example-ipGroup")},
	// 												IPPrefixValues: []*string{
	// 													to.Ptr("10.10.10.10/20")},
	// 													PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
	// 												},
	// 												ProtocolTypes: []*string{
	// 													to.Ptr("TCP")},
	// 													VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
	// 														InnerVlans: []*string{
	// 															to.Ptr("11-20")},
	// 															VlanGroupNames: []*string{
	// 																to.Ptr("exmaple-vlanGroup")},
	// 																Vlans: []*string{
	// 																	to.Ptr("10")},
	// 																},
	// 																EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
	// 																PortCondition: &armmanagednetworkfabric.PortCondition{
	// 																	Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
	// 																	PortGroupNames: []*string{
	// 																		to.Ptr("example-portGroup1")},
	// 																		PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
	// 																		Ports: []*string{
	// 																			to.Ptr("100")},
	// 																		},
	// 																}},
	// 																MatchConfigurationName: to.Ptr("config1"),
	// 																SequenceNumber: to.Ptr[int64](10),
	// 														}},
	// 														TapRulesURL: to.Ptr("https://microsoft.com/a"),
	// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 														ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 														LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.485Z"); return t}()),
	// 														NetworkTapID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-tap"),
	// 														PollingIntervalInSeconds: to.Ptr(armmanagednetworkfabric.PollingIntervalInSeconds(30)),
	// 														ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 													},
	// 												}
}

Output:

func (*NetworkTapRulesClient) BeginDelete 

func (client *NetworkTapRulesClient) BeginDelete(ctx context.Context, resourceGroupName string, networkTapRuleName string, options *NetworkTapRulesClientBeginDeleteOptions) (*runtime.Poller[NetworkTapRulesClientDeleteResponse], error)

BeginDelete - Delete Network Tap Rule resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • options - NetworkTapRulesClientBeginDeleteOptions contains the optional parameters for the NetworkTapRulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapRulesClient().BeginDelete(ctx, "example-rg", "example-tapRule", 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)
	}
}

Output:

func (*NetworkTapRulesClient) BeginResync 

func (client *NetworkTapRulesClient) BeginResync(ctx context.Context, resourceGroupName string, networkTapRuleName string, options *NetworkTapRulesClientBeginResyncOptions) (*runtime.Poller[NetworkTapRulesClientResyncResponse], error)

BeginResync - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • options - NetworkTapRulesClientBeginResyncOptions contains the optional parameters for the NetworkTapRulesClient.BeginResync method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_Resync_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapRulesClient().BeginResync(ctx, "example-rg", "example-tapRule", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkTapRulesClient) BeginUpdate 

func (client *NetworkTapRulesClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkTapRuleName string, body NetworkTapRulePatch, options *NetworkTapRulesClientBeginUpdateOptions) (*runtime.Poller[NetworkTapRulesClientUpdateResponse], error)

BeginUpdate - Update certain properties of the Network Tap Rule resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • body - Network Tap Rule properties to update.
  • options - NetworkTapRulesClientBeginUpdateOptions contains the optional parameters for the NetworkTapRulesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapRulesClient().BeginUpdate(ctx, "example-rg", "example-tapRule", armmanagednetworkfabric.NetworkTapRulePatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.NetworkTapRulePatchProperties{
			Annotation:        to.Ptr("annotation"),
			ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
			DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
				{
					IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
						{
							Name:          to.Ptr("example-ipGroup1"),
							IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
							IPPrefixes: []*string{
								to.Ptr("10.10.10.10/30")},
						}},
					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
						{
							Name: to.Ptr("example-portGroup1"),
							Ports: []*string{
								to.Ptr("100-200")},
						}},
					VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
						{
							Name: to.Ptr("exmaple-vlanGroup"),
							Vlans: []*string{
								to.Ptr("10"),
								to.Ptr("100-200")},
						}},
				}},
			MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
				{
					Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
						{
							Type:                   to.Ptr(armmanagednetworkfabric.TapRuleActionTypeGoto),
							DestinationID:          to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
							IsTimestampEnabled:     to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
							MatchConfigurationName: to.Ptr("match1"),
							Truncate:               to.Ptr("100"),
						}},
					IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
					MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
						{
							IPCondition: &armmanagednetworkfabric.IPMatchCondition{
								Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
								IPGroupNames: []*string{
									to.Ptr("example-ipGroup")},
								IPPrefixValues: []*string{
									to.Ptr("10.10.10.10/20")},
								PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
							},
							ProtocolTypes: []*string{
								to.Ptr("TCP")},
							VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
								InnerVlans: []*string{
									to.Ptr("11-20")},
								VlanGroupNames: []*string{
									to.Ptr("exmaple-vlanGroup")},
								Vlans: []*string{
									to.Ptr("10")},
							},
							EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
							PortCondition: &armmanagednetworkfabric.PortCondition{
								Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
								PortGroupNames: []*string{
									to.Ptr("example-portGroup1")},
								PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
								Ports: []*string{
									to.Ptr("100")},
							},
						}},
					MatchConfigurationName: to.Ptr("config1"),
					SequenceNumber:         to.Ptr[int64](10),
				}},
			TapRulesURL: to.Ptr("https://microsoft.com/amdsdx"),
		},
	}, 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.NetworkTapRule = armmanagednetworkfabric.NetworkTapRule{
	// 	Name: to.Ptr("example-tapRule"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkTapRules"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-tapRule"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkTapRuleProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
	// 		DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
	// 			{
	// 				IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
	// 					{
	// 						Name: to.Ptr("example-ipGroup1"),
	// 						IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 						IPPrefixes: []*string{
	// 							to.Ptr("10.10.10.10/30")},
	// 					}},
	// 					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
	// 						{
	// 							Name: to.Ptr("example-portGroup1"),
	// 							Ports: []*string{
	// 								to.Ptr("100-200")},
	// 							},
	// 							{
	// 								Name: to.Ptr("example-portGroup2"),
	// 								Ports: []*string{
	// 									to.Ptr("900"),
	// 									to.Ptr("1000-2000")},
	// 							}},
	// 							VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
	// 								{
	// 									Name: to.Ptr("exmaple-vlanGroup"),
	// 									Vlans: []*string{
	// 										to.Ptr("10"),
	// 										to.Ptr("100-200")},
	// 								}},
	// 						}},
	// 						MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
	// 							{
	// 								Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
	// 									{
	// 										Type: to.Ptr(armmanagednetworkfabric.TapRuleActionTypeGoto),
	// 										DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
	// 										IsTimestampEnabled: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 										MatchConfigurationName: to.Ptr("match1"),
	// 										Truncate: to.Ptr("100"),
	// 								}},
	// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 								MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
	// 									{
	// 										IPCondition: &armmanagednetworkfabric.IPMatchCondition{
	// 											Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
	// 											IPGroupNames: []*string{
	// 												to.Ptr("example-ipGroup")},
	// 												IPPrefixValues: []*string{
	// 													to.Ptr("10.10.10.10/20")},
	// 													PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
	// 												},
	// 												ProtocolTypes: []*string{
	// 													to.Ptr("TCP")},
	// 													VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
	// 														InnerVlans: []*string{
	// 															to.Ptr("11-20")},
	// 															VlanGroupNames: []*string{
	// 																to.Ptr("exmaple-vlanGroup")},
	// 																Vlans: []*string{
	// 																	to.Ptr("10")},
	// 																},
	// 																EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
	// 																PortCondition: &armmanagednetworkfabric.PortCondition{
	// 																	Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
	// 																	PortGroupNames: []*string{
	// 																		to.Ptr("example-portGroup1")},
	// 																		PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
	// 																		Ports: []*string{
	// 																			to.Ptr("100")},
	// 																		},
	// 																}},
	// 																MatchConfigurationName: to.Ptr("config1"),
	// 																SequenceNumber: to.Ptr[int64](10),
	// 														}},
	// 														TapRulesURL: to.Ptr("https://microsoft.com/a"),
	// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 														ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 														LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.485Z"); return t}()),
	// 														NetworkTapID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-tap"),
	// 														PollingIntervalInSeconds: to.Ptr(armmanagednetworkfabric.PollingIntervalInSeconds(30)),
	// 														ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 													},
	// 												}
}

Output:

func (*NetworkTapRulesClient) BeginUpdateAdministrativeState 

func (client *NetworkTapRulesClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, networkTapRuleName string, body UpdateAdministrativeState, options *NetworkTapRulesClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[NetworkTapRulesClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • body - Request payload.
  • options - NetworkTapRulesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkTapRulesClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapRulesClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-tapRule", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkTapRulesClient) BeginValidateConfiguration 

func (client *NetworkTapRulesClient) BeginValidateConfiguration(ctx context.Context, resourceGroupName string, networkTapRuleName string, options *NetworkTapRulesClientBeginValidateConfigurationOptions) (*runtime.Poller[NetworkTapRulesClientValidateConfigurationResponse], error)

BeginValidateConfiguration - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • options - NetworkTapRulesClientBeginValidateConfigurationOptions contains the optional parameters for the NetworkTapRulesClient.BeginValidateConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_ValidateConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapRulesClient().BeginValidateConfiguration(ctx, "example-rg", "example-tapRule", 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ActionDetails"),
	// }
}

Output:

func (*NetworkTapRulesClient) Get 

func (client *NetworkTapRulesClient) Get(ctx context.Context, resourceGroupName string, networkTapRuleName string, options *NetworkTapRulesClientGetOptions) (NetworkTapRulesClientGetResponse, error)

Get - Get Network Tap Rule resource details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapRuleName - Name of the Network Tap Rule.
  • options - NetworkTapRulesClientGetOptions contains the optional parameters for the NetworkTapRulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkTapRulesClient().Get(ctx, "example-rg", "example-tapRule", 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.NetworkTapRule = armmanagednetworkfabric.NetworkTapRule{
	// 	Name: to.Ptr("example-tapRule"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkTapRules"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-tapRule"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkTapRuleProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
	// 		DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
	// 			{
	// 				IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
	// 					{
	// 						Name: to.Ptr("example-ipGroup1"),
	// 						IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 						IPPrefixes: []*string{
	// 							to.Ptr("10.10.10.10/30")},
	// 					}},
	// 					PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
	// 						{
	// 							Name: to.Ptr("example-portGroup1"),
	// 							Ports: []*string{
	// 								to.Ptr("100-200")},
	// 							},
	// 							{
	// 								Name: to.Ptr("example-portGroup2"),
	// 								Ports: []*string{
	// 									to.Ptr("900"),
	// 									to.Ptr("1000-2000")},
	// 							}},
	// 							VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
	// 								{
	// 									Name: to.Ptr("exmaple-vlanGroup"),
	// 									Vlans: []*string{
	// 										to.Ptr("10"),
	// 										to.Ptr("100-200")},
	// 								}},
	// 						}},
	// 						MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
	// 							{
	// 								Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
	// 									{
	// 										Type: to.Ptr(armmanagednetworkfabric.TapRuleActionTypeDrop),
	// 										DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
	// 										IsTimestampEnabled: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 										MatchConfigurationName: to.Ptr("match1"),
	// 										Truncate: to.Ptr("100"),
	// 								}},
	// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
	// 								MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
	// 									{
	// 										IPCondition: &armmanagednetworkfabric.IPMatchCondition{
	// 											Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
	// 											IPGroupNames: []*string{
	// 												to.Ptr("example-ipGroup")},
	// 												IPPrefixValues: []*string{
	// 													to.Ptr("10.10.10.10/20")},
	// 													PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
	// 												},
	// 												ProtocolTypes: []*string{
	// 													to.Ptr("TCP")},
	// 													VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
	// 														InnerVlans: []*string{
	// 															to.Ptr("11-20")},
	// 															VlanGroupNames: []*string{
	// 																to.Ptr("exmaple-vlanGroup")},
	// 																Vlans: []*string{
	// 																	to.Ptr("10")},
	// 																},
	// 																EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
	// 																PortCondition: &armmanagednetworkfabric.PortCondition{
	// 																	Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
	// 																	PortGroupNames: []*string{
	// 																		to.Ptr("example-portGroup1")},
	// 																		PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
	// 																		Ports: []*string{
	// 																			to.Ptr("100")},
	// 																		},
	// 																}},
	// 																MatchConfigurationName: to.Ptr("config1"),
	// 																SequenceNumber: to.Ptr[int64](10),
	// 														}},
	// 														TapRulesURL: to.Ptr("https://microsoft.com/a"),
	// 														AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 														ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 														LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.485Z"); return t}()),
	// 														NetworkTapID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-tap"),
	// 														PollingIntervalInSeconds: to.Ptr(armmanagednetworkfabric.PollingIntervalInSeconds(30)),
	// 														ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 													},
	// 												}
}

Output:

func (*NetworkTapRulesClient) NewListByResourceGroupPager 

func (client *NetworkTapRulesClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkTapRulesClientListByResourceGroupOptions) *runtime.Pager[NetworkTapRulesClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all the Network Tap Rule resources in the given resource group.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkTapRulesClientListByResourceGroupOptions contains the optional parameters for the NetworkTapRulesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkTapRulesClient().NewListByResourceGroupPager("example-rg", 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.NetworkTapRulesListResult = armmanagednetworkfabric.NetworkTapRulesListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkTapRule{
		// 		{
		// 			Name: to.Ptr("example-tapRule"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkTapRules"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-tapRule"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkTapRuleProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
		// 				DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
		// 					{
		// 						IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
		// 							{
		// 								Name: to.Ptr("example-ipGroup1"),
		// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 								IPPrefixes: []*string{
		// 									to.Ptr("10.10.10.10/30")},
		// 							}},
		// 							PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
		// 								{
		// 									Name: to.Ptr("example-portGroup1"),
		// 									Ports: []*string{
		// 										to.Ptr("100-200")},
		// 									},
		// 									{
		// 										Name: to.Ptr("example-portGroup2"),
		// 										Ports: []*string{
		// 											to.Ptr("900"),
		// 											to.Ptr("1000-2000")},
		// 									}},
		// 									VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
		// 										{
		// 											Name: to.Ptr("exmaple-vlanGroup"),
		// 											Vlans: []*string{
		// 												to.Ptr("10"),
		// 												to.Ptr("100-200")},
		// 										}},
		// 								}},
		// 								MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
		// 									{
		// 										Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
		// 											{
		// 												Type: to.Ptr(armmanagednetworkfabric.TapRuleActionTypeDrop),
		// 												DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
		// 												IsTimestampEnabled: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
		// 												MatchConfigurationName: to.Ptr("match1"),
		// 												Truncate: to.Ptr("100"),
		// 										}},
		// 										IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 										MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
		// 											{
		// 												IPCondition: &armmanagednetworkfabric.IPMatchCondition{
		// 													Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
		// 													IPGroupNames: []*string{
		// 														to.Ptr("example-ipGroup")},
		// 														IPPrefixValues: []*string{
		// 															to.Ptr("10.10.10.10/20")},
		// 															PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
		// 														},
		// 														ProtocolTypes: []*string{
		// 															to.Ptr("TCP")},
		// 															VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
		// 																InnerVlans: []*string{
		// 																	to.Ptr("11-20")},
		// 																	VlanGroupNames: []*string{
		// 																		to.Ptr("exmaple-vlanGroup")},
		// 																		Vlans: []*string{
		// 																			to.Ptr("10")},
		// 																		},
		// 																		EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
		// 																		PortCondition: &armmanagednetworkfabric.PortCondition{
		// 																			Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
		// 																			PortGroupNames: []*string{
		// 																				to.Ptr("example-portGroup1")},
		// 																				PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
		// 																				Ports: []*string{
		// 																					to.Ptr("100")},
		// 																				},
		// 																		}},
		// 																		MatchConfigurationName: to.Ptr("yvtpdqhqc"),
		// 																		SequenceNumber: to.Ptr[int64](3649377483),
		// 																}},
		// 																TapRulesURL: to.Ptr("https://microsoft.com/a"),
		// 																AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 																ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 																LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.485Z"); return t}()),
		// 																NetworkTapID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-tap"),
		// 																PollingIntervalInSeconds: to.Ptr(armmanagednetworkfabric.PollingIntervalInSeconds(30)),
		// 																ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 															},
		// 													}},
		// 												}
	}
}

Output:

func (*NetworkTapRulesClient) NewListBySubscriptionPager 

func (client *NetworkTapRulesClient) NewListBySubscriptionPager(options *NetworkTapRulesClientListBySubscriptionOptions) *runtime.Pager[NetworkTapRulesClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all the Network Tap Rule resources in the given subscription.

Generated from API version 2023-06-15

  • options - NetworkTapRulesClientListBySubscriptionOptions contains the optional parameters for the NetworkTapRulesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTapRules_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkTapRulesClient().NewListBySubscriptionPager(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.NetworkTapRulesListResult = armmanagednetworkfabric.NetworkTapRulesListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkTapRule{
		// 		{
		// 			Name: to.Ptr("example-tapRule"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkTapRules"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-tapRule"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.488Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkTapRuleProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				ConfigurationType: to.Ptr(armmanagednetworkfabric.ConfigurationTypeFile),
		// 				DynamicMatchConfigurations: []*armmanagednetworkfabric.CommonDynamicMatchConfiguration{
		// 					{
		// 						IPGroups: []*armmanagednetworkfabric.IPGroupProperties{
		// 							{
		// 								Name: to.Ptr("example-ipGroup1"),
		// 								IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 								IPPrefixes: []*string{
		// 									to.Ptr("10.10.10.10/30")},
		// 							}},
		// 							PortGroups: []*armmanagednetworkfabric.PortGroupProperties{
		// 								{
		// 									Name: to.Ptr("example-portGroup1"),
		// 									Ports: []*string{
		// 										to.Ptr("100-200")},
		// 									},
		// 									{
		// 										Name: to.Ptr("example-portGroup2"),
		// 										Ports: []*string{
		// 											to.Ptr("900"),
		// 											to.Ptr("1000-2000")},
		// 									}},
		// 									VlanGroups: []*armmanagednetworkfabric.VlanGroupProperties{
		// 										{
		// 											Name: to.Ptr("exmaple-vlanGroup"),
		// 											Vlans: []*string{
		// 												to.Ptr("10"),
		// 												to.Ptr("100-200")},
		// 										}},
		// 								}},
		// 								MatchConfigurations: []*armmanagednetworkfabric.NetworkTapRuleMatchConfiguration{
		// 									{
		// 										Actions: []*armmanagednetworkfabric.NetworkTapRuleAction{
		// 											{
		// 												Type: to.Ptr(armmanagednetworkfabric.TapRuleActionTypeDrop),
		// 												DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
		// 												IsTimestampEnabled: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
		// 												MatchConfigurationName: to.Ptr("match1"),
		// 												Truncate: to.Ptr("100"),
		// 										}},
		// 										IPAddressType: to.Ptr(armmanagednetworkfabric.IPAddressTypeIPv4),
		// 										MatchConditions: []*armmanagednetworkfabric.NetworkTapRuleMatchCondition{
		// 											{
		// 												IPCondition: &armmanagednetworkfabric.IPMatchCondition{
		// 													Type: to.Ptr(armmanagednetworkfabric.SourceDestinationTypeSourceIP),
		// 													IPGroupNames: []*string{
		// 														to.Ptr("example-ipGroup")},
		// 														IPPrefixValues: []*string{
		// 															to.Ptr("10.10.10.10/20")},
		// 															PrefixType: to.Ptr(armmanagednetworkfabric.PrefixTypePrefix),
		// 														},
		// 														ProtocolTypes: []*string{
		// 															to.Ptr("TCP")},
		// 															VlanMatchCondition: &armmanagednetworkfabric.VlanMatchCondition{
		// 																InnerVlans: []*string{
		// 																	to.Ptr("11-20")},
		// 																	VlanGroupNames: []*string{
		// 																		to.Ptr("exmaple-vlanGroup")},
		// 																		Vlans: []*string{
		// 																			to.Ptr("10")},
		// 																		},
		// 																		EncapsulationType: to.Ptr(armmanagednetworkfabric.EncapsulationTypeNone),
		// 																		PortCondition: &armmanagednetworkfabric.PortCondition{
		// 																			Layer4Protocol: to.Ptr(armmanagednetworkfabric.Layer4ProtocolTCP),
		// 																			PortGroupNames: []*string{
		// 																				to.Ptr("example-portGroup1")},
		// 																				PortType: to.Ptr(armmanagednetworkfabric.PortTypeSourcePort),
		// 																				Ports: []*string{
		// 																					to.Ptr("100")},
		// 																				},
		// 																		}},
		// 																		MatchConfigurationName: to.Ptr("config1"),
		// 																		SequenceNumber: to.Ptr[int64](10),
		// 																}},
		// 																TapRulesURL: to.Ptr("https://microsoft.com/a"),
		// 																AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 																ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 																LastSyncedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-12T07:11:22.485Z"); return t}()),
		// 																NetworkTapID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-tap"),
		// 																PollingIntervalInSeconds: to.Ptr(armmanagednetworkfabric.PollingIntervalInSeconds(30)),
		// 																ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 															},
		// 													}},
		// 												}
	}
}

Output:

type NetworkTapRulesClientBeginCreateOptions 

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

NetworkTapRulesClientBeginCreateOptions contains the optional parameters for the NetworkTapRulesClient.BeginCreate method.

type NetworkTapRulesClientBeginDeleteOptions 

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

NetworkTapRulesClientBeginDeleteOptions contains the optional parameters for the NetworkTapRulesClient.BeginDelete method.

type NetworkTapRulesClientBeginResyncOptions 

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

NetworkTapRulesClientBeginResyncOptions contains the optional parameters for the NetworkTapRulesClient.BeginResync method.

type NetworkTapRulesClientBeginUpdateAdministrativeStateOptions 

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

NetworkTapRulesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkTapRulesClient.BeginUpdateAdministrativeState method.

type NetworkTapRulesClientBeginUpdateOptions 

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

NetworkTapRulesClientBeginUpdateOptions contains the optional parameters for the NetworkTapRulesClient.BeginUpdate method.

type NetworkTapRulesClientBeginValidateConfigurationOptions 

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

NetworkTapRulesClientBeginValidateConfigurationOptions contains the optional parameters for the NetworkTapRulesClient.BeginValidateConfiguration method.

type NetworkTapRulesClientCreateResponse 

type NetworkTapRulesClientCreateResponse struct {
	// The NetworkTapRule resource definition.
	NetworkTapRule
}

NetworkTapRulesClientCreateResponse contains the response from method NetworkTapRulesClient.BeginCreate.

type NetworkTapRulesClientDeleteResponse 

type NetworkTapRulesClientDeleteResponse struct {
}

NetworkTapRulesClientDeleteResponse contains the response from method NetworkTapRulesClient.BeginDelete.

type NetworkTapRulesClientGetOptions 

type NetworkTapRulesClientGetOptions struct {
}

NetworkTapRulesClientGetOptions contains the optional parameters for the NetworkTapRulesClient.Get method.

type NetworkTapRulesClientGetResponse 

type NetworkTapRulesClientGetResponse struct {
	// The NetworkTapRule resource definition.
	NetworkTapRule
}

NetworkTapRulesClientGetResponse contains the response from method NetworkTapRulesClient.Get.

type NetworkTapRulesClientListByResourceGroupOptions 

type NetworkTapRulesClientListByResourceGroupOptions struct {
}

NetworkTapRulesClientListByResourceGroupOptions contains the optional parameters for the NetworkTapRulesClient.NewListByResourceGroupPager method.

type NetworkTapRulesClientListByResourceGroupResponse 

type NetworkTapRulesClientListByResourceGroupResponse struct {
	// List of NetworkTapRules.
	NetworkTapRulesListResult
}

NetworkTapRulesClientListByResourceGroupResponse contains the response from method NetworkTapRulesClient.NewListByResourceGroupPager.

type NetworkTapRulesClientListBySubscriptionOptions 

type NetworkTapRulesClientListBySubscriptionOptions struct {
}

NetworkTapRulesClientListBySubscriptionOptions contains the optional parameters for the NetworkTapRulesClient.NewListBySubscriptionPager method.

type NetworkTapRulesClientListBySubscriptionResponse 

type NetworkTapRulesClientListBySubscriptionResponse struct {
	// List of NetworkTapRules.
	NetworkTapRulesListResult
}

NetworkTapRulesClientListBySubscriptionResponse contains the response from method NetworkTapRulesClient.NewListBySubscriptionPager.

type NetworkTapRulesClientResyncResponse 

type NetworkTapRulesClientResyncResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkTapRulesClientResyncResponse contains the response from method NetworkTapRulesClient.BeginResync.

type NetworkTapRulesClientUpdateAdministrativeStateResponse 

type NetworkTapRulesClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkTapRulesClientUpdateAdministrativeStateResponse contains the response from method NetworkTapRulesClient.BeginUpdateAdministrativeState.

type NetworkTapRulesClientUpdateResponse 

type NetworkTapRulesClientUpdateResponse struct {
	// The NetworkTapRule resource definition.
	NetworkTapRule
}

NetworkTapRulesClientUpdateResponse contains the response from method NetworkTapRulesClient.BeginUpdate.

type NetworkTapRulesClientValidateConfigurationResponse 

type NetworkTapRulesClientValidateConfigurationResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

NetworkTapRulesClientValidateConfigurationResponse contains the response from method NetworkTapRulesClient.BeginValidateConfiguration.

type NetworkTapRulesListResult 

type NetworkTapRulesListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of NetworkTapRule resources.
	Value []*NetworkTapRule
}

NetworkTapRulesListResult - List of NetworkTapRules.

func (NetworkTapRulesListResult) MarshalJSON 

func (n NetworkTapRulesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapRulesListResult.

func (*NetworkTapRulesListResult) UnmarshalJSON 

func (n *NetworkTapRulesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapRulesListResult.

type NetworkTapsClient 

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

NetworkTapsClient contains the methods for the NetworkTaps group. Don't use this type directly, use NewNetworkTapsClient() instead.

func NewNetworkTapsClient 

func NewNetworkTapsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkTapsClient, error)

NewNetworkTapsClient creates a new instance of NetworkTapsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkTapsClient) BeginCreate 

func (client *NetworkTapsClient) BeginCreate(ctx context.Context, resourceGroupName string, networkTapName string, body NetworkTap, options *NetworkTapsClientBeginCreateOptions) (*runtime.Poller[NetworkTapsClientCreateResponse], error)

BeginCreate - Creates a Network Tap. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapName - Name of the Network Tap.
  • body - Request payload.
  • options - NetworkTapsClientBeginCreateOptions contains the optional parameters for the NetworkTapsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapsClient().BeginCreate(ctx, "example-rg", "example-networkTap", armmanagednetworkfabric.NetworkTap{
		Location: to.Ptr("eastuseuap"),
		Tags: map[string]*string{
			"key6024": to.Ptr("1234"),
		},
		Properties: &armmanagednetworkfabric.NetworkTapProperties{
			Annotation: to.Ptr("annotation"),
			Destinations: []*armmanagednetworkfabric.NetworkTapPropertiesDestinationsItem{
				{
					Name:                 to.Ptr("example-destinaionName"),
					DestinationID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
					DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
					DestinationType:      to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
					IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
						Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
						NeighborGroupIDs: []*string{
							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
					},
				}},
			NetworkPacketBrokerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
			PollingType:           to.Ptr(armmanagednetworkfabric.PollingTypePull),
		},
	}, 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.NetworkTap = armmanagednetworkfabric.NetworkTap{
	// 	Name: to.Ptr("example-networkTap"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkTaps"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.578Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.579Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"key6024": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkTapProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		Destinations: []*armmanagednetworkfabric.NetworkTapPropertiesDestinationsItem{
	// 			{
	// 				Name: to.Ptr("example-destinaionName"),
	// 				DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
	// 				DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
	// 				DestinationType: to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
	// 				IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
	// 					Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
	// 					NeighborGroupIDs: []*string{
	// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
	// 					},
	// 			}},
	// 			NetworkPacketBrokerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
	// 			PollingType: to.Ptr(armmanagednetworkfabric.PollingTypePull),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			SourceTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-sourceTapRule"),
	// 		},
	// 	}
}

Output:

func (*NetworkTapsClient) BeginDelete 

func (client *NetworkTapsClient) BeginDelete(ctx context.Context, resourceGroupName string, networkTapName string, options *NetworkTapsClientBeginDeleteOptions) (*runtime.Poller[NetworkTapsClientDeleteResponse], error)

BeginDelete - Deletes Network Tap. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapName - Name of the Network Tap.
  • options - NetworkTapsClientBeginDeleteOptions contains the optional parameters for the NetworkTapsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapsClient().BeginDelete(ctx, "example-rg", "example-networkTap", 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)
	}
}

Output:

func (*NetworkTapsClient) BeginResync 

func (client *NetworkTapsClient) BeginResync(ctx context.Context, resourceGroupName string, networkTapName string, options *NetworkTapsClientBeginResyncOptions) (*runtime.Poller[NetworkTapsClientResyncResponse], error)

BeginResync - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapName - Name of the Network Tap.
  • options - NetworkTapsClientBeginResyncOptions contains the optional parameters for the NetworkTapsClient.BeginResync method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_Resync_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapsClient().BeginResync(ctx, "example-rg", "example-networkTap", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkTapsClient) BeginUpdate 

func (client *NetworkTapsClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkTapName string, body NetworkTapPatch, options *NetworkTapsClientBeginUpdateOptions) (*runtime.Poller[NetworkTapsClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the Network Tap resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapName - Name of the Network Tap.
  • body - Network Tap properties to update.
  • options - NetworkTapsClientBeginUpdateOptions contains the optional parameters for the NetworkTapsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapsClient().BeginUpdate(ctx, "example-rg", "example-networkTap", armmanagednetworkfabric.NetworkTapPatch{
		Tags: map[string]*string{
			"key6024": to.Ptr("1234"),
		},
		Properties: &armmanagednetworkfabric.NetworkTapPatchableParameters{
			Annotation: to.Ptr("annotation1"),
			Destinations: []*armmanagednetworkfabric.NetworkTapPatchableParametersDestinationsItem{
				{
					Name:                 to.Ptr("example-destinaionName"),
					DestinationID:        to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
					DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
					DestinationType:      to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
					IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
						Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
						NeighborGroupIDs: []*string{
							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
					},
				}},
			PollingType: to.Ptr(armmanagednetworkfabric.PollingTypePull),
		},
	}, 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.NetworkTap = armmanagednetworkfabric.NetworkTap{
	// 	Name: to.Ptr("example-networkTap"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkTaps"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.578Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.579Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"key6024": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkTapProperties{
	// 		Annotation: to.Ptr("annotation1"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		Destinations: []*armmanagednetworkfabric.NetworkTapPropertiesDestinationsItem{
	// 			{
	// 				Name: to.Ptr("example-destinaionName"),
	// 				DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
	// 				DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
	// 				DestinationType: to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
	// 				IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
	// 					Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
	// 					NeighborGroupIDs: []*string{
	// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
	// 					},
	// 			}},
	// 			NetworkPacketBrokerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
	// 			PollingType: to.Ptr(armmanagednetworkfabric.PollingTypePull),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			SourceTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-sourceTapRule"),
	// 		},
	// 	}
}

Output:

func (*NetworkTapsClient) BeginUpdateAdministrativeState 

func (client *NetworkTapsClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, networkTapName string, body UpdateAdministrativeState, options *NetworkTapsClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[NetworkTapsClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Implements the operation to the underlying resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapName - Name of the Network Tap.
  • body - Request payload.
  • options - NetworkTapsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkTapsClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkTapsClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-networkTap", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForDeviceUpdate = armmanagednetworkfabric.CommonPostActionResponseForDeviceUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	FailedDevices: []*string{
	// 		to.Ptr("")},
	// 		SuccessfulDevices: []*string{
	// 			to.Ptr("")},
	// 		}
}

Output:

func (*NetworkTapsClient) Get 

func (client *NetworkTapsClient) Get(ctx context.Context, resourceGroupName string, networkTapName string, options *NetworkTapsClientGetOptions) (NetworkTapsClientGetResponse, error)

Get - Retrieves details of this Network Tap. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkTapName - Name of the Network Tap.
  • options - NetworkTapsClientGetOptions contains the optional parameters for the NetworkTapsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkTapsClient().Get(ctx, "example-rg", "example-networkTap", 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.NetworkTap = armmanagednetworkfabric.NetworkTap{
	// 	Name: to.Ptr("example-networkTap"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/networkTaps"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.578Z"); return t}()),
	// 		CreatedBy: to.Ptr("email@address.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.579Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("email@address.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastuseuap"),
	// 	Tags: map[string]*string{
	// 		"key6024": to.Ptr("1234"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkTapProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		Destinations: []*armmanagednetworkfabric.NetworkTapPropertiesDestinationsItem{
	// 			{
	// 				Name: to.Ptr("example-destinaionName"),
	// 				DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
	// 				DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
	// 				DestinationType: to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
	// 				IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
	// 					Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
	// 					NeighborGroupIDs: []*string{
	// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
	// 					},
	// 			}},
	// 			NetworkPacketBrokerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
	// 			PollingType: to.Ptr(armmanagednetworkfabric.PollingTypePull),
	// 			ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 			SourceTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-sourceTapRule"),
	// 		},
	// 	}
}

Output:

func (*NetworkTapsClient) NewListByResourceGroupPager 

func (client *NetworkTapsClient) NewListByResourceGroupPager(resourceGroupName string, options *NetworkTapsClientListByResourceGroupOptions) *runtime.Pager[NetworkTapsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Displays Network Taps list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - NetworkTapsClientListByResourceGroupOptions contains the optional parameters for the NetworkTapsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkTapsClient().NewListByResourceGroupPager("example-rg", 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.NetworkTapsListResult = armmanagednetworkfabric.NetworkTapsListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkTap{
		// 		{
		// 			Name: to.Ptr("example-networkTap"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkTaps"),
		// 			ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.578Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.579Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"key6024": to.Ptr("1234"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkTapProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				Destinations: []*armmanagednetworkfabric.NetworkTapPropertiesDestinationsItem{
		// 					{
		// 						Name: to.Ptr("example-destinaionName"),
		// 						DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
		// 						DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
		// 						DestinationType: to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
		// 						IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
		// 							Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
		// 							NeighborGroupIDs: []*string{
		// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
		// 							},
		// 					}},
		// 					NetworkPacketBrokerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
		// 					PollingType: to.Ptr(armmanagednetworkfabric.PollingTypePull),
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 					SourceTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-sourceTapRule"),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

func (*NetworkTapsClient) NewListBySubscriptionPager 

func (client *NetworkTapsClient) NewListBySubscriptionPager(options *NetworkTapsClientListBySubscriptionOptions) *runtime.Pager[NetworkTapsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Displays Network Taps list by subscription GET method.

Generated from API version 2023-06-15

  • options - NetworkTapsClientListBySubscriptionOptions contains the optional parameters for the NetworkTapsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkTaps_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkTapsClient().NewListBySubscriptionPager(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.NetworkTapsListResult = armmanagednetworkfabric.NetworkTapsListResult{
		// 	Value: []*armmanagednetworkfabric.NetworkTap{
		// 		{
		// 			Name: to.Ptr("example-networkTap"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/networkTaps"),
		// 			ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTaps/example-networkTap"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.578Z"); return t}()),
		// 				CreatedBy: to.Ptr("email@address.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-08T16:02:57.579Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("email@address.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastuseuap"),
		// 			Tags: map[string]*string{
		// 				"key6024": to.Ptr("1234"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkTapProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				Destinations: []*armmanagednetworkfabric.NetworkTapPropertiesDestinationsItem{
		// 					{
		// 						Name: to.Ptr("example-destinaionName"),
		// 						DestinationID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/l3IsloationDomains/example-l3Domain/internalNetworks/example-internalNetwork"),
		// 						DestinationTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-destinationTapRule"),
		// 						DestinationType: to.Ptr(armmanagednetworkfabric.DestinationTypeIsolationDomain),
		// 						IsolationDomainProperties: &armmanagednetworkfabric.IsolationDomainProperties{
		// 							Encapsulation: to.Ptr(armmanagednetworkfabric.EncapsulationNone),
		// 							NeighborGroupIDs: []*string{
		// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup")},
		// 							},
		// 					}},
		// 					NetworkPacketBrokerID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkPacketBrokers/example-networkPacketBroker"),
		// 					PollingType: to.Ptr(armmanagednetworkfabric.PollingTypePull),
		// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 					SourceTapRuleID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkTapRules/example-sourceTapRule"),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type NetworkTapsClientBeginCreateOptions 

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

NetworkTapsClientBeginCreateOptions contains the optional parameters for the NetworkTapsClient.BeginCreate method.

type NetworkTapsClientBeginDeleteOptions 

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

NetworkTapsClientBeginDeleteOptions contains the optional parameters for the NetworkTapsClient.BeginDelete method.

type NetworkTapsClientBeginResyncOptions 

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

NetworkTapsClientBeginResyncOptions contains the optional parameters for the NetworkTapsClient.BeginResync method.

type NetworkTapsClientBeginUpdateAdministrativeStateOptions 

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

NetworkTapsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkTapsClient.BeginUpdateAdministrativeState method.

type NetworkTapsClientBeginUpdateOptions 

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

NetworkTapsClientBeginUpdateOptions contains the optional parameters for the NetworkTapsClient.BeginUpdate method.

type NetworkTapsClientCreateResponse 

type NetworkTapsClientCreateResponse struct {
	// The Network Tap resource definition.
	NetworkTap
}

NetworkTapsClientCreateResponse contains the response from method NetworkTapsClient.BeginCreate.

type NetworkTapsClientDeleteResponse 

type NetworkTapsClientDeleteResponse struct {
}

NetworkTapsClientDeleteResponse contains the response from method NetworkTapsClient.BeginDelete.

type NetworkTapsClientGetOptions 

type NetworkTapsClientGetOptions struct {
}

NetworkTapsClientGetOptions contains the optional parameters for the NetworkTapsClient.Get method.

type NetworkTapsClientGetResponse 

type NetworkTapsClientGetResponse struct {
	// The Network Tap resource definition.
	NetworkTap
}

NetworkTapsClientGetResponse contains the response from method NetworkTapsClient.Get.

type NetworkTapsClientListByResourceGroupOptions 

type NetworkTapsClientListByResourceGroupOptions struct {
}

NetworkTapsClientListByResourceGroupOptions contains the optional parameters for the NetworkTapsClient.NewListByResourceGroupPager method.

type NetworkTapsClientListByResourceGroupResponse 

type NetworkTapsClientListByResourceGroupResponse struct {
	// List of NetworkTaps.
	NetworkTapsListResult
}

NetworkTapsClientListByResourceGroupResponse contains the response from method NetworkTapsClient.NewListByResourceGroupPager.

type NetworkTapsClientListBySubscriptionOptions 

type NetworkTapsClientListBySubscriptionOptions struct {
}

NetworkTapsClientListBySubscriptionOptions contains the optional parameters for the NetworkTapsClient.NewListBySubscriptionPager method.

type NetworkTapsClientListBySubscriptionResponse 

type NetworkTapsClientListBySubscriptionResponse struct {
	// List of NetworkTaps.
	NetworkTapsListResult
}

NetworkTapsClientListBySubscriptionResponse contains the response from method NetworkTapsClient.NewListBySubscriptionPager.

type NetworkTapsClientResyncResponse 

type NetworkTapsClientResyncResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkTapsClientResyncResponse contains the response from method NetworkTapsClient.BeginResync.

type NetworkTapsClientUpdateAdministrativeStateResponse 

type NetworkTapsClientUpdateAdministrativeStateResponse struct {
	// Common response for device updates.
	CommonPostActionResponseForDeviceUpdate
}

NetworkTapsClientUpdateAdministrativeStateResponse contains the response from method NetworkTapsClient.BeginUpdateAdministrativeState.

type NetworkTapsClientUpdateResponse 

type NetworkTapsClientUpdateResponse struct {
	// The Network Tap resource definition.
	NetworkTap
}

NetworkTapsClientUpdateResponse contains the response from method NetworkTapsClient.BeginUpdate.

type NetworkTapsListResult 

type NetworkTapsListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of NetworkTap resources.
	Value []*NetworkTap
}

NetworkTapsListResult - List of NetworkTaps.

func (NetworkTapsListResult) MarshalJSON 

func (n NetworkTapsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkTapsListResult.

func (*NetworkTapsListResult) UnmarshalJSON 

func (n *NetworkTapsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkTapsListResult.

type NetworkToNetworkInterconnect 

type NetworkToNetworkInterconnect struct {
	// REQUIRED; Resource properties.
	Properties *NetworkToNetworkInterconnectProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkToNetworkInterconnect - The Network To Network Interconnect resource definition.

func (NetworkToNetworkInterconnect) MarshalJSON 

func (n NetworkToNetworkInterconnect) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkToNetworkInterconnect.

func (*NetworkToNetworkInterconnect) UnmarshalJSON 

func (n *NetworkToNetworkInterconnect) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkToNetworkInterconnect.

type NetworkToNetworkInterconnectPatch 

type NetworkToNetworkInterconnectPatch struct {
	// Resource properties.
	Properties *NetworkToNetworkInterconnectPatchableProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

NetworkToNetworkInterconnectPatch - The Network To Network Interconnect resource patch definition.

func (NetworkToNetworkInterconnectPatch) MarshalJSON 

func (n NetworkToNetworkInterconnectPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkToNetworkInterconnectPatch.

func (*NetworkToNetworkInterconnectPatch) UnmarshalJSON 

func (n *NetworkToNetworkInterconnectPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkToNetworkInterconnectPatch.

type NetworkToNetworkInterconnectPatchableProperties 

type NetworkToNetworkInterconnectPatchableProperties struct {
	// Egress Acl. ARM resource ID of Access Control Lists.
	EgressACLID *string

	// Export Route Policy information
	ExportRoutePolicy *ExportRoutePolicyInformation

	// Import Route Policy information.
	ImportRoutePolicy *ImportRoutePolicyInformation

	// Ingress Acl. ARM resource ID of Access Control Lists.
	IngressACLID *string

	// Common properties for Layer2Configuration.
	Layer2Configuration *Layer2Configuration

	// NPB Static Route Configuration properties.
	NpbStaticRouteConfiguration *NpbStaticRouteConfiguration

	// Common properties for Layer3Configuration.
	OptionBLayer3Configuration *OptionBLayer3Configuration
}

NetworkToNetworkInterconnectPatchableProperties - Network to Network Interconnect patchable properties.

func (NetworkToNetworkInterconnectPatchableProperties) MarshalJSON 

func (n NetworkToNetworkInterconnectPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkToNetworkInterconnectPatchableProperties.

func (*NetworkToNetworkInterconnectPatchableProperties) UnmarshalJSON 

func (n *NetworkToNetworkInterconnectPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkToNetworkInterconnectPatchableProperties.

type NetworkToNetworkInterconnectProperties 

type NetworkToNetworkInterconnectProperties struct {
	// REQUIRED; Based on this option layer3 parameters are mandatory. Example: True/False
	UseOptionB *BooleanEnumProperty

	// Egress Acl. ARM resource ID of Access Control Lists.
	EgressACLID *string

	// Export Route Policy configuration.
	ExportRoutePolicy *ExportRoutePolicyInformation

	// Import Route Policy configuration.
	ImportRoutePolicy *ImportRoutePolicyInformation

	// Ingress Acl. ARM resource ID of Access Control Lists.
	IngressACLID *string

	// Configuration to use NNI for Infrastructure Management. Example: True/False.
	IsManagementType *IsManagementType

	// Common properties for Layer2 Configuration.
	Layer2Configuration *Layer2Configuration

	// Type of NNI used. Example: CE | NPB
	NniType *NniType

	// NPB Static Route Configuration properties.
	NpbStaticRouteConfiguration *NpbStaticRouteConfiguration

	// Common properties for Layer3Configuration.
	OptionBLayer3Configuration *NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

NetworkToNetworkInterconnectProperties - Configuration used to setup CE-PE connectivity.

func (NetworkToNetworkInterconnectProperties) MarshalJSON 

func (n NetworkToNetworkInterconnectProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkToNetworkInterconnectProperties.

func (*NetworkToNetworkInterconnectProperties) UnmarshalJSON 

func (n *NetworkToNetworkInterconnectProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkToNetworkInterconnectProperties.

type NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration 

type NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration struct {
	// ASN of PE devices for CE/PE connectivity.Example : 28
	PeerASN *int64

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// VLAN for CE/PE Layer 3 connectivity.Example : 501
	VlanID *int32

	// READ-ONLY; ASN of CE devices for CE/PE connectivity.
	FabricASN *int64
}

NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration - Common properties for Layer3Configuration.

func (NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration) MarshalJSON 

func (n NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration.

func (*NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration) UnmarshalJSON 

func (n *NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration.

type NetworkToNetworkInterconnectsClient 

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

NetworkToNetworkInterconnectsClient contains the methods for the NetworkToNetworkInterconnects group. Don't use this type directly, use NewNetworkToNetworkInterconnectsClient() instead.

func NewNetworkToNetworkInterconnectsClient 

func NewNetworkToNetworkInterconnectsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*NetworkToNetworkInterconnectsClient, error)

NewNetworkToNetworkInterconnectsClient creates a new instance of NetworkToNetworkInterconnectsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*NetworkToNetworkInterconnectsClient) BeginCreate 

func (client *NetworkToNetworkInterconnectsClient) BeginCreate(ctx context.Context, resourceGroupName string, networkFabricName string, networkToNetworkInterconnectName string, body NetworkToNetworkInterconnect, options *NetworkToNetworkInterconnectsClientBeginCreateOptions) (*runtime.Poller[NetworkToNetworkInterconnectsClientCreateResponse], error)

BeginCreate - Configuration used to setup CE-PE connectivity PUT Method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • networkToNetworkInterconnectName - Name of the Network to Network Interconnect.
  • body - Request payload.
  • options - NetworkToNetworkInterconnectsClientBeginCreateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkToNetworkInterconnectsClient().BeginCreate(ctx, "example-rg", "example-fabric", "example-nni", armmanagednetworkfabric.NetworkToNetworkInterconnect{
		Properties: &armmanagednetworkfabric.NetworkToNetworkInterconnectProperties{
			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicyInformation{
				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
			},
			ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicyInformation{
				ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
				ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
			},
			IngressACLID:     to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			IsManagementType: to.Ptr(armmanagednetworkfabric.IsManagementTypeTrue),
			Layer2Configuration: &armmanagednetworkfabric.Layer2Configuration{
				Interfaces: []*string{
					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
				Mtu: to.Ptr[int32](1500),
			},
			NniType: to.Ptr(armmanagednetworkfabric.NniTypeCE),
			NpbStaticRouteConfiguration: &armmanagednetworkfabric.NpbStaticRouteConfiguration{
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](300),
					Multiplier:             to.Ptr[int32](25),
				},
				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("21.20.20.20")},
						Prefix: to.Ptr("20.0.0.12/30"),
					}},
				IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("4FFE:FFFF:0:CD30::ac")},
						Prefix: to.Ptr("3FFE:FFFF:0:CD30::ac/127"),
					}},
			},
			OptionBLayer3Configuration: &armmanagednetworkfabric.NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration{
				PrimaryIPv4Prefix:   to.Ptr("10.0.0.12/30"),
				PrimaryIPv6Prefix:   to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
				SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
				SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
				PeerASN:             to.Ptr[int64](61234),
				VlanID:              to.Ptr[int32](1234),
			},
			UseOptionB: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
		},
	}, 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.NetworkToNetworkInterconnect = armmanagednetworkfabric.NetworkToNetworkInterconnect{
	// 	Name: to.Ptr("example-nni"),
	// 	Type: to.Ptr("microsoft.managedNetworkFabric/networkFabrics/networkToNetworkInterconnects"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkToNetworkInterconnectProperties{
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicyInformation{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 		},
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicyInformation{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 		},
	// 		IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		IsManagementType: to.Ptr(armmanagednetworkfabric.IsManagementTypeTrue),
	// 		Layer2Configuration: &armmanagednetworkfabric.Layer2Configuration{
	// 			Interfaces: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
	// 				Mtu: to.Ptr[int32](1500),
	// 			},
	// 			NniType: to.Ptr(armmanagednetworkfabric.NniTypeCE),
	// 			NpbStaticRouteConfiguration: &armmanagednetworkfabric.NpbStaticRouteConfiguration{
	// 				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 					AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 					IntervalInMilliSeconds: to.Ptr[int32](300),
	// 					Multiplier: to.Ptr[int32](25),
	// 				},
	// 				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 					{
	// 						NextHop: []*string{
	// 							to.Ptr("21.20.20.20")},
	// 							Prefix: to.Ptr("20.0.0.12/30"),
	// 					}},
	// 					IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 						{
	// 							NextHop: []*string{
	// 								to.Ptr("4FFE:FFFF:0:CD30::ac")},
	// 								Prefix: to.Ptr("3FFE:FFFF:0:CD30::ac/127"),
	// 						}},
	// 					},
	// 					OptionBLayer3Configuration: &armmanagednetworkfabric.NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration{
	// 						PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 						PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 						SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
	// 						SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 						FabricASN: to.Ptr[int64](17),
	// 						PeerASN: to.Ptr[int64](61234),
	// 						VlanID: to.Ptr[int32](1234),
	// 					},
	// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					UseOptionB: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 				},
	// 			}
}

Output:

func (*NetworkToNetworkInterconnectsClient) BeginDelete 

func (client *NetworkToNetworkInterconnectsClient) BeginDelete(ctx context.Context, resourceGroupName string, networkFabricName string, networkToNetworkInterconnectName string, options *NetworkToNetworkInterconnectsClientBeginDeleteOptions) (*runtime.Poller[NetworkToNetworkInterconnectsClientDeleteResponse], error)

BeginDelete - Implements NetworkToNetworkInterconnects DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • networkToNetworkInterconnectName - Name of the Network to Network Interconnect.
  • options - NetworkToNetworkInterconnectsClientBeginDeleteOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkToNetworkInterconnectsClient().BeginDelete(ctx, "example-rg", "example-fabric", "example-nni", 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)
	}
}

Output:

func (*NetworkToNetworkInterconnectsClient) BeginUpdate 

func (client *NetworkToNetworkInterconnectsClient) BeginUpdate(ctx context.Context, resourceGroupName string, networkFabricName string, networkToNetworkInterconnectName string, body NetworkToNetworkInterconnectPatch, options *NetworkToNetworkInterconnectsClientBeginUpdateOptions) (*runtime.Poller[NetworkToNetworkInterconnectsClientUpdateResponse], error)

BeginUpdate - Update certain properties of the Network To NetworkInterconnects resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • networkToNetworkInterconnectName - Name of the Network to Network Interconnect.
  • body - Network to Network Interconnect properties to update.
  • options - NetworkToNetworkInterconnectsClientBeginUpdateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkToNetworkInterconnectsClient().BeginUpdate(ctx, "example-rg", "example-fabric", "example-nni", armmanagednetworkfabric.NetworkToNetworkInterconnectPatch{
		Properties: &armmanagednetworkfabric.NetworkToNetworkInterconnectPatchableProperties{
			EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicyInformation{
				ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
				ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
			},
			ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicyInformation{
				ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
				ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy1"),
			},
			IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
			Layer2Configuration: &armmanagednetworkfabric.Layer2Configuration{
				Interfaces: []*string{
					to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
				Mtu: to.Ptr[int32](1500),
			},
			NpbStaticRouteConfiguration: &armmanagednetworkfabric.NpbStaticRouteConfiguration{
				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
					IntervalInMilliSeconds: to.Ptr[int32](310),
					Multiplier:             to.Ptr[int32](15),
				},
				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("21.20.20.10")},
						Prefix: to.Ptr("20.0.0.11/30"),
					}},
				IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
					{
						NextHop: []*string{
							to.Ptr("5FFE:FFFF:0:CD30::ac")},
						Prefix: to.Ptr("4FFE:FFFF:0:CD30::ac/127"),
					}},
			},
			OptionBLayer3Configuration: &armmanagednetworkfabric.OptionBLayer3Configuration{
				PrimaryIPv4Prefix:   to.Ptr("20.0.0.12/29"),
				PrimaryIPv6Prefix:   to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
				SecondaryIPv4Prefix: to.Ptr("20.0.0.14/29"),
				SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
				PeerASN:             to.Ptr[int64](2345),
				VlanID:              to.Ptr[int32](1235),
			},
		},
	}, 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.NetworkToNetworkInterconnect = armmanagednetworkfabric.NetworkToNetworkInterconnect{
	// 	Name: to.Ptr("example-nni"),
	// 	Type: to.Ptr("microsoft.managedNetworkFabric/networkFabrics/networkToNetworkInterconnects"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkToNetworkInterconnectProperties{
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicyInformation{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 		},
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicyInformation{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 		},
	// 		IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		IsManagementType: to.Ptr(armmanagednetworkfabric.IsManagementTypeTrue),
	// 		Layer2Configuration: &armmanagednetworkfabric.Layer2Configuration{
	// 			Interfaces: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
	// 				Mtu: to.Ptr[int32](1500),
	// 			},
	// 			NniType: to.Ptr(armmanagednetworkfabric.NniTypeCE),
	// 			NpbStaticRouteConfiguration: &armmanagednetworkfabric.NpbStaticRouteConfiguration{
	// 				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 					AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 					IntervalInMilliSeconds: to.Ptr[int32](300),
	// 					Multiplier: to.Ptr[int32](25),
	// 				},
	// 				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 					{
	// 						NextHop: []*string{
	// 							to.Ptr("21.20.20.20")},
	// 							Prefix: to.Ptr("20.0.0.12/30"),
	// 					}},
	// 					IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 						{
	// 							NextHop: []*string{
	// 								to.Ptr("4FFE:FFFF:0:CD30::ac")},
	// 								Prefix: to.Ptr("3FFE:FFFF:0:CD30::ac/127"),
	// 						}},
	// 					},
	// 					OptionBLayer3Configuration: &armmanagednetworkfabric.NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration{
	// 						PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 						PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 						SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
	// 						SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 						FabricASN: to.Ptr[int64](17),
	// 						PeerASN: to.Ptr[int64](61234),
	// 						VlanID: to.Ptr[int32](1234),
	// 					},
	// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					UseOptionB: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 				},
	// 			}
}

Output:

func (*NetworkToNetworkInterconnectsClient) BeginUpdateAdministrativeState 

func (client *NetworkToNetworkInterconnectsClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, networkFabricName string, networkToNetworkInterconnectName string, body UpdateAdministrativeState, options *NetworkToNetworkInterconnectsClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[NetworkToNetworkInterconnectsClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Updates the Admin State. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • networkToNetworkInterconnectName - Name of the Network to Network Interconnect.
  • body - Request payload.
  • options - NetworkToNetworkInterconnectsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_updateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkToNetworkInterconnectsClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-fabric", "example-nni", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkToNetworkInterconnectsClient) BeginUpdateNpbStaticRouteBfdAdministrativeState 

func (client *NetworkToNetworkInterconnectsClient) BeginUpdateNpbStaticRouteBfdAdministrativeState(ctx context.Context, resourceGroupName string, networkFabricName string, networkToNetworkInterconnectName string, body UpdateAdministrativeState, options *NetworkToNetworkInterconnectsClientBeginUpdateNpbStaticRouteBfdAdministrativeStateOptions) (*runtime.Poller[NetworkToNetworkInterconnectsClientUpdateNpbStaticRouteBfdAdministrativeStateResponse], error)

BeginUpdateNpbStaticRouteBfdAdministrativeState - Updates the NPB Static Route BFD Administrative State. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • networkToNetworkInterconnectName - Name of the Network to Network Interconnect.
  • body - Request payload.
  • options - NetworkToNetworkInterconnectsClientBeginUpdateNpbStaticRouteBfdAdministrativeStateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginUpdateNpbStaticRouteBfdAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_updateNpbStaticRouteBfdAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewNetworkToNetworkInterconnectsClient().BeginUpdateNpbStaticRouteBfdAdministrativeState(ctx, "example-rg", "example-fabric", "example-nni", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*NetworkToNetworkInterconnectsClient) Get 

func (client *NetworkToNetworkInterconnectsClient) Get(ctx context.Context, resourceGroupName string, networkFabricName string, networkToNetworkInterconnectName string, options *NetworkToNetworkInterconnectsClientGetOptions) (NetworkToNetworkInterconnectsClientGetResponse, error)

Get - Implements NetworkToNetworkInterconnects GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • networkToNetworkInterconnectName - Name of the Network to Network Interconnect.
  • options - NetworkToNetworkInterconnectsClientGetOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewNetworkToNetworkInterconnectsClient().Get(ctx, "example-rg", "example-fabric", "example-nni", 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.NetworkToNetworkInterconnect = armmanagednetworkfabric.NetworkToNetworkInterconnect{
	// 	Name: to.Ptr("example-nni"),
	// 	Type: to.Ptr("microsoft.managedNetworkFabric/networkFabrics/networkToNetworkInterconnects"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Properties: &armmanagednetworkfabric.NetworkToNetworkInterconnectProperties{
	// 		AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 		ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 		EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicyInformation{
	// 			ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 		},
	// 		ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicyInformation{
	// 			ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 			ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 		},
	// 		IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
	// 		IsManagementType: to.Ptr(armmanagednetworkfabric.IsManagementTypeTrue),
	// 		Layer2Configuration: &armmanagednetworkfabric.Layer2Configuration{
	// 			Interfaces: []*string{
	// 				to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
	// 				Mtu: to.Ptr[int32](1500),
	// 			},
	// 			NniType: to.Ptr(armmanagednetworkfabric.NniTypeCE),
	// 			NpbStaticRouteConfiguration: &armmanagednetworkfabric.NpbStaticRouteConfiguration{
	// 				BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
	// 					AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
	// 					IntervalInMilliSeconds: to.Ptr[int32](300),
	// 					Multiplier: to.Ptr[int32](25),
	// 				},
	// 				IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 					{
	// 						NextHop: []*string{
	// 							to.Ptr("21.20.20.20")},
	// 							Prefix: to.Ptr("20.0.0.12/30"),
	// 					}},
	// 					IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
	// 						{
	// 							NextHop: []*string{
	// 								to.Ptr("4FFE:FFFF:0:CD30::ac")},
	// 								Prefix: to.Ptr("3FFE:FFFF:0:CD30::ac/127"),
	// 						}},
	// 					},
	// 					OptionBLayer3Configuration: &armmanagednetworkfabric.NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration{
	// 						PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
	// 						PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
	// 						SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
	// 						SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
	// 						FabricASN: to.Ptr[int64](17),
	// 						PeerASN: to.Ptr[int64](61234),
	// 						VlanID: to.Ptr[int32](1234),
	// 					},
	// 					ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 					UseOptionB: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
	// 				},
	// 			}
}

Output:

func (*NetworkToNetworkInterconnectsClient) NewListByNetworkFabricPager 

func (client *NetworkToNetworkInterconnectsClient) NewListByNetworkFabricPager(resourceGroupName string, networkFabricName string, options *NetworkToNetworkInterconnectsClientListByNetworkFabricOptions) *runtime.Pager[NetworkToNetworkInterconnectsClientListByNetworkFabricResponse]

NewListByNetworkFabricPager - Implements Network To Network Interconnects list by Network Fabric GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • networkFabricName - Name of the Network Fabric.
  • options - NetworkToNetworkInterconnectsClientListByNetworkFabricOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.NewListByNetworkFabricPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/NetworkToNetworkInterconnects_ListByNetworkFabric_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewNetworkToNetworkInterconnectsClient().NewListByNetworkFabricPager("example-rg", "example-fabric", 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.NetworkToNetworkInterconnectsList = armmanagednetworkfabric.NetworkToNetworkInterconnectsList{
		// 	Value: []*armmanagednetworkfabric.NetworkToNetworkInterconnect{
		// 		{
		// 			Name: to.Ptr("example-nni"),
		// 			Type: to.Ptr("microsoft.managedNetworkFabric/networkFabrics/networkToNetworkInterconnects"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric/networkToNetworkInterconnects/example-nni"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-07T09:53:31.314Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Properties: &armmanagednetworkfabric.NetworkToNetworkInterconnectProperties{
		// 				AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 				ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 				EgressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 				ExportRoutePolicy: &armmanagednetworkfabric.ExportRoutePolicyInformation{
		// 					ExportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 					ExportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 				},
		// 				ImportRoutePolicy: &armmanagednetworkfabric.ImportRoutePolicyInformation{
		// 					ImportIPv4RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 					ImportIPv6RoutePolicyID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 				},
		// 				IngressACLID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/accessControlLists/example-acl"),
		// 				IsManagementType: to.Ptr(armmanagednetworkfabric.IsManagementTypeTrue),
		// 				Layer2Configuration: &armmanagednetworkfabric.Layer2Configuration{
		// 					Interfaces: []*string{
		// 						to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkDevices/example-networkDevice/networkInterfaces/example-networkInterface")},
		// 						Mtu: to.Ptr[int32](1500),
		// 					},
		// 					NniType: to.Ptr(armmanagednetworkfabric.NniTypeCE),
		// 					NpbStaticRouteConfiguration: &armmanagednetworkfabric.NpbStaticRouteConfiguration{
		// 						BfdConfiguration: &armmanagednetworkfabric.BfdConfiguration{
		// 							AdministrativeState: to.Ptr(armmanagednetworkfabric.BfdAdministrativeStateEnabled),
		// 							IntervalInMilliSeconds: to.Ptr[int32](300),
		// 							Multiplier: to.Ptr[int32](25),
		// 						},
		// 						IPv4Routes: []*armmanagednetworkfabric.StaticRouteProperties{
		// 							{
		// 								NextHop: []*string{
		// 									to.Ptr("21.20.20.20")},
		// 									Prefix: to.Ptr("20.0.0.12/30"),
		// 							}},
		// 							IPv6Routes: []*armmanagednetworkfabric.StaticRouteProperties{
		// 								{
		// 									NextHop: []*string{
		// 										to.Ptr("4FFE:FFFF:0:CD30::ac")},
		// 										Prefix: to.Ptr("3FFE:FFFF:0:CD30::ac/127"),
		// 								}},
		// 							},
		// 							OptionBLayer3Configuration: &armmanagednetworkfabric.NetworkToNetworkInterconnectPropertiesOptionBLayer3Configuration{
		// 								PrimaryIPv4Prefix: to.Ptr("10.0.0.12/30"),
		// 								PrimaryIPv6Prefix: to.Ptr("4FFE:FFFF:0:CD30::a8/127"),
		// 								SecondaryIPv4Prefix: to.Ptr("40.0.0.14/30"),
		// 								SecondaryIPv6Prefix: to.Ptr("6FFE:FFFF:0:CD30::ac/127"),
		// 								FabricASN: to.Ptr[int64](17),
		// 								PeerASN: to.Ptr[int64](61234),
		// 								VlanID: to.Ptr[int32](1234),
		// 							},
		// 							ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 							UseOptionB: to.Ptr(armmanagednetworkfabric.BooleanEnumPropertyTrue),
		// 						},
		// 				}},
		// 			}
	}
}

Output:

type NetworkToNetworkInterconnectsClientBeginCreateOptions 

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

NetworkToNetworkInterconnectsClientBeginCreateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginCreate method.

type NetworkToNetworkInterconnectsClientBeginDeleteOptions 

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

NetworkToNetworkInterconnectsClientBeginDeleteOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginDelete method.

type NetworkToNetworkInterconnectsClientBeginUpdateAdministrativeStateOptions 

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

NetworkToNetworkInterconnectsClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginUpdateAdministrativeState method.

type NetworkToNetworkInterconnectsClientBeginUpdateNpbStaticRouteBfdAdministrativeStateOptions 

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

NetworkToNetworkInterconnectsClientBeginUpdateNpbStaticRouteBfdAdministrativeStateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginUpdateNpbStaticRouteBfdAdministrativeState method.

type NetworkToNetworkInterconnectsClientBeginUpdateOptions 

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

NetworkToNetworkInterconnectsClientBeginUpdateOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.BeginUpdate method.

type NetworkToNetworkInterconnectsClientCreateResponse 

type NetworkToNetworkInterconnectsClientCreateResponse struct {
	// The Network To Network Interconnect resource definition.
	NetworkToNetworkInterconnect
}

NetworkToNetworkInterconnectsClientCreateResponse contains the response from method NetworkToNetworkInterconnectsClient.BeginCreate.

type NetworkToNetworkInterconnectsClientDeleteResponse 

type NetworkToNetworkInterconnectsClientDeleteResponse struct {
}

NetworkToNetworkInterconnectsClientDeleteResponse contains the response from method NetworkToNetworkInterconnectsClient.BeginDelete.

type NetworkToNetworkInterconnectsClientGetOptions 

type NetworkToNetworkInterconnectsClientGetOptions struct {
}

NetworkToNetworkInterconnectsClientGetOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.Get method.

type NetworkToNetworkInterconnectsClientGetResponse 

type NetworkToNetworkInterconnectsClientGetResponse struct {
	// The Network To Network Interconnect resource definition.
	NetworkToNetworkInterconnect
}

NetworkToNetworkInterconnectsClientGetResponse contains the response from method NetworkToNetworkInterconnectsClient.Get.

type NetworkToNetworkInterconnectsClientListByNetworkFabricOptions 

type NetworkToNetworkInterconnectsClientListByNetworkFabricOptions struct {
}

NetworkToNetworkInterconnectsClientListByNetworkFabricOptions contains the optional parameters for the NetworkToNetworkInterconnectsClient.NewListByNetworkFabricPager method.

type NetworkToNetworkInterconnectsClientListByNetworkFabricResponse 

type NetworkToNetworkInterconnectsClientListByNetworkFabricResponse struct {
	// List of Network To Network Interconnects.
	NetworkToNetworkInterconnectsList
}

NetworkToNetworkInterconnectsClientListByNetworkFabricResponse contains the response from method NetworkToNetworkInterconnectsClient.NewListByNetworkFabricPager.

type NetworkToNetworkInterconnectsClientUpdateAdministrativeStateResponse 

type NetworkToNetworkInterconnectsClientUpdateAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkToNetworkInterconnectsClientUpdateAdministrativeStateResponse contains the response from method NetworkToNetworkInterconnectsClient.BeginUpdateAdministrativeState.

type NetworkToNetworkInterconnectsClientUpdateNpbStaticRouteBfdAdministrativeStateResponse 

type NetworkToNetworkInterconnectsClientUpdateNpbStaticRouteBfdAdministrativeStateResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

NetworkToNetworkInterconnectsClientUpdateNpbStaticRouteBfdAdministrativeStateResponse contains the response from method NetworkToNetworkInterconnectsClient.BeginUpdateNpbStaticRouteBfdAdministrativeState.

type NetworkToNetworkInterconnectsClientUpdateResponse 

type NetworkToNetworkInterconnectsClientUpdateResponse struct {
	// The Network To Network Interconnect resource definition.
	NetworkToNetworkInterconnect
}

NetworkToNetworkInterconnectsClientUpdateResponse contains the response from method NetworkToNetworkInterconnectsClient.BeginUpdate.

type NetworkToNetworkInterconnectsList 

type NetworkToNetworkInterconnectsList struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of NetworkToNetworkInterconnects resources.
	Value []*NetworkToNetworkInterconnect
}

NetworkToNetworkInterconnectsList - List of Network To Network Interconnects.

func (NetworkToNetworkInterconnectsList) MarshalJSON 

func (n NetworkToNetworkInterconnectsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkToNetworkInterconnectsList.

func (*NetworkToNetworkInterconnectsList) UnmarshalJSON 

func (n *NetworkToNetworkInterconnectsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkToNetworkInterconnectsList.

type NfcSKU 

type NfcSKU string

NfcSKU - Network Fabric Controller SKU. 

const (
	NfcSKUBasic           NfcSKU = "Basic"
	NfcSKUHighPerformance NfcSKU = "HighPerformance"
	NfcSKUStandard        NfcSKU = "Standard"
)

func PossibleNfcSKUValues 

func PossibleNfcSKUValues() []NfcSKU

PossibleNfcSKUValues returns the possible values for the NfcSKU const type.

type NniType 

type NniType string

NniType - Type of NNI used. Example: CE | NPB 

const (
	NniTypeCE  NniType = "CE"
	NniTypeNPB NniType = "NPB"
)

func PossibleNniTypeValues 

func PossibleNniTypeValues() []NniType

PossibleNniTypeValues returns the possible values for the NniType const type.

type NpbStaticRouteConfiguration 

type NpbStaticRouteConfiguration struct {
	// BFD Configuration properties.
	BfdConfiguration *BfdConfiguration

	// List of IPv4 Routes.
	IPv4Routes []*StaticRouteProperties

	// List of IPv6 Routes.
	IPv6Routes []*StaticRouteProperties
}

NpbStaticRouteConfiguration - NPB Static Route Configuration properties.

func (NpbStaticRouteConfiguration) MarshalJSON 

func (n NpbStaticRouteConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NpbStaticRouteConfiguration.

func (*NpbStaticRouteConfiguration) UnmarshalJSON 

func (n *NpbStaticRouteConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NpbStaticRouteConfiguration.

type Operation 

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
	// operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for this particular operation.

func (OperationDisplay) MarshalJSON 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; URL to get the next set of operation list results (if there are any).
	NextLink *string

	// READ-ONLY; List of operations supported by the resource provider
	Value []*Operation
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

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

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Returns list of all operations.

Generated from API version 2023-06-15

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/ListOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().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.OperationListResult = armmanagednetworkfabric.OperationListResult{
		// 	Value: []*armmanagednetworkfabric.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.ManagedNetworkFabric/NetworkFabricControllers/Read"),
		// 			ActionType: to.Ptr(armmanagednetworkfabric.ActionTypeInternal),
		// 			Display: &armmanagednetworkfabric.OperationDisplay{
		// 				Description: to.Ptr("Gets/List the NetworkFabricController resource data."),
		// 				Operation: to.Ptr("Gets/List NetworkFabricController resources."),
		// 				Provider: to.Ptr("Microsoft.ManagedNetworkFabric resource provider"),
		// 				Resource: to.Ptr("NetworkFabricControllers"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 			Origin: to.Ptr(armmanagednetworkfabric.OriginUserSystem),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ManagedNetworkFabric/NetworkFabricControllers/Write"),
		// 			ActionType: to.Ptr(armmanagednetworkfabric.ActionTypeInternal),
		// 			Display: &armmanagednetworkfabric.OperationDisplay{
		// 				Description: to.Ptr("Create or Update NetworkFabricController resource data."),
		// 				Operation: to.Ptr("Create or Update NetworkFabricController resource."),
		// 				Provider: to.Ptr("Microsoft.ManagedNetworkFabric resource provider"),
		// 				Resource: to.Ptr("NetworkFabricControllers"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 			Origin: to.Ptr(armmanagednetworkfabric.OriginUserSystem),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.ManagedNetworkFabric/NetworkFabricControllers/Delete"),
		// 			ActionType: to.Ptr(armmanagednetworkfabric.ActionTypeInternal),
		// 			Display: &armmanagednetworkfabric.OperationDisplay{
		// 				Description: to.Ptr("Deletes the NetworkFabricController resource."),
		// 				Operation: to.Ptr("Deletes the NetworkFabricController resource."),
		// 				Provider: to.Ptr("Microsoft.ManagedNetworkFabric resource provider"),
		// 				Resource: to.Ptr("NetworkFabricControllers"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 			Origin: to.Ptr(armmanagednetworkfabric.OriginUserSystem),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OptionBLayer3Configuration 

type OptionBLayer3Configuration struct {
	// ASN of PE devices for CE/PE connectivity.Example : 28
	PeerASN *int64

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// VLAN for CE/PE Layer 3 connectivity.Example : 501
	VlanID *int32

	// READ-ONLY; ASN of CE devices for CE/PE connectivity.
	FabricASN *int64
}

OptionBLayer3Configuration - OptionB Layer3 Configuration properties.

func (OptionBLayer3Configuration) MarshalJSON 

func (o OptionBLayer3Configuration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OptionBLayer3Configuration.

func (*OptionBLayer3Configuration) UnmarshalJSON 

func (o *OptionBLayer3Configuration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OptionBLayer3Configuration.

type OptionBProperties 

type OptionBProperties struct {
	// Route Targets to be applied for outgoing routes from CE. This is for backward compatibility.
	ExportRouteTargets []*string

	// Route Targets to be applied for incoming routes into CE. This is for backward compatibility.
	ImportRouteTargets []*string

	// Route Targets to be applied.
	RouteTargets *RouteTargetInformation
}

OptionBProperties - Option B configuration to be used for Management VPN.

func (OptionBProperties) MarshalJSON 

func (o OptionBProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OptionBProperties.

func (*OptionBProperties) UnmarshalJSON 

func (o *OptionBProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OptionBProperties.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	OriginSystem     Origin = "system"
	OriginUser       Origin = "user"
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PeeringOption 

type PeeringOption string

PeeringOption - Peering option list. 

const (
	PeeringOptionOptionA PeeringOption = "OptionA"
	PeeringOptionOptionB PeeringOption = "OptionB"
)

func PossiblePeeringOptionValues 

func PossiblePeeringOptionValues() []PeeringOption

PossiblePeeringOptionValues returns the possible values for the PeeringOption const type.

type PollingIntervalInSeconds 

type PollingIntervalInSeconds int32

PollingIntervalInSeconds - Polling interval in seconds. 

const (
	PollingIntervalInSecondsNinety           PollingIntervalInSeconds = 90
	PollingIntervalInSecondsOneHundredTwenty PollingIntervalInSeconds = 120
	PollingIntervalInSecondsSixty            PollingIntervalInSeconds = 60
	PollingIntervalInSecondsThirty           PollingIntervalInSeconds = 30
)

func PossiblePollingIntervalInSecondsValues 

func PossiblePollingIntervalInSecondsValues() []PollingIntervalInSeconds

PossiblePollingIntervalInSecondsValues returns the possible values for the PollingIntervalInSeconds const type.

type PollingType 

type PollingType string

PollingType - Polling type. 

const (
	PollingTypePull PollingType = "Pull"
	PollingTypePush PollingType = "Push"
)

func PossiblePollingTypeValues 

func PossiblePollingTypeValues() []PollingType

PossiblePollingTypeValues returns the possible values for the PollingType const type.

type PortCondition 

type PortCondition struct {
	// REQUIRED; Layer4 protocol type that needs to be matched.
	Layer4Protocol *Layer4Protocol

	// List of the port Group Names that to be matched.
	PortGroupNames []*string

	// Port type that needs to be matched.
	PortType *PortType

	// List of the Ports that need to be matched.
	Ports []*string
}

PortCondition - Port condition that needs to be matched.

func (PortCondition) MarshalJSON 

func (p PortCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PortCondition.

func (*PortCondition) UnmarshalJSON 

func (p *PortCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PortCondition.

type PortGroupProperties 

type PortGroupProperties struct {
	// The name of the port group.
	Name *string

	// List of the ports that needs to be matched.
	Ports []*string
}

PortGroupProperties - Port Group properties.

func (PortGroupProperties) MarshalJSON 

func (p PortGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PortGroupProperties.

func (*PortGroupProperties) UnmarshalJSON 

func (p *PortGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PortGroupProperties.

type PortType 

type PortType string

PortType - Port type that needs to be matched. 

const (
	PortTypeDestinationPort PortType = "DestinationPort"
	PortTypeSourcePort      PortType = "SourcePort"
)

func PossiblePortTypeValues 

func PossiblePortTypeValues() []PortType

PossiblePortTypeValues returns the possible values for the PortType const type.

type PrefixType 

type PrefixType string

PrefixType - IP Prefix Type. 

const (
	PrefixTypeLongestPrefix PrefixType = "LongestPrefix"
	PrefixTypePrefix        PrefixType = "Prefix"
)

func PossiblePrefixTypeValues 

func PossiblePrefixTypeValues() []PrefixType

PossiblePrefixTypeValues returns the possible values for the PrefixType const type.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The current provisioning state. 

const (
	ProvisioningStateAccepted  ProvisioningState = "Accepted"
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	ProvisioningStateUpdating  ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type RebootProperties 

type RebootProperties struct {
	// Type of reboot to be performed. Example: GracefulRebootWithZTP
	RebootType *RebootType
}

RebootProperties - Reboot properties.

func (RebootProperties) MarshalJSON 

func (r RebootProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RebootProperties.

func (*RebootProperties) UnmarshalJSON 

func (r *RebootProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RebootProperties.

type RebootType 

type RebootType string

RebootType - Type of reboot to be performed. Example: GracefulRebootWithZTP 

const (
	RebootTypeGracefulRebootWithZTP      RebootType = "GracefulRebootWithZTP"
	RebootTypeGracefulRebootWithoutZTP   RebootType = "GracefulRebootWithoutZTP"
	RebootTypeUngracefulRebootWithZTP    RebootType = "UngracefulRebootWithZTP"
	RebootTypeUngracefulRebootWithoutZTP RebootType = "UngracefulRebootWithoutZTP"
)

func PossibleRebootTypeValues 

func PossibleRebootTypeValues() []RebootType

PossibleRebootTypeValues returns the possible values for the RebootType const type.

type RedistributeConnectedSubnets 

type RedistributeConnectedSubnets string

RedistributeConnectedSubnets - Advertise Connected Subnets. Ex: "True" | "False". 

const (
	RedistributeConnectedSubnetsFalse RedistributeConnectedSubnets = "False"
	RedistributeConnectedSubnetsTrue  RedistributeConnectedSubnets = "True"
)

func PossibleRedistributeConnectedSubnetsValues 

func PossibleRedistributeConnectedSubnetsValues() []RedistributeConnectedSubnets

PossibleRedistributeConnectedSubnetsValues returns the possible values for the RedistributeConnectedSubnets const type.

type RedistributeStaticRoutes 

type RedistributeStaticRoutes string

RedistributeStaticRoutes - Advertise Static Routes. Ex: "True" | "False". 

const (
	RedistributeStaticRoutesFalse RedistributeStaticRoutes = "False"
	RedistributeStaticRoutesTrue  RedistributeStaticRoutes = "True"
)

func PossibleRedistributeStaticRoutesValues 

func PossibleRedistributeStaticRoutesValues() []RedistributeStaticRoutes

PossibleRedistributeStaticRoutesValues returns the possible values for the RedistributeStaticRoutes const type.

type RoutePoliciesClient 

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

RoutePoliciesClient contains the methods for the RoutePolicies group. Don't use this type directly, use NewRoutePoliciesClient() instead.

func NewRoutePoliciesClient 

func NewRoutePoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*RoutePoliciesClient, error)

NewRoutePoliciesClient creates a new instance of RoutePoliciesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*RoutePoliciesClient) BeginCommitConfiguration 

func (client *RoutePoliciesClient) BeginCommitConfiguration(ctx context.Context, resourceGroupName string, routePolicyName string, options *RoutePoliciesClientBeginCommitConfigurationOptions) (*runtime.Poller[RoutePoliciesClientCommitConfigurationResponse], error)

BeginCommitConfiguration - Commits the configuration of the given resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • options - RoutePoliciesClientBeginCommitConfigurationOptions contains the optional parameters for the RoutePoliciesClient.BeginCommitConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_CommitConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewRoutePoliciesClient().BeginCommitConfiguration(ctx, "example-rg", "example-routePolicy", 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.CommonPostActionResponseForStateUpdate = armmanagednetworkfabric.CommonPostActionResponseForStateUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// }
}

Output:

func (*RoutePoliciesClient) BeginCreate 

func (client *RoutePoliciesClient) BeginCreate(ctx context.Context, resourceGroupName string, routePolicyName string, body RoutePolicy, options *RoutePoliciesClientBeginCreateOptions) (*runtime.Poller[RoutePoliciesClientCreateResponse], error)

BeginCreate - Implements Route Policy PUT method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • body - Request payload.
  • options - RoutePoliciesClientBeginCreateOptions contains the optional parameters for the RoutePoliciesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewRoutePoliciesClient().BeginCreate(ctx, "example-rg", "example-routePolicy", armmanagednetworkfabric.RoutePolicy{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.RoutePolicyProperties{
			Annotation: to.Ptr("annotation"),
			Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
				{
					Annotation: to.Ptr("annotation"),
					Action: &armmanagednetworkfabric.StatementActionProperties{
						ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
						IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
							Add: &armmanagednetworkfabric.IPCommunityIDList{
								IPCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
							},
							Delete: &armmanagednetworkfabric.IPCommunityIDList{
								IPCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
							},
							Set: &armmanagednetworkfabric.IPCommunityIDList{
								IPCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
							},
						},
						IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
							Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
								IPExtendedCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
							},
							Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
								IPExtendedCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
							},
							Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
								IPExtendedCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
							},
						},
						LocalPreference: to.Ptr[int64](20),
					},
					Condition: &armmanagednetworkfabric.StatementConditionProperties{
						IPCommunityIDs: []*string{
							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
						IPExtendedCommunityIDs: []*string{
							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
						Type:       to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
						IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
					},
					SequenceNumber: to.Ptr[int64](7),
				}},
			AddressFamilyType: to.Ptr(armmanagednetworkfabric.AddressFamilyTypeIPv4),
			NetworkFabricID:   to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		},
	}, 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.RoutePolicy = armmanagednetworkfabric.RoutePolicy{
	// 	Name: to.Ptr("example-routePolicy"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/routePolicies"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.RoutePolicyProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Action: &armmanagednetworkfabric.StatementActionProperties{
	// 					ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
	// 					IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
	// 						Add: &armmanagednetworkfabric.IPCommunityIDList{
	// 							IPCommunityIDs: []*string{
	// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 							},
	// 							Delete: &armmanagednetworkfabric.IPCommunityIDList{
	// 								IPCommunityIDs: []*string{
	// 									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 								},
	// 								Set: &armmanagednetworkfabric.IPCommunityIDList{
	// 									IPCommunityIDs: []*string{
	// 										to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 									},
	// 								},
	// 								IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
	// 									Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 										IPExtendedCommunityIDs: []*string{
	// 											to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 										},
	// 										Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 											IPExtendedCommunityIDs: []*string{
	// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 											},
	// 											Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 												IPExtendedCommunityIDs: []*string{
	// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 												},
	// 											},
	// 											LocalPreference: to.Ptr[int64](20),
	// 										},
	// 										Condition: &armmanagednetworkfabric.StatementConditionProperties{
	// 											IPCommunityIDs: []*string{
	// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 												IPExtendedCommunityIDs: []*string{
	// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 													Type: to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
	// 													IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
	// 												},
	// 												SequenceNumber: to.Ptr[int64](7),
	// 										}},
	// 										AddressFamilyType: to.Ptr(armmanagednetworkfabric.AddressFamilyTypeIPv4),
	// 										AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 										ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 										NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 										ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 									},
	// 								}
}

Output:

func (*RoutePoliciesClient) BeginDelete 

func (client *RoutePoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, routePolicyName string, options *RoutePoliciesClientBeginDeleteOptions) (*runtime.Poller[RoutePoliciesClientDeleteResponse], error)

BeginDelete - Implements Route Policy DELETE method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • options - RoutePoliciesClientBeginDeleteOptions contains the optional parameters for the RoutePoliciesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewRoutePoliciesClient().BeginDelete(ctx, "example-rg", "example-routePolicy", 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)
	}
}

Output:

func (*RoutePoliciesClient) BeginUpdate 

func (client *RoutePoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, routePolicyName string, body RoutePolicyPatch, options *RoutePoliciesClientBeginUpdateOptions) (*runtime.Poller[RoutePoliciesClientUpdateResponse], error)

BeginUpdate - API to update certain properties of the Route Policy resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • body - Route Policy properties to update.
  • options - RoutePoliciesClientBeginUpdateOptions contains the optional parameters for the RoutePoliciesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewRoutePoliciesClient().BeginUpdate(ctx, "example-rg", "example-routePolicy", armmanagednetworkfabric.RoutePolicyPatch{
		Tags: map[string]*string{
			"keyID": to.Ptr("keyValue"),
		},
		Properties: &armmanagednetworkfabric.RoutePolicyPatchableProperties{
			Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
				{
					Annotation: to.Ptr("annotation"),
					Action: &armmanagednetworkfabric.StatementActionProperties{
						ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
						IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
							Add: &armmanagednetworkfabric.IPCommunityIDList{
								IPCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
							},
							Delete: &armmanagednetworkfabric.IPCommunityIDList{
								IPCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
							},
							Set: &armmanagednetworkfabric.IPCommunityIDList{
								IPCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
							},
						},
						IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
							Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
								IPExtendedCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
							},
							Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
								IPExtendedCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
							},
							Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
								IPExtendedCommunityIDs: []*string{
									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
							},
						},
						LocalPreference: to.Ptr[int64](20),
					},
					Condition: &armmanagednetworkfabric.StatementConditionProperties{
						IPCommunityIDs: []*string{
							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
						IPExtendedCommunityIDs: []*string{
							to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
						Type:       to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
						IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
					},
					SequenceNumber: to.Ptr[int64](7),
				}},
		},
	}, 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.RoutePolicy = armmanagednetworkfabric.RoutePolicy{
	// 	Name: to.Ptr("example-routePolicy"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/routePolicies"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.RoutePolicyProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Action: &armmanagednetworkfabric.StatementActionProperties{
	// 					ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
	// 					IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
	// 						Add: &armmanagednetworkfabric.IPCommunityIDList{
	// 							IPCommunityIDs: []*string{
	// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 							},
	// 							Delete: &armmanagednetworkfabric.IPCommunityIDList{
	// 								IPCommunityIDs: []*string{
	// 									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 								},
	// 								Set: &armmanagednetworkfabric.IPCommunityIDList{
	// 									IPCommunityIDs: []*string{
	// 										to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 									},
	// 								},
	// 								IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
	// 									Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 										IPExtendedCommunityIDs: []*string{
	// 											to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 										},
	// 										Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 											IPExtendedCommunityIDs: []*string{
	// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 											},
	// 											Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 												IPExtendedCommunityIDs: []*string{
	// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 												},
	// 											},
	// 											LocalPreference: to.Ptr[int64](20),
	// 										},
	// 										Condition: &armmanagednetworkfabric.StatementConditionProperties{
	// 											IPCommunityIDs: []*string{
	// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 												IPExtendedCommunityIDs: []*string{
	// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 													Type: to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
	// 													IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
	// 												},
	// 												SequenceNumber: to.Ptr[int64](7),
	// 										}},
	// 										AddressFamilyType: to.Ptr(armmanagednetworkfabric.AddressFamilyTypeIPv4),
	// 										AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 										ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 										NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 										ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 									},
	// 								}
}

Output:

func (*RoutePoliciesClient) BeginUpdateAdministrativeState 

func (client *RoutePoliciesClient) BeginUpdateAdministrativeState(ctx context.Context, resourceGroupName string, routePolicyName string, body UpdateAdministrativeState, options *RoutePoliciesClientBeginUpdateAdministrativeStateOptions) (*runtime.Poller[RoutePoliciesClientUpdateAdministrativeStateResponse], error)

BeginUpdateAdministrativeState - Updated the admin state for this Route Policy. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • body - Request payload.
  • options - RoutePoliciesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the RoutePoliciesClient.BeginUpdateAdministrativeState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_UpdateAdministrativeState_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewRoutePoliciesClient().BeginUpdateAdministrativeState(ctx, "example-rg", "example-routePolicy", armmanagednetworkfabric.UpdateAdministrativeState{
		ResourceIDs: []*string{
			to.Ptr("")},
		State: to.Ptr(armmanagednetworkfabric.EnableDisableStateEnable),
	}, 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.CommonPostActionResponseForDeviceUpdate = armmanagednetworkfabric.CommonPostActionResponseForDeviceUpdate{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	FailedDevices: []*string{
	// 		to.Ptr("")},
	// 		SuccessfulDevices: []*string{
	// 			to.Ptr("")},
	// 		}
}

Output:

func (*RoutePoliciesClient) BeginValidateConfiguration 

func (client *RoutePoliciesClient) BeginValidateConfiguration(ctx context.Context, resourceGroupName string, routePolicyName string, options *RoutePoliciesClientBeginValidateConfigurationOptions) (*runtime.Poller[RoutePoliciesClientValidateConfigurationResponse], error)

BeginValidateConfiguration - Validates the configuration of the resources. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • options - RoutePoliciesClientBeginValidateConfigurationOptions contains the optional parameters for the RoutePoliciesClient.BeginValidateConfiguration method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_ValidateConfiguration_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewRoutePoliciesClient().BeginValidateConfiguration(ctx, "example-rg", "example-routePolicy", 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.ValidateConfigurationResponse = armmanagednetworkfabric.ValidateConfigurationResponse{
	// 	Error: &armmanagednetworkfabric.ErrorDetail{
	// 		AdditionalInfo: []*armmanagednetworkfabric.ErrorAdditionalInfo{
	// 			{
	// 				Info: map[string]any{
	// 				},
	// 				Type: to.Ptr(""),
	// 		}},
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 		Target: to.Ptr(""),
	// 		Details: []*armmanagednetworkfabric.ErrorDetail{
	// 		},
	// 	},
	// 	ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 	URL: to.Ptr("https://ValidateResultsUrl"),
	// }
}

Output:

func (*RoutePoliciesClient) Get 

func (client *RoutePoliciesClient) Get(ctx context.Context, resourceGroupName string, routePolicyName string, options *RoutePoliciesClientGetOptions) (RoutePoliciesClientGetResponse, error)

Get - Implements Route Policy GET method. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • routePolicyName - Name of the Route Policy.
  • options - RoutePoliciesClientGetOptions contains the optional parameters for the RoutePoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewRoutePoliciesClient().Get(ctx, "example-rg", "example-routePolicy", 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.RoutePolicy = armmanagednetworkfabric.RoutePolicy{
	// 	Name: to.Ptr("example-routePolicy"),
	// 	Type: to.Ptr("microsoft.managednetworkfabric/routePolicies"),
	// 	ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
	// 	SystemData: &armmanagednetworkfabric.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@mail.com"),
	// 		CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@mail.com"),
	// 		LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"keyID": to.Ptr("keyValue"),
	// 	},
	// 	Properties: &armmanagednetworkfabric.RoutePolicyProperties{
	// 		Annotation: to.Ptr("annotation"),
	// 		Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
	// 			{
	// 				Annotation: to.Ptr("annotation"),
	// 				Action: &armmanagednetworkfabric.StatementActionProperties{
	// 					ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
	// 					IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
	// 						Add: &armmanagednetworkfabric.IPCommunityIDList{
	// 							IPCommunityIDs: []*string{
	// 								to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 							},
	// 							Delete: &armmanagednetworkfabric.IPCommunityIDList{
	// 								IPCommunityIDs: []*string{
	// 									to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 								},
	// 								Set: &armmanagednetworkfabric.IPCommunityIDList{
	// 									IPCommunityIDs: []*string{
	// 										to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 									},
	// 								},
	// 								IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
	// 									Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 										IPExtendedCommunityIDs: []*string{
	// 											to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 										},
	// 										Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 											IPExtendedCommunityIDs: []*string{
	// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 											},
	// 											Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
	// 												IPExtendedCommunityIDs: []*string{
	// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 												},
	// 											},
	// 											LocalPreference: to.Ptr[int64](20),
	// 										},
	// 										Condition: &armmanagednetworkfabric.StatementConditionProperties{
	// 											IPCommunityIDs: []*string{
	// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
	// 												IPExtendedCommunityIDs: []*string{
	// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
	// 													Type: to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
	// 													IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
	// 												},
	// 												SequenceNumber: to.Ptr[int64](7),
	// 										}},
	// 										AddressFamilyType: to.Ptr(armmanagednetworkfabric.AddressFamilyTypeIPv4),
	// 										AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
	// 										ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
	// 										NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
	// 										ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
	// 									},
	// 								}
}

Output:

func (*RoutePoliciesClient) NewListByResourceGroupPager 

func (client *RoutePoliciesClient) NewListByResourceGroupPager(resourceGroupName string, options *RoutePoliciesClientListByResourceGroupOptions) *runtime.Pager[RoutePoliciesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Implements RoutePolicies list by resource group GET method.

Generated from API version 2023-06-15

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - RoutePoliciesClientListByResourceGroupOptions contains the optional parameters for the RoutePoliciesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewRoutePoliciesClient().NewListByResourceGroupPager("example-rg", 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.RoutePoliciesListResult = armmanagednetworkfabric.RoutePoliciesListResult{
		// 	Value: []*armmanagednetworkfabric.RoutePolicy{
		// 		{
		// 			Name: to.Ptr("example-routePolicy"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/routePolicies"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.RoutePolicyProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
		// 					{
		// 						Annotation: to.Ptr("annotation"),
		// 						Action: &armmanagednetworkfabric.StatementActionProperties{
		// 							ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
		// 							IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
		// 								Add: &armmanagednetworkfabric.IPCommunityIDList{
		// 									IPCommunityIDs: []*string{
		// 										to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 									},
		// 									Delete: &armmanagednetworkfabric.IPCommunityIDList{
		// 										IPCommunityIDs: []*string{
		// 											to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 										},
		// 										Set: &armmanagednetworkfabric.IPCommunityIDList{
		// 											IPCommunityIDs: []*string{
		// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 											},
		// 										},
		// 										IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
		// 											Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
		// 												IPExtendedCommunityIDs: []*string{
		// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 												},
		// 												Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
		// 													IPExtendedCommunityIDs: []*string{
		// 														to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 													},
		// 													Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
		// 														IPExtendedCommunityIDs: []*string{
		// 															to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 														},
		// 													},
		// 													LocalPreference: to.Ptr[int64](20),
		// 												},
		// 												Condition: &armmanagednetworkfabric.StatementConditionProperties{
		// 													IPCommunityIDs: []*string{
		// 														to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 														IPExtendedCommunityIDs: []*string{
		// 															to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 															Type: to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
		// 															IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
		// 														},
		// 														SequenceNumber: to.Ptr[int64](7),
		// 												}},
		// 												AddressFamilyType: to.Ptr(armmanagednetworkfabric.AddressFamilyTypeIPv4),
		// 												AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 												ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 												NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 												ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 											},
		// 									}},
		// 								}
	}
}

Output:

func (*RoutePoliciesClient) NewListBySubscriptionPager 

func (client *RoutePoliciesClient) NewListBySubscriptionPager(options *RoutePoliciesClientListBySubscriptionOptions) *runtime.Pager[RoutePoliciesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Implements RoutePolicies list by subscription GET method.

Generated from API version 2023-06-15

  • options - RoutePoliciesClientListBySubscriptionOptions contains the optional parameters for the RoutePoliciesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/925ba149e17454ce91ecd3f9f4134effb2f97844/specification/managednetworkfabric/resource-manager/Microsoft.ManagedNetworkFabric/stable/2023-06-15/examples/RoutePolicies_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managednetworkfabric/armmanagednetworkfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmanagednetworkfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewRoutePoliciesClient().NewListBySubscriptionPager(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.RoutePoliciesListResult = armmanagednetworkfabric.RoutePoliciesListResult{
		// 	Value: []*armmanagednetworkfabric.RoutePolicy{
		// 		{
		// 			Name: to.Ptr("example-routePolicy"),
		// 			Type: to.Ptr("microsoft.managednetworkfabric/routePolicies"),
		// 			ID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/routePolicies/example-routePolicy"),
		// 			SystemData: &armmanagednetworkfabric.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@mail.com"),
		// 				CreatedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-11T17:48:22.837Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@mail.com"),
		// 				LastModifiedByType: to.Ptr(armmanagednetworkfabric.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("eastus"),
		// 			Tags: map[string]*string{
		// 				"keyID": to.Ptr("keyValue"),
		// 			},
		// 			Properties: &armmanagednetworkfabric.RoutePolicyProperties{
		// 				Annotation: to.Ptr("annotation"),
		// 				Statements: []*armmanagednetworkfabric.RoutePolicyStatementProperties{
		// 					{
		// 						Annotation: to.Ptr("annotation"),
		// 						Action: &armmanagednetworkfabric.StatementActionProperties{
		// 							ActionType: to.Ptr(armmanagednetworkfabric.RoutePolicyActionTypePermit),
		// 							IPCommunityProperties: &armmanagednetworkfabric.ActionIPCommunityProperties{
		// 								Add: &armmanagednetworkfabric.IPCommunityIDList{
		// 									IPCommunityIDs: []*string{
		// 										to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 									},
		// 									Delete: &armmanagednetworkfabric.IPCommunityIDList{
		// 										IPCommunityIDs: []*string{
		// 											to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 										},
		// 										Set: &armmanagednetworkfabric.IPCommunityIDList{
		// 											IPCommunityIDs: []*string{
		// 												to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 											},
		// 										},
		// 										IPExtendedCommunityProperties: &armmanagednetworkfabric.ActionIPExtendedCommunityProperties{
		// 											Add: &armmanagednetworkfabric.IPExtendedCommunityIDList{
		// 												IPExtendedCommunityIDs: []*string{
		// 													to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 												},
		// 												Delete: &armmanagednetworkfabric.IPExtendedCommunityIDList{
		// 													IPExtendedCommunityIDs: []*string{
		// 														to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 													},
		// 													Set: &armmanagednetworkfabric.IPExtendedCommunityIDList{
		// 														IPExtendedCommunityIDs: []*string{
		// 															to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 														},
		// 													},
		// 													LocalPreference: to.Ptr[int64](20),
		// 												},
		// 												Condition: &armmanagednetworkfabric.StatementConditionProperties{
		// 													IPCommunityIDs: []*string{
		// 														to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipCommunities/example-ipCommunity")},
		// 														IPExtendedCommunityIDs: []*string{
		// 															to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipExtendedCommunities/example-ipExtendedCommunity")},
		// 															Type: to.Ptr(armmanagednetworkfabric.RoutePolicyConditionTypeOr),
		// 															IPPrefixID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/ipPrefixes/example-ipPrefix"),
		// 														},
		// 														SequenceNumber: to.Ptr[int64](7),
		// 												}},
		// 												AddressFamilyType: to.Ptr(armmanagednetworkfabric.AddressFamilyTypeIPv4),
		// 												AdministrativeState: to.Ptr(armmanagednetworkfabric.AdministrativeStateEnabled),
		// 												ConfigurationState: to.Ptr(armmanagednetworkfabric.ConfigurationStateSucceeded),
		// 												NetworkFabricID: to.Ptr("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourceGroups/example-rg/providers/Microsoft.ManagedNetworkFabric/networkFabrics/example-fabric"),
		// 												ProvisioningState: to.Ptr(armmanagednetworkfabric.ProvisioningStateSucceeded),
		// 											},
		// 									}},
		// 								}
	}
}

Output:

type RoutePoliciesClientBeginCommitConfigurationOptions 

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

RoutePoliciesClientBeginCommitConfigurationOptions contains the optional parameters for the RoutePoliciesClient.BeginCommitConfiguration method.

type RoutePoliciesClientBeginCreateOptions 

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

RoutePoliciesClientBeginCreateOptions contains the optional parameters for the RoutePoliciesClient.BeginCreate method.

type RoutePoliciesClientBeginDeleteOptions 

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

RoutePoliciesClientBeginDeleteOptions contains the optional parameters for the RoutePoliciesClient.BeginDelete method.

type RoutePoliciesClientBeginUpdateAdministrativeStateOptions 

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

RoutePoliciesClientBeginUpdateAdministrativeStateOptions contains the optional parameters for the RoutePoliciesClient.BeginUpdateAdministrativeState method.

type RoutePoliciesClientBeginUpdateOptions 

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

RoutePoliciesClientBeginUpdateOptions contains the optional parameters for the RoutePoliciesClient.BeginUpdate method.

type RoutePoliciesClientBeginValidateConfigurationOptions 

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

RoutePoliciesClientBeginValidateConfigurationOptions contains the optional parameters for the RoutePoliciesClient.BeginValidateConfiguration method.

type RoutePoliciesClientCommitConfigurationResponse 

type RoutePoliciesClientCommitConfigurationResponse struct {
	// Common response for the state updates.
	CommonPostActionResponseForStateUpdate
}

RoutePoliciesClientCommitConfigurationResponse contains the response from method RoutePoliciesClient.BeginCommitConfiguration.

type RoutePoliciesClientCreateResponse 

type RoutePoliciesClientCreateResponse struct {
	// The RoutePolicy resource definition.
	RoutePolicy
}

RoutePoliciesClientCreateResponse contains the response from method RoutePoliciesClient.BeginCreate.

type RoutePoliciesClientDeleteResponse 

type RoutePoliciesClientDeleteResponse struct {
}

RoutePoliciesClientDeleteResponse contains the response from method RoutePoliciesClient.BeginDelete.

type RoutePoliciesClientGetOptions 

type RoutePoliciesClientGetOptions struct {
}

RoutePoliciesClientGetOptions contains the optional parameters for the RoutePoliciesClient.Get method.

type RoutePoliciesClientGetResponse 

type RoutePoliciesClientGetResponse struct {
	// The RoutePolicy resource definition.
	RoutePolicy
}

RoutePoliciesClientGetResponse contains the response from method RoutePoliciesClient.Get.

type RoutePoliciesClientListByResourceGroupOptions 

type RoutePoliciesClientListByResourceGroupOptions struct {
}

RoutePoliciesClientListByResourceGroupOptions contains the optional parameters for the RoutePoliciesClient.NewListByResourceGroupPager method.

type RoutePoliciesClientListByResourceGroupResponse 

type RoutePoliciesClientListByResourceGroupResponse struct {
	// List of RoutePolicies.
	RoutePoliciesListResult
}

RoutePoliciesClientListByResourceGroupResponse contains the response from method RoutePoliciesClient.NewListByResourceGroupPager.

type RoutePoliciesClientListBySubscriptionOptions 

type RoutePoliciesClientListBySubscriptionOptions struct {
}

RoutePoliciesClientListBySubscriptionOptions contains the optional parameters for the RoutePoliciesClient.NewListBySubscriptionPager method.

type RoutePoliciesClientListBySubscriptionResponse 

type RoutePoliciesClientListBySubscriptionResponse struct {
	// List of RoutePolicies.
	RoutePoliciesListResult
}

RoutePoliciesClientListBySubscriptionResponse contains the response from method RoutePoliciesClient.NewListBySubscriptionPager.

type RoutePoliciesClientUpdateAdministrativeStateResponse 

type RoutePoliciesClientUpdateAdministrativeStateResponse struct {
	// Common response for device updates.
	CommonPostActionResponseForDeviceUpdate
}

RoutePoliciesClientUpdateAdministrativeStateResponse contains the response from method RoutePoliciesClient.BeginUpdateAdministrativeState.

type RoutePoliciesClientUpdateResponse 

type RoutePoliciesClientUpdateResponse struct {
	// The RoutePolicy resource definition.
	RoutePolicy
}

RoutePoliciesClientUpdateResponse contains the response from method RoutePoliciesClient.BeginUpdate.

type RoutePoliciesClientValidateConfigurationResponse 

type RoutePoliciesClientValidateConfigurationResponse struct {
	// The response of the action validate configuration.
	ValidateConfigurationResponse
}

RoutePoliciesClientValidateConfigurationResponse contains the response from method RoutePoliciesClient.BeginValidateConfiguration.

type RoutePoliciesListResult 

type RoutePoliciesListResult struct {
	// Url to follow for getting next page of resources.
	NextLink *string

	// List of RoutePolicy resources.
	Value []*RoutePolicy
}

RoutePoliciesListResult - List of RoutePolicies.

func (RoutePoliciesListResult) MarshalJSON 

func (r RoutePoliciesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutePoliciesListResult.

func (*RoutePoliciesListResult) UnmarshalJSON 

func (r *RoutePoliciesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutePoliciesListResult.

type RoutePolicy 

type RoutePolicy struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Resource properties.
	Properties *RoutePolicyProperties

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

RoutePolicy - The RoutePolicy resource definition.

func (RoutePolicy) MarshalJSON 

func (r RoutePolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutePolicy.

func (*RoutePolicy) UnmarshalJSON 

func (r *RoutePolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutePolicy.

type RoutePolicyActionType 

type RoutePolicyActionType string

RoutePolicyActionType - Action type. Example: Permit | Deny | Continue. 

const (
	RoutePolicyActionTypeContinue RoutePolicyActionType = "Continue"
	RoutePolicyActionTypeDeny     RoutePolicyActionType = "Deny"
	RoutePolicyActionTypePermit   RoutePolicyActionType = "Permit"
)

func PossibleRoutePolicyActionTypeValues 

func PossibleRoutePolicyActionTypeValues() []RoutePolicyActionType

PossibleRoutePolicyActionTypeValues returns the possible values for the RoutePolicyActionType const type.

type RoutePolicyConditionType 

type RoutePolicyConditionType string

RoutePolicyConditionType - Type of the condition used. 

const (
	RoutePolicyConditionTypeAnd RoutePolicyConditionType = "And"
	RoutePolicyConditionTypeOr  RoutePolicyConditionType = "Or"
)

func PossibleRoutePolicyConditionTypeValues 

func PossibleRoutePolicyConditionTypeValues() []RoutePolicyConditionType

PossibleRoutePolicyConditionTypeValues returns the possible values for the RoutePolicyConditionType const type.

type RoutePolicyPatch 

type RoutePolicyPatch struct {
	// The RoutePolicy patchable properties.
	Properties *RoutePolicyPatchableProperties

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

RoutePolicyPatch - The Route Policy patch resource definition.

func (RoutePolicyPatch) MarshalJSON 

func (r RoutePolicyPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutePolicyPatch.

func (*RoutePolicyPatch) UnmarshalJSON 

func (r *RoutePolicyPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutePolicyPatch.

type RoutePolicyPatchableProperties 

type RoutePolicyPatchableProperties struct {
	// Route Policy statements.
	Statements []*RoutePolicyStatementProperties
}

RoutePolicyPatchableProperties - Route Policy patchable properties.

func (RoutePolicyPatchableProperties) MarshalJSON 

func (r RoutePolicyPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutePolicyPatchableProperties.

func (*RoutePolicyPatchableProperties) UnmarshalJSON 

func (r *RoutePolicyPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutePolicyPatchableProperties.

type RoutePolicyProperties 

type RoutePolicyProperties struct {
	// REQUIRED; Arm Resource ID of Network Fabric.
	NetworkFabricID *string

	// AddressFamilyType. This parameter decides whether the given ipv4 or ipv6 route policy.
	AddressFamilyType *AddressFamilyType

	// Switch configuration description.
	Annotation *string

	// Route Policy statements.
	Statements []*RoutePolicyStatementProperties

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState

	// READ-ONLY; Configuration state of the resource.
	ConfigurationState *ConfigurationState

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ProvisioningState
}

RoutePolicyProperties defines the resource properties.

func (RoutePolicyProperties) MarshalJSON 

func (r RoutePolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutePolicyProperties.

func (*RoutePolicyProperties) UnmarshalJSON 

func (r *RoutePolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutePolicyProperties.

type RoutePolicyStatementProperties 

type RoutePolicyStatementProperties struct {
	// REQUIRED; Route policy action properties.
	Action *StatementActionProperties

	// REQUIRED; Route policy condition properties.
	Condition *StatementConditionProperties

	// REQUIRED; Sequence to insert to/delete from existing route.
	SequenceNumber *int64

	// Switch configuration description.
	Annotation *string
}

RoutePolicyStatementProperties - Route Policy Statement properties.

func (RoutePolicyStatementProperties) MarshalJSON 

func (r RoutePolicyStatementProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RoutePolicyStatementProperties.

func (*RoutePolicyStatementProperties) UnmarshalJSON 

func (r *RoutePolicyStatementProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RoutePolicyStatementProperties.

type RouteTargetInformation 

type RouteTargetInformation struct {
	// Route Targets to be applied for outgoing routes into CE.
	ExportIPv4RouteTargets []*string

	// Route Targets to be applied for outgoing routes from CE.
	ExportIPv6RouteTargets []*string

	// Route Targets to be applied for incoming routes into CE.
	ImportIPv4RouteTargets []*string

	// Route Targets to be applied for incoming routes from CE.
	ImportIPv6RouteTargets []*string
}

RouteTargetInformation - Route Target Configuration.

func (RouteTargetInformation) MarshalJSON 

func (r RouteTargetInformation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RouteTargetInformation.

func (*RouteTargetInformation) UnmarshalJSON 

func (r *RouteTargetInformation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RouteTargetInformation.

type RuleProperties 

type RuleProperties struct {
	// REQUIRED; Specify action.
	Action *Action

	// REQUIRED; List of Addresses to be allowed or denied.
	AddressList []*string
}

RuleProperties - Rules for the InternetGateways

func (RuleProperties) MarshalJSON 

func (r RuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RuleProperties.

func (*RuleProperties) UnmarshalJSON 

func (r *RuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RuleProperties.

type SourceDestinationType 

type SourceDestinationType string

SourceDestinationType - IP Address type. 

const (
	SourceDestinationTypeDestinationIP SourceDestinationType = "DestinationIP"
	SourceDestinationTypeSourceIP      SourceDestinationType = "SourceIP"
)

func PossibleSourceDestinationTypeValues 

func PossibleSourceDestinationTypeValues() []SourceDestinationType

PossibleSourceDestinationTypeValues returns the possible values for the SourceDestinationType const type.

type StatementActionProperties 

type StatementActionProperties struct {
	// REQUIRED; Action type. Example: Permit | Deny | Continue.
	ActionType *RoutePolicyActionType

	// IP Community Properties.
	IPCommunityProperties *ActionIPCommunityProperties

	// IP Extended Community Properties.
	IPExtendedCommunityProperties *ActionIPExtendedCommunityProperties

	// Local Preference of the route policy.
	LocalPreference *int64
}

StatementActionProperties - Route policy action properties.

func (StatementActionProperties) MarshalJSON 

func (s StatementActionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StatementActionProperties.

func (*StatementActionProperties) UnmarshalJSON 

func (s *StatementActionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StatementActionProperties.

type StatementConditionProperties 

type StatementConditionProperties struct {
	// List of IP Community resource IDs.
	IPCommunityIDs []*string

	// List of IP Extended Community resource IDs.
	IPExtendedCommunityIDs []*string

	// Arm Resource Id of IpPrefix.
	IPPrefixID *string

	// Type of the condition used.
	Type *RoutePolicyConditionType
}

StatementConditionProperties - Route policy statement condition properties.

func (StatementConditionProperties) MarshalJSON 

func (s StatementConditionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StatementConditionProperties.

func (*StatementConditionProperties) UnmarshalJSON 

func (s *StatementConditionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StatementConditionProperties.

type StaticRouteConfiguration 

type StaticRouteConfiguration struct {
	// BFD configuration properties
	BfdConfiguration *BfdConfiguration

	// List of IPv4 Routes.
	IPv4Routes []*StaticRouteProperties

	// List of IPv6 Routes.
	IPv6Routes []*StaticRouteProperties
}

StaticRouteConfiguration - Static Route Configuration properties.

func (StaticRouteConfiguration) MarshalJSON 

func (s StaticRouteConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StaticRouteConfiguration.

func (*StaticRouteConfiguration) UnmarshalJSON 

func (s *StaticRouteConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StaticRouteConfiguration.

type StaticRouteProperties 

type StaticRouteProperties struct {
	// REQUIRED; List of next hop addresses.
	NextHop []*string

	// REQUIRED; Prefix of the route.
	Prefix *string
}

StaticRouteProperties - Route Properties.

func (StaticRouteProperties) MarshalJSON 

func (s StaticRouteProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StaticRouteProperties.

func (*StaticRouteProperties) UnmarshalJSON 

func (s *StaticRouteProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StaticRouteProperties.

type SupportedConnectorProperties 

type SupportedConnectorProperties struct {
	// Type of connector used. Example: Optical.
	ConnectorType *string

	// Maximum speed of the connector in Mbps.
	MaxSpeedInMbps *int32
}

SupportedConnectorProperties - Supported connector properties.

func (SupportedConnectorProperties) MarshalJSON 

func (s SupportedConnectorProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SupportedConnectorProperties.

func (*SupportedConnectorProperties) UnmarshalJSON 

func (s *SupportedConnectorProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedConnectorProperties.

type SupportedVersionProperties 

type SupportedVersionProperties struct {
	// If true newly provisioned Fabric will use this device version by default to bootstrap the network devices for the first
	// time.
	IsDefault *BooleanEnumProperty

	// Firmware version.
	VendorFirmwareVersion *string

	// Operating system version.
	VendorOsVersion *string

	// Operating system and firmware combined versions.
	Version *string
}

SupportedVersionProperties - Supported version details of the network device.

func (SupportedVersionProperties) MarshalJSON 

func (s SupportedVersionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SupportedVersionProperties.

func (*SupportedVersionProperties) UnmarshalJSON 

func (s *SupportedVersionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SupportedVersionProperties.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TagsUpdate 

type TagsUpdate struct {
	// Resource tags
	Tags map[string]*string
}

TagsUpdate - Base tracked resource type for PATCH updates.

func (TagsUpdate) MarshalJSON 

func (t TagsUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagsUpdate.

func (*TagsUpdate) UnmarshalJSON 

func (t *TagsUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TagsUpdate.

type TapRuleActionType 

type TapRuleActionType string

TapRuleActionType - Type of actions that can be performed. 

const (
	TapRuleActionTypeCount     TapRuleActionType = "Count"
	TapRuleActionTypeDrop      TapRuleActionType = "Drop"
	TapRuleActionTypeGoto      TapRuleActionType = "Goto"
	TapRuleActionTypeLog       TapRuleActionType = "Log"
	TapRuleActionTypeMirror    TapRuleActionType = "Mirror"
	TapRuleActionTypeRedirect  TapRuleActionType = "Redirect"
	TapRuleActionTypeReplicate TapRuleActionType = "Replicate"
)

func PossibleTapRuleActionTypeValues 

func PossibleTapRuleActionTypeValues() []TapRuleActionType

PossibleTapRuleActionTypeValues returns the possible values for the TapRuleActionType const type.

type TerminalServerConfiguration 

type TerminalServerConfiguration struct {
	// Password for the terminal server connection.
	Password *string

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// Serial Number of Terminal server.
	SerialNumber *string

	// Username for the terminal server connection.
	Username *string

	// READ-ONLY; ARM Resource ID used for the NetworkDevice.
	NetworkDeviceID *string
}

TerminalServerConfiguration - Network and credentials configuration currently applied to terminal server.

func (TerminalServerConfiguration) MarshalJSON 

func (t TerminalServerConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TerminalServerConfiguration.

func (*TerminalServerConfiguration) UnmarshalJSON 

func (t *TerminalServerConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TerminalServerConfiguration.

type UpdateAdministrativeState 

type UpdateAdministrativeState struct {
	// Network Fabrics or Network Rack resource Id.
	ResourceIDs []*string

	// Administrative state.
	State *EnableDisableState
}

UpdateAdministrativeState - Update administrative state on list of resources.

func (UpdateAdministrativeState) MarshalJSON 

func (u UpdateAdministrativeState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdateAdministrativeState.

func (*UpdateAdministrativeState) UnmarshalJSON 

func (u *UpdateAdministrativeState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateAdministrativeState.

type UpdateDeviceAdministrativeState 

type UpdateDeviceAdministrativeState struct {
	// Network Fabrics or Network Rack resource Id.
	ResourceIDs []*string

	// Administrative state.
	State *DeviceAdministrativeState
}

UpdateDeviceAdministrativeState - Update the administrative state on list of resources.

func (UpdateDeviceAdministrativeState) MarshalJSON 

func (u UpdateDeviceAdministrativeState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdateDeviceAdministrativeState.

func (*UpdateDeviceAdministrativeState) UnmarshalJSON 

func (u *UpdateDeviceAdministrativeState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDeviceAdministrativeState.

type UpdateVersion 

type UpdateVersion struct {
	// Specify the version.
	Version *string
}

UpdateVersion - Update version properties.

func (UpdateVersion) MarshalJSON 

func (u UpdateVersion) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdateVersion.

func (*UpdateVersion) UnmarshalJSON 

func (u *UpdateVersion) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateVersion.

type VPNConfigurationPatchableProperties 

type VPNConfigurationPatchableProperties struct {
	// ARM Resource ID of the Network To Network Interconnect.
	NetworkToNetworkInterconnectID *string

	// option A properties
	OptionAProperties *VPNConfigurationPatchablePropertiesOptionAProperties

	// option B properties
	OptionBProperties *OptionBProperties

	// Peering option list.
	PeeringOption *PeeringOption
}

VPNConfigurationPatchableProperties - Network and credential configuration currently applied on terminal server.

func (VPNConfigurationPatchableProperties) MarshalJSON 

func (v VPNConfigurationPatchableProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VPNConfigurationPatchableProperties.

func (*VPNConfigurationPatchableProperties) UnmarshalJSON 

func (v *VPNConfigurationPatchableProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VPNConfigurationPatchableProperties.

type VPNConfigurationPatchablePropertiesOptionAProperties 

type VPNConfigurationPatchablePropertiesOptionAProperties struct {
	// BFD Configuration properties.
	BfdConfiguration *BfdConfiguration

	// MTU to use for option A peering.
	Mtu *int32

	// Peer ASN number.Example : 28
	PeerASN *int64

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// Vlan Id.Example : 501
	VlanID *int32
}

VPNConfigurationPatchablePropertiesOptionAProperties - option A properties

func (VPNConfigurationPatchablePropertiesOptionAProperties) MarshalJSON 

func (v VPNConfigurationPatchablePropertiesOptionAProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VPNConfigurationPatchablePropertiesOptionAProperties.

func (*VPNConfigurationPatchablePropertiesOptionAProperties) UnmarshalJSON 

func (v *VPNConfigurationPatchablePropertiesOptionAProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VPNConfigurationPatchablePropertiesOptionAProperties.

type VPNConfigurationProperties 

type VPNConfigurationProperties struct {
	// REQUIRED; Peering option list.
	PeeringOption *PeeringOption

	// ARM Resource ID of the Network To Network Interconnect.
	NetworkToNetworkInterconnectID *string

	// option A properties
	OptionAProperties *VPNConfigurationPropertiesOptionAProperties

	// option B properties
	OptionBProperties *OptionBProperties

	// READ-ONLY; Administrative state of the resource.
	AdministrativeState *AdministrativeState
}

VPNConfigurationProperties - Network and credential configuration currently applied on terminal server.

func (VPNConfigurationProperties) MarshalJSON 

func (v VPNConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VPNConfigurationProperties.

func (*VPNConfigurationProperties) UnmarshalJSON 

func (v *VPNConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VPNConfigurationProperties.

type VPNConfigurationPropertiesOptionAProperties 

type VPNConfigurationPropertiesOptionAProperties struct {
	// BFD Configuration properties.
	BfdConfiguration *BfdConfiguration

	// MTU to use for option A peering.
	Mtu *int32

	// Peer ASN number.Example : 28
	PeerASN *int64

	// IPv4 Address Prefix.
	PrimaryIPv4Prefix *string

	// IPv6 Address Prefix.
	PrimaryIPv6Prefix *string

	// Secondary IPv4 Address Prefix.
	SecondaryIPv4Prefix *string

	// Secondary IPv6 Address Prefix.
	SecondaryIPv6Prefix *string

	// Vlan Id.Example : 501
	VlanID *int32
}

VPNConfigurationPropertiesOptionAProperties - option A properties

func (VPNConfigurationPropertiesOptionAProperties) MarshalJSON 

func (v VPNConfigurationPropertiesOptionAProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VPNConfigurationPropertiesOptionAProperties.

func (*VPNConfigurationPropertiesOptionAProperties) UnmarshalJSON 

func (v *VPNConfigurationPropertiesOptionAProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VPNConfigurationPropertiesOptionAProperties.

type ValidateAction 

type ValidateAction string

ValidateAction - Validate action that to be performed 

const (
	ValidateActionCabling       ValidateAction = "Cabling"
	ValidateActionConfiguration ValidateAction = "Configuration"
	ValidateActionConnectivity  ValidateAction = "Connectivity"
)

func PossibleValidateActionValues 

func PossibleValidateActionValues() []ValidateAction

PossibleValidateActionValues returns the possible values for the ValidateAction const type.

type ValidateConfigurationProperties 

type ValidateConfigurationProperties struct {
	// Validate action that to be performed
	ValidateAction *ValidateAction
}

ValidateConfigurationProperties - Validation configuration properties.

func (ValidateConfigurationProperties) MarshalJSON 

func (v ValidateConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateConfigurationProperties.

func (*ValidateConfigurationProperties) UnmarshalJSON 

func (v *ValidateConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateConfigurationProperties.

type ValidateConfigurationResponse 

type ValidateConfigurationResponse struct {
	// The error object.
	Error *ErrorDetail

	// URL for the details of the response.
	URL *string

	// READ-ONLY; Gets the configuration state.
	ConfigurationState *ConfigurationState
}

ValidateConfigurationResponse - The response of the action validate configuration.

func (ValidateConfigurationResponse) MarshalJSON 

func (v ValidateConfigurationResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateConfigurationResponse.

func (*ValidateConfigurationResponse) UnmarshalJSON 

func (v *ValidateConfigurationResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateConfigurationResponse.

type VlanGroupProperties 

type VlanGroupProperties struct {
	// Vlan group name.
	Name *string

	// List of vlans.
	Vlans []*string
}

VlanGroupProperties - Vlan group properties.

func (VlanGroupProperties) MarshalJSON 

func (v VlanGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VlanGroupProperties.

func (*VlanGroupProperties) UnmarshalJSON 

func (v *VlanGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VlanGroupProperties.

type VlanMatchCondition 

type VlanMatchCondition struct {
	// List of inner vlans that needs to be matched.
	InnerVlans []*string

	// List of vlan group names that to be matched.
	VlanGroupNames []*string

	// List of vlans that needs to be matched.
	Vlans []*string
}

VlanMatchCondition - The vlan match conditions that needs to be matched.

func (VlanMatchCondition) MarshalJSON 

func (v VlanMatchCondition) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VlanMatchCondition.

func (*VlanMatchCondition) UnmarshalJSON 

func (v *VlanMatchCondition) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VlanMatchCondition.

type WellKnownCommunities 

type WellKnownCommunities string

WellKnownCommunities - Internet - Advertise routes to internet community. LocalAS - Advertise routes to only localAS peers. NoAdvertise - Don't advertise routes to any peer.NoExport - Don't export to next AS.GShut - Graceful Shutdown (GSHUT) withdraw routes before terminating BGP connection. 

const (
	WellKnownCommunitiesGShut       WellKnownCommunities = "GShut"
	WellKnownCommunitiesInternet    WellKnownCommunities = "Internet"
	WellKnownCommunitiesLocalAS     WellKnownCommunities = "LocalAS"
	WellKnownCommunitiesNoAdvertise WellKnownCommunities = "NoAdvertise"
	WellKnownCommunitiesNoExport    WellKnownCommunities = "NoExport"
)

func PossibleWellKnownCommunitiesValues 

func PossibleWellKnownCommunitiesValues() []WellKnownCommunities

PossibleWellKnownCommunitiesValues returns the possible values for the WellKnownCommunities const type.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.