armavs

package module

v2.3.0 Latest Latest Go to latest Published: Sep 15, 2026 License: MIT Imports: 14 Imported by: 1

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/Azure/azure-sdk-for-go

Links

Open Source Insights

README ¶

Azure VMware Solution Module for Go

The armavs module provides operations for working with Azure VMware Solution.

Source code

Getting started

Prerequisites

an Azure subscription
Supported version of Go (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 VMware Solution module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure VMware Solution. 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 VMware 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 := armavs.NewClientFactory(, cred, nil)

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

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armavs.NewClientFactory(, 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.NewAddonsClient()

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 VMware Solution 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 ActionType ¶

type ActionType string

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

const (
	// ActionTypeInternal - Actions are for internal-only APIs.
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues ¶

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type Addon ¶

type Addon struct {
	// The resource-specific properties for this resource.
	Properties AddonPropertiesClassification

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

Addon - An addon resource

func (Addon) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type Addon.

func (*Addon) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type Addon.

type AddonArcProperties ¶

type AddonArcProperties struct {
	// CONSTANT; The type of private cloud addon
	// Field has constant value AddonTypeArc, any specified value is ignored.
	AddonType *AddonType

	// The VMware vCenter resource ID
	VCenter *string

	// READ-ONLY; The state of the addon provisioning
	ProvisioningState *AddonProvisioningState
}

AddonArcProperties - The properties of an Arc addon

func (*AddonArcProperties) GetAddonProperties ¶

func (a *AddonArcProperties) GetAddonProperties() *AddonProperties

GetAddonProperties implements the AddonPropertiesClassification interface for type AddonArcProperties.

func (AddonArcProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AddonArcProperties.

func (*AddonArcProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddonArcProperties.

type AddonHcxProperties ¶

type AddonHcxProperties struct {
	// CONSTANT; The type of private cloud addon
	// Field has constant value AddonTypeHCX, any specified value is ignored.
	AddonType *AddonType

	// REQUIRED; The HCX offer, example VMware MaaS Cloud Provider (Enterprise)
	Offer *string

	// HCX management network.
	ManagementNetwork *string

	// HCX uplink network
	UplinkNetwork *string

	// READ-ONLY; The state of the addon provisioning
	ProvisioningState *AddonProvisioningState
}

AddonHcxProperties - The properties of an HCX addon

func (*AddonHcxProperties) GetAddonProperties ¶

func (a *AddonHcxProperties) GetAddonProperties() *AddonProperties

GetAddonProperties implements the AddonPropertiesClassification interface for type AddonHcxProperties.

func (AddonHcxProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AddonHcxProperties.

func (*AddonHcxProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddonHcxProperties.

type AddonList ¶

type AddonList struct {
	// REQUIRED; The Addon items on this page
	Value []*Addon

	// The link to the next page of items
	NextLink *string
}

AddonList - The response of a Addon list operation.

func (AddonList) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AddonList.

func (*AddonList) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddonList.

type AddonProperties ¶

type AddonProperties struct {
	// REQUIRED; Addon type
	AddonType *AddonType

	// READ-ONLY; The state of the addon provisioning
	ProvisioningState *AddonProvisioningState
}

AddonProperties - The properties of an addon

func (*AddonProperties) GetAddonProperties ¶

func (a *AddonProperties) GetAddonProperties() *AddonProperties

GetAddonProperties implements the AddonPropertiesClassification interface for type AddonProperties.

func (AddonProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AddonProperties.

func (*AddonProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddonProperties.

type AddonPropertiesClassification ¶

type AddonPropertiesClassification interface {
	// GetAddonProperties returns the AddonProperties content of the underlying type.
	GetAddonProperties() *AddonProperties
}

AddonPropertiesClassification provides polymorphic access to related types. Call the interface's GetAddonProperties() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AddonArcProperties, *AddonHcxProperties, *AddonProperties, *AddonSrmProperties, *AddonVrProperties

type AddonProvisioningState ¶

type AddonProvisioningState string

AddonProvisioningState - Addon provisioning state

const (
	// AddonProvisioningStateBuilding - is building
	AddonProvisioningStateBuilding AddonProvisioningState = "Building"
	// AddonProvisioningStateCanceled - Resource creation was canceled.
	AddonProvisioningStateCanceled AddonProvisioningState = "Canceled"
	// AddonProvisioningStateCancelled - is cancelled
	AddonProvisioningStateCancelled AddonProvisioningState = "Cancelled"
	// AddonProvisioningStateDeleting - is deleting
	AddonProvisioningStateDeleting AddonProvisioningState = "Deleting"
	// AddonProvisioningStateFailed - Resource creation failed.
	AddonProvisioningStateFailed AddonProvisioningState = "Failed"
	// AddonProvisioningStateSucceeded - Resource has been created.
	AddonProvisioningStateSucceeded AddonProvisioningState = "Succeeded"
	// AddonProvisioningStateUpdating - is updating
	AddonProvisioningStateUpdating AddonProvisioningState = "Updating"
)

func PossibleAddonProvisioningStateValues ¶

func PossibleAddonProvisioningStateValues() []AddonProvisioningState

PossibleAddonProvisioningStateValues returns the possible values for the AddonProvisioningState const type.

type AddonSrmProperties ¶

type AddonSrmProperties struct {
	// CONSTANT; The type of private cloud addon
	// Field has constant value AddonTypeSRM, any specified value is ignored.
	AddonType *AddonType

	// The Site Recovery Manager (SRM) license
	LicenseKey *string

	// READ-ONLY; The state of the addon provisioning
	ProvisioningState *AddonProvisioningState
}

AddonSrmProperties - The properties of a Site Recovery Manager (SRM) addon

func (*AddonSrmProperties) GetAddonProperties ¶

func (a *AddonSrmProperties) GetAddonProperties() *AddonProperties

GetAddonProperties implements the AddonPropertiesClassification interface for type AddonSrmProperties.

func (AddonSrmProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AddonSrmProperties.

func (*AddonSrmProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddonSrmProperties.

type AddonType ¶

type AddonType string

AddonType - Addon type

const (
	AddonTypeArc AddonType = "Arc"
	AddonTypeHCX AddonType = "HCX"
	AddonTypeSRM AddonType = "SRM"
	AddonTypeVR  AddonType = "VR"
)

func PossibleAddonTypeValues ¶

func PossibleAddonTypeValues() []AddonType

PossibleAddonTypeValues returns the possible values for the AddonType const type.

type AddonVrProperties ¶

type AddonVrProperties struct {
	// CONSTANT; The type of private cloud addon
	// Field has constant value AddonTypeVR, any specified value is ignored.
	AddonType *AddonType

	// REQUIRED; The vSphere Replication Server (VRS) count
	VrsCount *int32

	// READ-ONLY; The state of the addon provisioning
	ProvisioningState *AddonProvisioningState
}

AddonVrProperties - The properties of a vSphere Replication (VR) addon

func (*AddonVrProperties) GetAddonProperties ¶

func (a *AddonVrProperties) GetAddonProperties() *AddonProperties

GetAddonProperties implements the AddonPropertiesClassification interface for type AddonVrProperties.

func (AddonVrProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AddonVrProperties.

func (*AddonVrProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddonVrProperties.

type AddonsClient ¶

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

AddonsClient contains the methods for the Addons group. Don't use this type directly, use NewAddonsClient() instead.

Generated from API version 2026-03-01

func NewAddonsClient ¶

func NewAddonsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AddonsClient, error)

NewAddonsClient creates a new instance of AddonsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*AddonsClient) BeginCreateOrUpdate ¶

func (client *AddonsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, addonName string, addon Addon, options *AddonsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AddonsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a Addon If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
addonName - Name of the addon.
addon - Resource create parameters.
options - AddonsClientBeginCreateOrUpdateOptions contains the optional parameters for the AddonsClient.BeginCreateOrUpdate method.

Example (AddonsCreateOrUpdateArcReg) ¶

Generated from example definition: 2026-03-01/Addons_CreateOrUpdate_ArcReg.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAddonsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "arc", armavs.Addon{
		Properties: &armavs.AddonArcProperties{
			AddonType: to.Ptr(armavs.AddonTypeArc),
			VCenter:   to.Ptr("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg_test/providers/Microsoft.ConnectedVMwarevSphere/VCenters/test-vcenter"),
		},
	}, 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 poll 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 = armavs.AddonsClientCreateOrUpdateResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/arc"),
	// 		Name: to.Ptr("arc"),
	// 		Properties: &armavs.AddonArcProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeArc),
	// 			VCenter: to.Ptr("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg_test/providers/Microsoft.ConnectedVMwarevSphere/VCenters/test-vcenter"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsCreateOrUpdateHcx) ¶

Generated from example definition: 2026-03-01/Addons_CreateOrUpdate_HCX.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAddonsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "hcx", armavs.Addon{
		Properties: &armavs.AddonHcxProperties{
			AddonType: to.Ptr(armavs.AddonTypeHCX),
			Offer:     to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
		},
	}, 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 poll 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 = armavs.AddonsClientCreateOrUpdateResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/hcx"),
	// 		Name: to.Ptr("hcx"),
	// 		Properties: &armavs.AddonHcxProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeHCX),
	// 			Offer: to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsCreateOrUpdateHcxWithNetworks) ¶

Generated from example definition: 2026-03-01/Addons_CreateOrUpdate_HCX_With_Networks.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAddonsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "hcx", armavs.Addon{
		Properties: &armavs.AddonHcxProperties{
			AddonType:         to.Ptr(armavs.AddonTypeHCX),
			Offer:             to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
			ManagementNetwork: to.Ptr("10.3.1.0/24"),
			UplinkNetwork:     to.Ptr("10.3.2.0/24"),
		},
	}, 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 poll 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 = armavs.AddonsClientCreateOrUpdateResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/hcx"),
	// 		Name: to.Ptr("hcx"),
	// 		Properties: &armavs.AddonHcxProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeHCX),
	// 			Offer: to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
	// 			ManagementNetwork: to.Ptr("10.3.1.0/24"),
	// 			UplinkNetwork: to.Ptr("10.3.2.0/24"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsCreateOrUpdateSrm) ¶

Generated from example definition: 2026-03-01/Addons_CreateOrUpdate_SRM.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAddonsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "srm", armavs.Addon{
		Properties: &armavs.AddonSrmProperties{
			AddonType:  to.Ptr(armavs.AddonTypeSRM),
			LicenseKey: to.Ptr("41915178-A8FF-4A4D-B683-6D735AF5E3F5"),
		},
	}, 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 poll 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 = armavs.AddonsClientCreateOrUpdateResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/srm"),
	// 		Name: to.Ptr("srm"),
	// 		Properties: &armavs.AddonSrmProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeSRM),
	// 			LicenseKey: to.Ptr("41915178-A8FF-4A4D-B683-6D735AF5E3F5"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsCreateOrUpdateVr) ¶

Generated from example definition: 2026-03-01/Addons_CreateOrUpdate_VR.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAddonsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "vr", armavs.Addon{
		Properties: &armavs.AddonVrProperties{
			AddonType: to.Ptr(armavs.AddonTypeVR),
			VrsCount:  to.Ptr[int32](1),
		},
	}, 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 poll 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 = armavs.AddonsClientCreateOrUpdateResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/vr"),
	// 		Name: to.Ptr("vr"),
	// 		Properties: &armavs.AddonVrProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeVR),
	// 			VrsCount: to.Ptr[int32](1),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

func (*AddonsClient) BeginDelete ¶

func (client *AddonsClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, addonName string, options *AddonsClientBeginDeleteOptions) (*runtime.Poller[AddonsClientDeleteResponse], error)

BeginDelete - Delete a Addon If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
addonName - Name of the addon.
options - AddonsClientBeginDeleteOptions contains the optional parameters for the AddonsClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/Addons_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAddonsClient().BeginDelete(ctx, "group1", "cloud1", "srm", 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 poll 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 = armavs.AddonsClientDeleteResponse{
	// }
}

Output:

func (*AddonsClient) Get ¶

func (client *AddonsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, addonName string, options *AddonsClientGetOptions) (AddonsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
addonName - Name of the addon.
options - AddonsClientGetOptions contains the optional parameters for the AddonsClient.Get method.

Example (AddonsGetArcReg) ¶

Generated from example definition: 2026-03-01/Addons_Get_ArcReg.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAddonsClient().Get(ctx, "group1", "cloud1", "arc", 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 = armavs.AddonsClientGetResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/arc"),
	// 		Name: to.Ptr("arc"),
	// 		Properties: &armavs.AddonArcProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeArc),
	// 			VCenter: to.Ptr("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg_test/providers/Microsoft.ConnectedVMwarevSphere/VCenters/test-vcenter"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsGetHcx) ¶

Generated from example definition: 2026-03-01/Addons_Get_HCX.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAddonsClient().Get(ctx, "group1", "cloud1", "hcx", 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 = armavs.AddonsClientGetResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/hcx"),
	// 		Name: to.Ptr("hcx"),
	// 		Properties: &armavs.AddonHcxProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeHCX),
	// 			Offer: to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsGetHcxWithNetworks) ¶

Generated from example definition: 2026-03-01/Addons_Get_HCX_With_Networks.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAddonsClient().Get(ctx, "group1", "cloud1", "hcx", 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 = armavs.AddonsClientGetResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/hcx"),
	// 		Name: to.Ptr("hcx"),
	// 		Properties: &armavs.AddonHcxProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeHCX),
	// 			Offer: to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 			ManagementNetwork: to.Ptr("10.3.1.0/24"),
	// 			UplinkNetwork: to.Ptr("10.3.2.0/24"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsGetSrm) ¶

Generated from example definition: 2026-03-01/Addons_Get_SRM.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAddonsClient().Get(ctx, "group1", "cloud1", "srm", 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 = armavs.AddonsClientGetResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/srm"),
	// 		Name: to.Ptr("srm"),
	// 		Properties: &armavs.AddonSrmProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeSRM),
	// 			LicenseKey: to.Ptr("41915178-A8FF-4A4D-B683-6D735AF5E3F5"),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

Example (AddonsGetVr) ¶

Generated from example definition: 2026-03-01/Addons_Get_VR.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAddonsClient().Get(ctx, "group1", "cloud1", "vr", 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 = armavs.AddonsClientGetResponse{
	// 	Addon: armavs.Addon{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/vr"),
	// 		Name: to.Ptr("vr"),
	// 		Properties: &armavs.AddonVrProperties{
	// 			AddonType: to.Ptr(armavs.AddonTypeVR),
	// 			VrsCount: to.Ptr[int32](1),
	// 			ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
	// 	},
	// }
}

Output:

func (*AddonsClient) NewListPager ¶

func (client *AddonsClient) NewListPager(resourceGroupName string, privateCloudName string, options *AddonsClientListOptions) *runtime.Pager[AddonsClientListResponse]

NewListPager - List Addon resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - AddonsClientListOptions contains the optional parameters for the AddonsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Addons_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAddonsClient().NewListPager("group1", "cloud1", 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 = armavs.AddonsClientListResponse{
		// 	AddonList: armavs.AddonList{
		// 		Value: []*armavs.Addon{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/srm"),
		// 				Name: to.Ptr("srm"),
		// 				Properties: &armavs.AddonSrmProperties{
		// 					AddonType: to.Ptr(armavs.AddonTypeSRM),
		// 					LicenseKey: to.Ptr("41915178-A8FF-4A4D-B683-6D735AF5E3F5"),
		// 					ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type AddonsClientBeginCreateOrUpdateOptions ¶

type AddonsClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AddonsClientBeginCreateOrUpdateOptions contains the optional parameters for the AddonsClient.BeginCreateOrUpdate method.

type AddonsClientBeginDeleteOptions ¶

type AddonsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AddonsClientBeginDeleteOptions contains the optional parameters for the AddonsClient.BeginDelete method.

type AddonsClientCreateOrUpdateResponse ¶

type AddonsClientCreateOrUpdateResponse struct {
	// An addon resource
	Addon
}

AddonsClientCreateOrUpdateResponse contains the response from method AddonsClient.BeginCreateOrUpdate.

type AddonsClientDeleteResponse ¶

type AddonsClientDeleteResponse struct {
}

AddonsClientDeleteResponse contains the response from method AddonsClient.BeginDelete.

type AddonsClientGetOptions ¶

type AddonsClientGetOptions struct {
}

AddonsClientGetOptions contains the optional parameters for the AddonsClient.Get method.

type AddonsClientGetResponse ¶

type AddonsClientGetResponse struct {
	// An addon resource
	Addon
}

AddonsClientGetResponse contains the response from method AddonsClient.Get.

type AddonsClientListOptions ¶

type AddonsClientListOptions struct {
}

AddonsClientListOptions contains the optional parameters for the AddonsClient.NewListPager method.

type AddonsClientListResponse ¶

type AddonsClientListResponse struct {
	// The response of a Addon list operation.
	AddonList
}

AddonsClientListResponse contains the response from method AddonsClient.NewListPager.

type AdminCredentials ¶

type AdminCredentials struct {
	// READ-ONLY; NSX-T Manager password
	NsxtPassword *string

	// READ-ONLY; NSX-T Manager username
	NsxtUsername *string

	// READ-ONLY; vCenter admin password
	VcenterPassword *string

	// READ-ONLY; vCenter admin username
	VcenterUsername *string
}

AdminCredentials - Administrative credentials for accessing vCenter and NSX-T

func (AdminCredentials) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AdminCredentials.

func (*AdminCredentials) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AdminCredentials.

type AffinityStrength ¶

type AffinityStrength string

AffinityStrength - Affinity Strength

const (
	// AffinityStrengthMust - is must
	AffinityStrengthMust AffinityStrength = "Must"
	// AffinityStrengthShould - is should
	AffinityStrengthShould AffinityStrength = "Should"
)

func PossibleAffinityStrengthValues ¶

func PossibleAffinityStrengthValues() []AffinityStrength

PossibleAffinityStrengthValues returns the possible values for the AffinityStrength const type.

type AffinityType ¶

type AffinityType string

AffinityType - Affinity type

const (
	// AffinityTypeAffinity - is affinity
	AffinityTypeAffinity AffinityType = "Affinity"
	// AffinityTypeAntiAffinity - is anti-affinity
	AffinityTypeAntiAffinity AffinityType = "AntiAffinity"
)

func PossibleAffinityTypeValues ¶

func PossibleAffinityTypeValues() []AffinityType

PossibleAffinityTypeValues returns the possible values for the AffinityType const type.

type AuthorizationsClient ¶

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

AuthorizationsClient contains the methods for the Authorizations group. Don't use this type directly, use NewAuthorizationsClient() instead.

Generated from API version 2026-03-01

func NewAuthorizationsClient ¶

func NewAuthorizationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AuthorizationsClient, error)

NewAuthorizationsClient creates a new instance of AuthorizationsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*AuthorizationsClient) BeginCreateOrUpdate ¶

func (client *AuthorizationsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization ExpressRouteAuthorization, options *AuthorizationsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AuthorizationsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a ExpressRouteAuthorization If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
authorizationName - Name of the ExpressRoute Circuit Authorization
authorization - Resource create parameters.
options - AuthorizationsClientBeginCreateOrUpdateOptions contains the optional parameters for the AuthorizationsClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/Authorizations_CreateOrUpdate.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAuthorizationsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "authorization1", armavs.ExpressRouteAuthorization{}, 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 poll 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 = armavs.AuthorizationsClientCreateOrUpdateResponse{
	// 	ExpressRouteAuthorization: armavs.ExpressRouteAuthorization{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/authorizations/authorization1"),
	// 		Name: to.Ptr("authorization1"),
	// 		Properties: &armavs.ExpressRouteAuthorizationProperties{
	// 			ProvisioningState: to.Ptr(armavs.ExpressRouteAuthorizationProvisioningStateSucceeded),
	// 			ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 			ExpressRouteAuthorizationID: to.Ptr("/subscriptions/5206f269-120b-41ef-a95b-0dce7109de61/resourceGroups/tnt34-cust-mockp02-spearj2dev/providers/Microsoft.Network/expressroutecircuits/tnt34-cust-mockp02-spearj2dev-er/authorizations/myauth"),
	// 			ExpressRouteAuthorizationKey: to.Ptr("37b0db3b-3b17-4c7b-bf76-bf13b01bcadc"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/authorizations"),
	// 	},
	// }
}

Output:

func (*AuthorizationsClient) BeginDelete ¶

func (client *AuthorizationsClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, options *AuthorizationsClientBeginDeleteOptions) (*runtime.Poller[AuthorizationsClientDeleteResponse], error)

BeginDelete - Delete a ExpressRouteAuthorization If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
authorizationName - Name of the ExpressRoute Circuit Authorization
options - AuthorizationsClientBeginDeleteOptions contains the optional parameters for the AuthorizationsClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/Authorizations_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAuthorizationsClient().BeginDelete(ctx, "group1", "cloud1", "authorization1", 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 poll 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 = armavs.AuthorizationsClientDeleteResponse{
	// }
}

Output:

func (*AuthorizationsClient) Get ¶

func (client *AuthorizationsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, options *AuthorizationsClientGetOptions) (AuthorizationsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
authorizationName - Name of the ExpressRoute Circuit Authorization
options - AuthorizationsClientGetOptions contains the optional parameters for the AuthorizationsClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/Authorizations_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAuthorizationsClient().Get(ctx, "group1", "cloud1", "authorization1", 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 = armavs.AuthorizationsClientGetResponse{
	// 	ExpressRouteAuthorization: armavs.ExpressRouteAuthorization{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/authorizations/authorization1"),
	// 		Name: to.Ptr("authorization1"),
	// 		Properties: &armavs.ExpressRouteAuthorizationProperties{
	// 			ProvisioningState: to.Ptr(armavs.ExpressRouteAuthorizationProvisioningStateSucceeded),
	// 			ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 			ExpressRouteAuthorizationID: to.Ptr("/subscriptions/5206f269-120b-41ef-a95b-0dce7109de61/resourceGroups/tnt34-cust-mockp02-spearj2dev/providers/Microsoft.Network/expressroutecircuits/tnt34-cust-mockp02-spearj2dev-er/authorizations/myauth"),
	// 			ExpressRouteAuthorizationKey: to.Ptr("37b0db3b-3b17-4c7b-bf76-bf13b01bcadc"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/authorizations"),
	// 	},
	// }
}

Output:

func (*AuthorizationsClient) NewListPager ¶

func (client *AuthorizationsClient) NewListPager(resourceGroupName string, privateCloudName string, options *AuthorizationsClientListOptions) *runtime.Pager[AuthorizationsClientListResponse]

NewListPager - List ExpressRouteAuthorization resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - AuthorizationsClientListOptions contains the optional parameters for the AuthorizationsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Authorizations_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAuthorizationsClient().NewListPager("group1", "cloud1", 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 = armavs.AuthorizationsClientListResponse{
		// 	ExpressRouteAuthorizationList: armavs.ExpressRouteAuthorizationList{
		// 		Value: []*armavs.ExpressRouteAuthorization{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/authorizations/authorization1"),
		// 				Name: to.Ptr("authorization1"),
		// 				Properties: &armavs.ExpressRouteAuthorizationProperties{
		// 					ProvisioningState: to.Ptr(armavs.ExpressRouteAuthorizationProvisioningStateSucceeded),
		// 					ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
		// 					ExpressRouteAuthorizationID: to.Ptr("/subscriptions/5206f269-120b-41ef-a95b-0dce7109de61/resourceGroups/tnt34-cust-mockp02-spearj2dev/providers/Microsoft.Network/expressroutecircuits/tnt34-cust-mockp02-spearj2dev-er/authorizations/myauth"),
		// 					ExpressRouteAuthorizationKey: to.Ptr("37b0db3b-3b17-4c7b-bf76-bf13b01bcadc"),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/authorizations"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type AuthorizationsClientBeginCreateOrUpdateOptions ¶

type AuthorizationsClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AuthorizationsClientBeginCreateOrUpdateOptions contains the optional parameters for the AuthorizationsClient.BeginCreateOrUpdate method.

type AuthorizationsClientBeginDeleteOptions ¶

type AuthorizationsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AuthorizationsClientBeginDeleteOptions contains the optional parameters for the AuthorizationsClient.BeginDelete method.

type AuthorizationsClientCreateOrUpdateResponse ¶

type AuthorizationsClientCreateOrUpdateResponse struct {
	// ExpressRoute Circuit Authorization
	ExpressRouteAuthorization
}

AuthorizationsClientCreateOrUpdateResponse contains the response from method AuthorizationsClient.BeginCreateOrUpdate.

type AuthorizationsClientDeleteResponse ¶

type AuthorizationsClientDeleteResponse struct {
}

AuthorizationsClientDeleteResponse contains the response from method AuthorizationsClient.BeginDelete.

type AuthorizationsClientGetOptions ¶

type AuthorizationsClientGetOptions struct {
}

AuthorizationsClientGetOptions contains the optional parameters for the AuthorizationsClient.Get method.

type AuthorizationsClientGetResponse ¶

type AuthorizationsClientGetResponse struct {
	// ExpressRoute Circuit Authorization
	ExpressRouteAuthorization
}

AuthorizationsClientGetResponse contains the response from method AuthorizationsClient.Get.

type AuthorizationsClientListOptions ¶

type AuthorizationsClientListOptions struct {
}

AuthorizationsClientListOptions contains the optional parameters for the AuthorizationsClient.NewListPager method.

type AuthorizationsClientListResponse ¶

type AuthorizationsClientListResponse struct {
	// The response of a ExpressRouteAuthorization list operation.
	ExpressRouteAuthorizationList
}

AuthorizationsClientListResponse contains the response from method AuthorizationsClient.NewListPager.

type AvailabilityProperties ¶

type AvailabilityProperties struct {
	// The secondary availability zone for the private cloud
	SecondaryZone *int32

	// The availability strategy for the private cloud
	Strategy *AvailabilityStrategy

	// The primary availability zone for the private cloud
	Zone *int32
}

AvailabilityProperties - The properties describing private cloud availability zone distribution

func (AvailabilityProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type AvailabilityProperties.

func (*AvailabilityProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailabilityProperties.

type AvailabilityStrategy ¶

type AvailabilityStrategy string

AvailabilityStrategy - Whether the private clouds is available in a single zone or two zones

const (
	// AvailabilityStrategyDualZone - in two zones
	AvailabilityStrategyDualZone AvailabilityStrategy = "DualZone"
	// AvailabilityStrategySingleZone - in single zone
	AvailabilityStrategySingleZone AvailabilityStrategy = "SingleZone"
)

func PossibleAvailabilityStrategyValues ¶

func PossibleAvailabilityStrategyValues() []AvailabilityStrategy

PossibleAvailabilityStrategyValues returns the possible values for the AvailabilityStrategy const type.

type AvailableWindowForMaintenanceWhileRescheduleOperation ¶ added in v2.2.0

type AvailableWindowForMaintenanceWhileRescheduleOperation struct {
	// REQUIRED; The kind of constraint
	Kind *RescheduleOperationConstraintKind

	// READ-ONLY; End date Time
	EndsAt *time.Time

	// READ-ONLY; Start date time
	StartsAt *time.Time
}

AvailableWindowForMaintenanceWhileRescheduleOperation - Time window in which Customer can reschedule maintenance

func (*AvailableWindowForMaintenanceWhileRescheduleOperation) GetRescheduleOperationConstraint ¶ added in v2.2.0

func (a *AvailableWindowForMaintenanceWhileRescheduleOperation) GetRescheduleOperationConstraint() *RescheduleOperationConstraint

GetRescheduleOperationConstraint implements the RescheduleOperationConstraintClassification interface for type AvailableWindowForMaintenanceWhileRescheduleOperation.

func (AvailableWindowForMaintenanceWhileRescheduleOperation) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type AvailableWindowForMaintenanceWhileRescheduleOperation.

func (*AvailableWindowForMaintenanceWhileRescheduleOperation) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableWindowForMaintenanceWhileRescheduleOperation.

type AvailableWindowForMaintenanceWhileScheduleOperation ¶ added in v2.2.0

type AvailableWindowForMaintenanceWhileScheduleOperation struct {
	// REQUIRED; The kind of constraint
	Kind *ScheduleOperationConstraintKind

	// READ-ONLY; End date Time
	EndsAt *time.Time

	// READ-ONLY; Start date time
	StartsAt *time.Time
}

AvailableWindowForMaintenanceWhileScheduleOperation - Time window in which Customer can to schedule maintenance

func (*AvailableWindowForMaintenanceWhileScheduleOperation) GetScheduleOperationConstraint ¶ added in v2.2.0

func (a *AvailableWindowForMaintenanceWhileScheduleOperation) GetScheduleOperationConstraint() *ScheduleOperationConstraint

GetScheduleOperationConstraint implements the ScheduleOperationConstraintClassification interface for type AvailableWindowForMaintenanceWhileScheduleOperation.

func (AvailableWindowForMaintenanceWhileScheduleOperation) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type AvailableWindowForMaintenanceWhileScheduleOperation.

func (*AvailableWindowForMaintenanceWhileScheduleOperation) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableWindowForMaintenanceWhileScheduleOperation.

type AzureHybridBenefitType ¶

type AzureHybridBenefitType string

AzureHybridBenefitType - Azure Hybrid Benefit type

const (
	// AzureHybridBenefitTypeNone - is None
	AzureHybridBenefitTypeNone AzureHybridBenefitType = "None"
	// AzureHybridBenefitTypeSQLHost - is SqlHost
	AzureHybridBenefitTypeSQLHost AzureHybridBenefitType = "SqlHost"
)

func PossibleAzureHybridBenefitTypeValues ¶

func PossibleAzureHybridBenefitTypeValues() []AzureHybridBenefitType

PossibleAzureHybridBenefitTypeValues returns the possible values for the AzureHybridBenefitType const type.

type BlockedDatesConstraintCategory ¶ added in v2.2.0

type BlockedDatesConstraintCategory string

BlockedDatesConstraintCategory - Reason for blocking operation on maintenance

const (
	// BlockedDatesConstraintCategoryHiPriorityEvent - Hi-Priority Event
	BlockedDatesConstraintCategoryHiPriorityEvent BlockedDatesConstraintCategory = "HiPriorityEvent"
	// BlockedDatesConstraintCategoryHoliday - Holidays
	BlockedDatesConstraintCategoryHoliday BlockedDatesConstraintCategory = "Holiday"
	// BlockedDatesConstraintCategoryOverlappingMaintenance - Constraint due to overlapping maintenance
	BlockedDatesConstraintCategoryOverlappingMaintenance BlockedDatesConstraintCategory = "OverlappingMaintenance"
	// BlockedDatesConstraintCategoryQuotaExhausted - Quota Exhausted
	BlockedDatesConstraintCategoryQuotaExhausted BlockedDatesConstraintCategory = "QuotaExhausted"
)

func PossibleBlockedDatesConstraintCategoryValues ¶ added in v2.2.0

func PossibleBlockedDatesConstraintCategoryValues() []BlockedDatesConstraintCategory

PossibleBlockedDatesConstraintCategoryValues returns the possible values for the BlockedDatesConstraintCategory const type.

type BlockedDatesConstraintTimeRange ¶ added in v2.2.0

type BlockedDatesConstraintTimeRange struct {
	// READ-ONLY; End date Time
	EndsAt *time.Time

	// READ-ONLY; Start date time
	StartsAt *time.Time

	// READ-ONLY; Reason category for blocking maintenance reschedule
	Reason *string
}

BlockedDatesConstraintTimeRange - Blocked Time range Constraints for maintenance

func (BlockedDatesConstraintTimeRange) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type BlockedDatesConstraintTimeRange.

func (*BlockedDatesConstraintTimeRange) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type BlockedDatesConstraintTimeRange.

type BlockedWhileRescheduleOperation ¶ added in v2.2.0

type BlockedWhileRescheduleOperation struct {
	// REQUIRED; The kind of constraint
	Kind *RescheduleOperationConstraintKind

	// READ-ONLY; Category of blocked date
	Category *BlockedDatesConstraintCategory

	// READ-ONLY; Date ranges blocked for schedule
	TimeRanges []*BlockedDatesConstraintTimeRange
}

BlockedWhileRescheduleOperation - Time ranges blocked for rescheduling maintenance

func (*BlockedWhileRescheduleOperation) GetRescheduleOperationConstraint ¶ added in v2.2.0

func (b *BlockedWhileRescheduleOperation) GetRescheduleOperationConstraint() *RescheduleOperationConstraint

GetRescheduleOperationConstraint implements the RescheduleOperationConstraintClassification interface for type BlockedWhileRescheduleOperation.

func (BlockedWhileRescheduleOperation) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type BlockedWhileRescheduleOperation.

func (*BlockedWhileRescheduleOperation) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type BlockedWhileRescheduleOperation.

type BlockedWhileScheduleOperation ¶ added in v2.2.0

type BlockedWhileScheduleOperation struct {
	// REQUIRED; The kind of constraint
	Kind *ScheduleOperationConstraintKind

	// READ-ONLY; Category of blocked date
	Category *BlockedDatesConstraintCategory

	// READ-ONLY; Date ranges blocked for schedule
	TimeRanges []*BlockedDatesConstraintTimeRange
}

BlockedWhileScheduleOperation - Time ranges blocked for scheduling maintenance

func (*BlockedWhileScheduleOperation) GetScheduleOperationConstraint ¶ added in v2.2.0

func (b *BlockedWhileScheduleOperation) GetScheduleOperationConstraint() *ScheduleOperationConstraint

GetScheduleOperationConstraint implements the ScheduleOperationConstraintClassification interface for type BlockedWhileScheduleOperation.

func (BlockedWhileScheduleOperation) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type BlockedWhileScheduleOperation.

func (*BlockedWhileScheduleOperation) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type BlockedWhileScheduleOperation.

type Circuit ¶

type Circuit struct {
	// READ-ONLY; Identifier of the ExpressRoute Circuit (Microsoft Colo only)
	ExpressRouteID *string

	// READ-ONLY; ExpressRoute Circuit private peering identifier
	ExpressRoutePrivatePeeringID *string

	// READ-ONLY; CIDR of primary subnet
	PrimarySubnet *string

	// READ-ONLY; CIDR of secondary subnet
	SecondarySubnet *string
}

Circuit - An ExpressRoute Circuit

func (Circuit) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type Circuit.

func (*Circuit) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type Circuit.

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) NewAddonsClient ¶

func (c *ClientFactory) NewAddonsClient() *AddonsClient

NewAddonsClient creates a new instance of AddonsClient.

func (*ClientFactory) NewAuthorizationsClient ¶

func (c *ClientFactory) NewAuthorizationsClient() *AuthorizationsClient

NewAuthorizationsClient creates a new instance of AuthorizationsClient.

func (*ClientFactory) NewCloudLinksClient ¶

func (c *ClientFactory) NewCloudLinksClient() *CloudLinksClient

NewCloudLinksClient creates a new instance of CloudLinksClient.

func (*ClientFactory) NewClustersClient ¶

func (c *ClientFactory) NewClustersClient() *ClustersClient

NewClustersClient creates a new instance of ClustersClient.

func (*ClientFactory) NewDatastoresClient ¶

func (c *ClientFactory) NewDatastoresClient() *DatastoresClient

NewDatastoresClient creates a new instance of DatastoresClient.

func (*ClientFactory) NewGlobalReachConnectionsClient ¶

func (c *ClientFactory) NewGlobalReachConnectionsClient() *GlobalReachConnectionsClient

NewGlobalReachConnectionsClient creates a new instance of GlobalReachConnectionsClient.

func (*ClientFactory) NewHcxEnterpriseSitesClient ¶

func (c *ClientFactory) NewHcxEnterpriseSitesClient() *HcxEnterpriseSitesClient

NewHcxEnterpriseSitesClient creates a new instance of HcxEnterpriseSitesClient.

func (*ClientFactory) NewHostsClient ¶ added in v2.1.0

func (c *ClientFactory) NewHostsClient() *HostsClient

NewHostsClient creates a new instance of HostsClient.

func (*ClientFactory) NewIscsiPathsClient ¶

func (c *ClientFactory) NewIscsiPathsClient() *IscsiPathsClient

NewIscsiPathsClient creates a new instance of IscsiPathsClient.

func (*ClientFactory) NewLicensesClient ¶ added in v2.2.0

func (c *ClientFactory) NewLicensesClient() *LicensesClient

NewLicensesClient creates a new instance of LicensesClient.

func (*ClientFactory) NewLocationsClient ¶

func (c *ClientFactory) NewLocationsClient() *LocationsClient

NewLocationsClient creates a new instance of LocationsClient.

func (*ClientFactory) NewMaintenancesClient ¶ added in v2.2.0

func (c *ClientFactory) NewMaintenancesClient() *MaintenancesClient

NewMaintenancesClient creates a new instance of MaintenancesClient.

func (*ClientFactory) NewOperationsClient ¶

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPlacementPoliciesClient ¶

func (c *ClientFactory) NewPlacementPoliciesClient() *PlacementPoliciesClient

NewPlacementPoliciesClient creates a new instance of PlacementPoliciesClient.

func (*ClientFactory) NewPrivateCloudsClient ¶

func (c *ClientFactory) NewPrivateCloudsClient() *PrivateCloudsClient

NewPrivateCloudsClient creates a new instance of PrivateCloudsClient.

func (*ClientFactory) NewProvisionedNetworksClient ¶ added in v2.1.0

func (c *ClientFactory) NewProvisionedNetworksClient() *ProvisionedNetworksClient

NewProvisionedNetworksClient creates a new instance of ProvisionedNetworksClient.

func (*ClientFactory) NewPureStoragePoliciesClient ¶ added in v2.1.0

func (c *ClientFactory) NewPureStoragePoliciesClient() *PureStoragePoliciesClient

NewPureStoragePoliciesClient creates a new instance of PureStoragePoliciesClient.

func (*ClientFactory) NewSKUsClient ¶ added in v2.1.0

func (c *ClientFactory) NewSKUsClient() *SKUsClient

NewSKUsClient creates a new instance of SKUsClient.

func (*ClientFactory) NewScriptCmdletsClient ¶

func (c *ClientFactory) NewScriptCmdletsClient() *ScriptCmdletsClient

NewScriptCmdletsClient creates a new instance of ScriptCmdletsClient.

func (*ClientFactory) NewScriptExecutionsClient ¶

func (c *ClientFactory) NewScriptExecutionsClient() *ScriptExecutionsClient

NewScriptExecutionsClient creates a new instance of ScriptExecutionsClient.

func (*ClientFactory) NewScriptPackagesClient ¶

func (c *ClientFactory) NewScriptPackagesClient() *ScriptPackagesClient

NewScriptPackagesClient creates a new instance of ScriptPackagesClient.

func (*ClientFactory) NewVirtualMachinesClient ¶

func (c *ClientFactory) NewVirtualMachinesClient() *VirtualMachinesClient

NewVirtualMachinesClient creates a new instance of VirtualMachinesClient.

func (*ClientFactory) NewWorkloadNetworksClient ¶

func (c *ClientFactory) NewWorkloadNetworksClient() *WorkloadNetworksClient

NewWorkloadNetworksClient creates a new instance of WorkloadNetworksClient.

type CloudLink ¶

type CloudLink struct {
	// The resource-specific properties for this resource.
	Properties *CloudLinkProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

CloudLink - A cloud link resource

func (CloudLink) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type CloudLink.

func (*CloudLink) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudLink.

type CloudLinkList ¶

type CloudLinkList struct {
	// REQUIRED; The CloudLink items on this page
	Value []*CloudLink

	// The link to the next page of items
	NextLink *string
}

CloudLinkList - The response of a CloudLink list operation.

func (CloudLinkList) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type CloudLinkList.

func (*CloudLinkList) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudLinkList.

type CloudLinkProperties ¶

type CloudLinkProperties struct {
	// Identifier of the other private cloud participating in the link.
	LinkedCloud *string

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

	// READ-ONLY; The state of the cloud link.
	Status *CloudLinkStatus
}

CloudLinkProperties - The properties of a cloud link.

func (CloudLinkProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type CloudLinkProperties.

func (*CloudLinkProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudLinkProperties.

type CloudLinkProvisioningState ¶

type CloudLinkProvisioningState string

CloudLinkProvisioningState - cloud link provisioning state

const (
	// CloudLinkProvisioningStateCanceled - Resource creation was canceled.
	CloudLinkProvisioningStateCanceled CloudLinkProvisioningState = "Canceled"
	// CloudLinkProvisioningStateFailed - Resource creation failed.
	CloudLinkProvisioningStateFailed CloudLinkProvisioningState = "Failed"
	// CloudLinkProvisioningStateSucceeded - Resource has been created.
	CloudLinkProvisioningStateSucceeded CloudLinkProvisioningState = "Succeeded"
)

func PossibleCloudLinkProvisioningStateValues ¶

func PossibleCloudLinkProvisioningStateValues() []CloudLinkProvisioningState

PossibleCloudLinkProvisioningStateValues returns the possible values for the CloudLinkProvisioningState const type.

type CloudLinkStatus ¶

type CloudLinkStatus string

CloudLinkStatus - Cloud Link status

const (
	// CloudLinkStatusActive - is active
	CloudLinkStatusActive CloudLinkStatus = "Active"
	// CloudLinkStatusBuilding - is building
	CloudLinkStatusBuilding CloudLinkStatus = "Building"
	// CloudLinkStatusDeleting - is deleting
	CloudLinkStatusDeleting CloudLinkStatus = "Deleting"
	// CloudLinkStatusDisconnected - is disconnected
	CloudLinkStatusDisconnected CloudLinkStatus = "Disconnected"
	// CloudLinkStatusFailed - is failed
	CloudLinkStatusFailed CloudLinkStatus = "Failed"
)

func PossibleCloudLinkStatusValues ¶

func PossibleCloudLinkStatusValues() []CloudLinkStatus

PossibleCloudLinkStatusValues returns the possible values for the CloudLinkStatus const type.

type CloudLinksClient ¶

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

CloudLinksClient contains the methods for the CloudLinks group. Don't use this type directly, use NewCloudLinksClient() instead.

Generated from API version 2026-03-01

func NewCloudLinksClient ¶

func NewCloudLinksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CloudLinksClient, error)

NewCloudLinksClient creates a new instance of CloudLinksClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*CloudLinksClient) BeginCreateOrUpdate ¶

func (client *CloudLinksClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, cloudLinkName string, cloudLink CloudLink, options *CloudLinksClientBeginCreateOrUpdateOptions) (*runtime.Poller[CloudLinksClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a CloudLink If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
cloudLinkName - Name of the cloud link.
cloudLink - Resource create parameters.
options - CloudLinksClientBeginCreateOrUpdateOptions contains the optional parameters for the CloudLinksClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/CloudLinks_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCloudLinksClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "cloudLink1", armavs.CloudLink{
		Properties: &armavs.CloudLinkProperties{
			LinkedCloud: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
		},
	}, 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 poll 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 = armavs.CloudLinksClientCreateOrUpdateResponse{
	// 	CloudLink: armavs.CloudLink{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/cloudLinks/cloudLink1"),
	// 		Name: to.Ptr("cloudLink1"),
	// 		Properties: &armavs.CloudLinkProperties{
	// 			Status: to.Ptr(armavs.CloudLinkStatusActive),
	// 			LinkedCloud: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/cloudLinks"),
	// 	},
	// }
}

Output:

func (*CloudLinksClient) BeginDelete ¶

func (client *CloudLinksClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, cloudLinkName string, options *CloudLinksClientBeginDeleteOptions) (*runtime.Poller[CloudLinksClientDeleteResponse], error)

BeginDelete - Delete a CloudLink If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
cloudLinkName - Name of the cloud link.
options - CloudLinksClientBeginDeleteOptions contains the optional parameters for the CloudLinksClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/CloudLinks_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCloudLinksClient().BeginDelete(ctx, "group1", "cloud1", "cloudLink1", 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 poll 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 = armavs.CloudLinksClientDeleteResponse{
	// }
}

Output:

func (*CloudLinksClient) Get ¶

func (client *CloudLinksClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, cloudLinkName string, options *CloudLinksClientGetOptions) (CloudLinksClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
cloudLinkName - Name of the cloud link.
options - CloudLinksClientGetOptions contains the optional parameters for the CloudLinksClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/CloudLinks_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewCloudLinksClient().Get(ctx, "group1", "cloud1", "cloudLink1", 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 = armavs.CloudLinksClientGetResponse{
	// 	CloudLink: armavs.CloudLink{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/cloudLinks/cloudLink1"),
	// 		Name: to.Ptr("cloudLink1"),
	// 		Properties: &armavs.CloudLinkProperties{
	// 			Status: to.Ptr(armavs.CloudLinkStatusActive),
	// 			LinkedCloud: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/cloudLinks"),
	// 	},
	// }
}

Output:

func (*CloudLinksClient) NewListPager ¶

func (client *CloudLinksClient) NewListPager(resourceGroupName string, privateCloudName string, options *CloudLinksClientListOptions) *runtime.Pager[CloudLinksClientListResponse]

NewListPager - List CloudLink resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - CloudLinksClientListOptions contains the optional parameters for the CloudLinksClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/CloudLinks_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewCloudLinksClient().NewListPager("group1", "cloud1", 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 = armavs.CloudLinksClientListResponse{
		// 	CloudLinkList: armavs.CloudLinkList{
		// 		Value: []*armavs.CloudLink{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/cloudLinks/cloudLink1"),
		// 				Name: to.Ptr("cloudLink1"),
		// 				Properties: &armavs.CloudLinkProperties{
		// 					Status: to.Ptr(armavs.CloudLinkStatusActive),
		// 					LinkedCloud: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/cloudLinks"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type CloudLinksClientBeginCreateOrUpdateOptions ¶

type CloudLinksClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

CloudLinksClientBeginCreateOrUpdateOptions contains the optional parameters for the CloudLinksClient.BeginCreateOrUpdate method.

type CloudLinksClientBeginDeleteOptions ¶

type CloudLinksClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

CloudLinksClientBeginDeleteOptions contains the optional parameters for the CloudLinksClient.BeginDelete method.

type CloudLinksClientCreateOrUpdateResponse ¶

type CloudLinksClientCreateOrUpdateResponse struct {
	// A cloud link resource
	CloudLink
}

CloudLinksClientCreateOrUpdateResponse contains the response from method CloudLinksClient.BeginCreateOrUpdate.

type CloudLinksClientDeleteResponse ¶

type CloudLinksClientDeleteResponse struct {
}

CloudLinksClientDeleteResponse contains the response from method CloudLinksClient.BeginDelete.

type CloudLinksClientGetOptions ¶

type CloudLinksClientGetOptions struct {
}

CloudLinksClientGetOptions contains the optional parameters for the CloudLinksClient.Get method.

type CloudLinksClientGetResponse ¶

type CloudLinksClientGetResponse struct {
	// A cloud link resource
	CloudLink
}

CloudLinksClientGetResponse contains the response from method CloudLinksClient.Get.

type CloudLinksClientListOptions ¶

type CloudLinksClientListOptions struct {
}

CloudLinksClientListOptions contains the optional parameters for the CloudLinksClient.NewListPager method.

type CloudLinksClientListResponse ¶

type CloudLinksClientListResponse struct {
	// The response of a CloudLink list operation.
	CloudLinkList
}

CloudLinksClientListResponse contains the response from method CloudLinksClient.NewListPager.

type Cluster ¶

type Cluster struct {
	// REQUIRED; The SKU (Stock Keeping Unit) assigned to this resource.
	SKU *SKU

	// The resource-specific properties for this resource.
	Properties *ClusterProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

Cluster - A cluster resource

func (Cluster) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type Cluster.

func (*Cluster) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type Cluster.

type ClusterList ¶

type ClusterList struct {
	// REQUIRED; The Cluster items on this page
	Value []*Cluster

	// The link to the next page of items
	NextLink *string
}

ClusterList - The response of a Cluster list operation.

func (ClusterList) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ClusterList.

func (*ClusterList) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterList.

type ClusterProperties ¶

type ClusterProperties struct {
	// The cluster size
	ClusterSize *int32

	// The hosts
	Hosts []*string

	// Name of the vsan datastore associated with the cluster
	VsanDatastoreName *string

	// READ-ONLY; The identity
	ClusterID *int32

	// READ-ONLY; The state of the cluster provisioning
	ProvisioningState *ClusterProvisioningState
}

ClusterProperties - The properties of a cluster

func (ClusterProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ClusterProperties.

func (*ClusterProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterProperties.

type ClusterProvisioningState ¶

type ClusterProvisioningState string

ClusterProvisioningState - Cluster provisioning state

const (
	// ClusterProvisioningStateCanceled - Resource creation was canceled.
	ClusterProvisioningStateCanceled ClusterProvisioningState = "Canceled"
	// ClusterProvisioningStateCancelled - is cancelled
	ClusterProvisioningStateCancelled ClusterProvisioningState = "Cancelled"
	// ClusterProvisioningStateDeleting - is deleting
	ClusterProvisioningStateDeleting ClusterProvisioningState = "Deleting"
	// ClusterProvisioningStateFailed - Resource creation failed.
	ClusterProvisioningStateFailed ClusterProvisioningState = "Failed"
	// ClusterProvisioningStateSucceeded - Resource has been created.
	ClusterProvisioningStateSucceeded ClusterProvisioningState = "Succeeded"
	// ClusterProvisioningStateUpdating - is updating
	ClusterProvisioningStateUpdating ClusterProvisioningState = "Updating"
)

func PossibleClusterProvisioningStateValues ¶

func PossibleClusterProvisioningStateValues() []ClusterProvisioningState

PossibleClusterProvisioningStateValues returns the possible values for the ClusterProvisioningState const type.

type ClusterUpdate ¶

type ClusterUpdate struct {
	// The properties of a cluster resource that may be updated
	Properties *ClusterUpdateProperties

	// The SKU (Stock Keeping Unit) assigned to this resource.
	SKU *SKU
}

ClusterUpdate - An update of a cluster resource

func (ClusterUpdate) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ClusterUpdate.

func (*ClusterUpdate) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterUpdate.

type ClusterUpdateProperties ¶

type ClusterUpdateProperties struct {
	// The cluster size
	ClusterSize *int32

	// The hosts
	Hosts []*string
}

ClusterUpdateProperties - The properties of a cluster that may be updated

func (ClusterUpdateProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ClusterUpdateProperties.

func (*ClusterUpdateProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterUpdateProperties.

type ClusterZone ¶

type ClusterZone struct {
	// READ-ONLY; List of hosts belonging to the availability zone in a cluster
	Hosts []*string

	// READ-ONLY; Availability zone identifier
	Zone *string
}

ClusterZone - Zone and associated hosts info

func (ClusterZone) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ClusterZone.

func (*ClusterZone) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterZone.

type ClusterZoneList ¶

type ClusterZoneList struct {
	// Zone and associated hosts info
	Zones []*ClusterZone
}

ClusterZoneList - List of all zones and associated hosts for a cluster

func (ClusterZoneList) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ClusterZoneList.

func (*ClusterZoneList) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterZoneList.

type ClustersClient ¶

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

ClustersClient contains the methods for the Clusters group. Don't use this type directly, use NewClustersClient() instead.

Generated from API version 2026-03-01

func NewClustersClient ¶

func NewClustersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClustersClient, error)

NewClustersClient creates a new instance of ClustersClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*ClustersClient) BeginCreateOrUpdate ¶

func (client *ClustersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster, options *ClustersClientBeginCreateOrUpdateOptions) (*runtime.Poller[ClustersClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a Cluster If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
cluster - Resource create parameters.
options - ClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the ClustersClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/Clusters_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClustersClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "cluster1", armavs.Cluster{
		SKU: &armavs.SKU{
			Name: to.Ptr("AV20"),
		},
		Properties: &armavs.ClusterProperties{
			ClusterSize: to.Ptr[int32](3),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armavs.ClustersClientCreateOrUpdateResponse{
	// 	Cluster: armavs.Cluster{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
	// 		Name: to.Ptr("cluster1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV20"),
	// 		},
	// 		Properties: &armavs.ClusterProperties{
	// 			ClusterSize: to.Ptr[int32](3),
	// 			Hosts: []*string{
	// 				to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.ClusterProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
	// 	},
	// }
}

Output:

func (*ClustersClient) BeginDelete ¶

func (client *ClustersClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, options *ClustersClientBeginDeleteOptions) (*runtime.Poller[ClustersClientDeleteResponse], error)

BeginDelete - Delete a Cluster If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - ClustersClientBeginDeleteOptions contains the optional parameters for the ClustersClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/Clusters_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClustersClient().BeginDelete(ctx, "group1", "cloud1", "cluster1", 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 poll 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 = armavs.ClustersClientDeleteResponse{
	// }
}

Output:

func (*ClustersClient) BeginUpdate ¶

func (client *ClustersClient) BeginUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate, options *ClustersClientBeginUpdateOptions) (*runtime.Poller[ClustersClientUpdateResponse], error)

BeginUpdate - Update a Cluster If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
clusterUpdate - The resource properties to be updated.
options - ClustersClientBeginUpdateOptions contains the optional parameters for the ClustersClient.BeginUpdate method.

Example ¶

Generated from example definition: 2026-03-01/Clusters_Update.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClustersClient().BeginUpdate(ctx, "group1", "cloud1", "cluster1", armavs.ClusterUpdate{
		Properties: &armavs.ClusterUpdateProperties{
			ClusterSize: to.Ptr[int32](4),
		},
	}, 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 poll 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 = armavs.ClustersClientUpdateResponse{
	// 	Cluster: armavs.Cluster{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
	// 		Name: to.Ptr("cluster1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV20"),
	// 		},
	// 		Properties: &armavs.ClusterProperties{
	// 			ClusterSize: to.Ptr[int32](4),
	// 			VsanDatastoreName: to.Ptr("vsanDatastore1"),
	// 			Hosts: []*string{
	// 				to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost25.nyc1.kubernetes.center"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.ClusterProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
	// 	},
	// }
}

Output:

func (*ClustersClient) Get ¶

func (client *ClustersClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, options *ClustersClientGetOptions) (ClustersClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - ClustersClientGetOptions contains the optional parameters for the ClustersClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/Clusters_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClustersClient().Get(ctx, "group1", "cloud1", "cluster1", 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 = armavs.ClustersClientGetResponse{
	// 	Cluster: armavs.Cluster{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
	// 		Name: to.Ptr("cluster1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV20"),
	// 		},
	// 		Properties: &armavs.ClusterProperties{
	// 			ClusterSize: to.Ptr[int32](4),
	// 			Hosts: []*string{
	// 				to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost25.nyc1.kubernetes.center"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.ClusterProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
	// 	},
	// }
}

Output:

func (*ClustersClient) ListZones ¶

func (client *ClustersClient) ListZones(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, options *ClustersClientListZonesOptions) (ClustersClientListZonesResponse, error)

ListZones - List hosts by zone in a cluster If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - ClustersClientListZonesOptions contains the optional parameters for the ClustersClient.ListZones method.

Example (ClustersListZones) ¶

Generated from example definition: 2026-03-01/Clusters_ListZones.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClustersClient().ListZones(ctx, "group1", "cloud1", "cluster1", 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 = armavs.ClustersClientListZonesResponse{
	// 	ClusterZoneList: armavs.ClusterZoneList{
	// 		Zones: []*armavs.ClusterZone{
	// 			{
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 				},
	// 				Zone: to.Ptr("2"),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

Example (ClustersListZonesStretched) ¶

Generated from example definition: 2026-03-01/Clusters_ListZones_Stretched.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClustersClient().ListZones(ctx, "group1", "cloud1", "cluster1", 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 = armavs.ClustersClientListZonesResponse{
	// 	ClusterZoneList: armavs.ClusterZoneList{
	// 		Zones: []*armavs.ClusterZone{
	// 			{
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 				},
	// 				Zone: to.Ptr("2"),
	// 			},
	// 			{
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost74.nyc2.kubernetes.center"),
	// 					to.Ptr("fakehost75.nyc2.kubernetes.center"),
	// 					to.Ptr("fakehost76.nyc2.kubernetes.center"),
	// 				},
	// 				Zone: to.Ptr("1"),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

func (*ClustersClient) NewListPager ¶

func (client *ClustersClient) NewListPager(resourceGroupName string, privateCloudName string, options *ClustersClientListOptions) *runtime.Pager[ClustersClientListResponse]

NewListPager - List Cluster resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - ClustersClientListOptions contains the optional parameters for the ClustersClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Clusters_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClustersClient().NewListPager("group1", "cloud1", 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 = armavs.ClustersClientListResponse{
		// 	ClusterList: armavs.ClusterList{
		// 		Value: []*armavs.Cluster{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
		// 				Name: to.Ptr("cluster1"),
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("AV20"),
		// 				},
		// 				Properties: &armavs.ClusterProperties{
		// 					ClusterSize: to.Ptr[int32](3),
		// 					Hosts: []*string{
		// 						to.Ptr("fakehost22.nyc1.kubernetes.center"),
		// 						to.Ptr("fakehost23.nyc1.kubernetes.center"),
		// 						to.Ptr("fakehost24.nyc1.kubernetes.center"),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.ClusterProvisioningStateSucceeded),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type ClustersClientBeginCreateOrUpdateOptions ¶

type ClustersClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the ClustersClient.BeginCreateOrUpdate method.

type ClustersClientBeginDeleteOptions ¶

type ClustersClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ClustersClientBeginDeleteOptions contains the optional parameters for the ClustersClient.BeginDelete method.

type ClustersClientBeginUpdateOptions ¶

type ClustersClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ClustersClientBeginUpdateOptions contains the optional parameters for the ClustersClient.BeginUpdate method.

type ClustersClientCreateOrUpdateResponse ¶

type ClustersClientCreateOrUpdateResponse struct {
	// A cluster resource
	Cluster
}

ClustersClientCreateOrUpdateResponse contains the response from method ClustersClient.BeginCreateOrUpdate.

type ClustersClientDeleteResponse ¶

type ClustersClientDeleteResponse struct {
}

ClustersClientDeleteResponse contains the response from method ClustersClient.BeginDelete.

type ClustersClientGetOptions ¶

type ClustersClientGetOptions struct {
}

ClustersClientGetOptions contains the optional parameters for the ClustersClient.Get method.

type ClustersClientGetResponse ¶

type ClustersClientGetResponse struct {
	// A cluster resource
	Cluster
}

ClustersClientGetResponse contains the response from method ClustersClient.Get.

type ClustersClientListOptions ¶

type ClustersClientListOptions struct {
}

ClustersClientListOptions contains the optional parameters for the ClustersClient.NewListPager method.

type ClustersClientListResponse ¶

type ClustersClientListResponse struct {
	// The response of a Cluster list operation.
	ClusterList
}

ClustersClientListResponse contains the response from method ClustersClient.NewListPager.

type ClustersClientListZonesOptions ¶

type ClustersClientListZonesOptions struct {
}

ClustersClientListZonesOptions contains the optional parameters for the ClustersClient.ListZones method.

type ClustersClientListZonesResponse ¶

type ClustersClientListZonesResponse struct {
	// List of all zones and associated hosts for a cluster
	ClusterZoneList
}

ClustersClientListZonesResponse contains the response from method ClustersClient.ListZones.

type ClustersClientUpdateResponse ¶

type ClustersClientUpdateResponse struct {
	// A cluster resource
	Cluster
}

ClustersClientUpdateResponse contains the response from method ClustersClient.BeginUpdate.

type CreatedByType ¶

type CreatedByType string

CreatedByType - The kind of entity that created the resource.

const (
	// CreatedByTypeApplication - The entity was created by an application.
	CreatedByTypeApplication CreatedByType = "Application"
	// CreatedByTypeKey - The entity was created by a key.
	CreatedByTypeKey CreatedByType = "Key"
	// CreatedByTypeManagedIdentity - The entity was created by a managed identity.
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	// CreatedByTypeUser - The entity was created by a user.
	CreatedByTypeUser CreatedByType = "User"
)

func PossibleCreatedByTypeValues ¶

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DNSServiceLogLevelEnum ¶

type DNSServiceLogLevelEnum string

DNSServiceLogLevelEnum - DNS service log level

const (
	// DNSServiceLogLevelEnumDEBUG - is debug
	DNSServiceLogLevelEnumDEBUG DNSServiceLogLevelEnum = "DEBUG"
	// DNSServiceLogLevelEnumERROR - is error
	DNSServiceLogLevelEnumERROR DNSServiceLogLevelEnum = "ERROR"
	// DNSServiceLogLevelEnumFATAL - is fatal
	DNSServiceLogLevelEnumFATAL DNSServiceLogLevelEnum = "FATAL"
	// DNSServiceLogLevelEnumINFO - is info
	DNSServiceLogLevelEnumINFO DNSServiceLogLevelEnum = "INFO"
	// DNSServiceLogLevelEnumWARNING - is warning
	DNSServiceLogLevelEnumWARNING DNSServiceLogLevelEnum = "WARNING"
)

func PossibleDNSServiceLogLevelEnumValues ¶

func PossibleDNSServiceLogLevelEnumValues() []DNSServiceLogLevelEnum

PossibleDNSServiceLogLevelEnumValues returns the possible values for the DNSServiceLogLevelEnum const type.

type DNSServiceStatusEnum ¶

type DNSServiceStatusEnum string

DNSServiceStatusEnum - DNS service status

const (
	// DNSServiceStatusEnumFAILURE - is failure
	DNSServiceStatusEnumFAILURE DNSServiceStatusEnum = "FAILURE"
	// DNSServiceStatusEnumSUCCESS - is success
	DNSServiceStatusEnumSUCCESS DNSServiceStatusEnum = "SUCCESS"
)

func PossibleDNSServiceStatusEnumValues ¶

func PossibleDNSServiceStatusEnumValues() []DNSServiceStatusEnum

PossibleDNSServiceStatusEnumValues returns the possible values for the DNSServiceStatusEnum const type.

type DNSZoneType ¶

type DNSZoneType string

DNSZoneType - The type of DNS zone.

const (
	// DNSZoneTypePrivate - Private DNS zone.
	DNSZoneTypePrivate DNSZoneType = "Private"
	// DNSZoneTypePublic - Primary DNS zone.
	DNSZoneTypePublic DNSZoneType = "Public"
)

func PossibleDNSZoneTypeValues ¶

func PossibleDNSZoneTypeValues() []DNSZoneType

PossibleDNSZoneTypeValues returns the possible values for the DNSZoneType const type.

type Datastore ¶

type Datastore struct {
	// The resource-specific properties for this resource.
	Properties *DatastoreProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

Datastore - A datastore resource

func (Datastore) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type Datastore.

func (*Datastore) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type Datastore.

type DatastoreList ¶

type DatastoreList struct {
	// REQUIRED; The Datastore items on this page
	Value []*Datastore

	// The link to the next page of items
	NextLink *string
}

DatastoreList - The response of a Datastore list operation.

func (DatastoreList) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type DatastoreList.

func (*DatastoreList) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type DatastoreList.

type DatastoreProperties ¶

type DatastoreProperties struct {
	// An iSCSI volume
	DiskPoolVolume *DiskPoolVolume

	// An Elastic SAN volume
	ElasticSanVolume *ElasticSanVolume

	// An Azure NetApp Files volume
	NetAppVolume *NetAppVolume

	// A Pure Storage volume
	PureStorageVolume *PureStorageVolume

	// READ-ONLY; The state of the datastore provisioning
	ProvisioningState *DatastoreProvisioningState

	// READ-ONLY; The operational status of the datastore
	Status *DatastoreStatus
}

DatastoreProperties - The properties of a datastore

func (DatastoreProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type DatastoreProperties.

func (*DatastoreProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type DatastoreProperties.

type DatastoreProvisioningState ¶

type DatastoreProvisioningState string

DatastoreProvisioningState - datastore provisioning state

const (
	// DatastoreProvisioningStateCanceled - Resource creation was canceled.
	DatastoreProvisioningStateCanceled DatastoreProvisioningState = "Canceled"
	// DatastoreProvisioningStateCancelled - is cancelled
	DatastoreProvisioningStateCancelled DatastoreProvisioningState = "Cancelled"
	// DatastoreProvisioningStateCreating - is creating
	DatastoreProvisioningStateCreating DatastoreProvisioningState = "Creating"
	// DatastoreProvisioningStateDeleting - is deleting
	DatastoreProvisioningStateDeleting DatastoreProvisioningState = "Deleting"
	// DatastoreProvisioningStateFailed - Resource creation failed.
	DatastoreProvisioningStateFailed DatastoreProvisioningState = "Failed"
	// DatastoreProvisioningStatePending - is pending
	DatastoreProvisioningStatePending DatastoreProvisioningState = "Pending"
	// DatastoreProvisioningStateSucceeded - Resource has been created.
	DatastoreProvisioningStateSucceeded DatastoreProvisioningState = "Succeeded"
	// DatastoreProvisioningStateUpdating - is updating
	DatastoreProvisioningStateUpdating DatastoreProvisioningState = "Updating"
)

func PossibleDatastoreProvisioningStateValues ¶

func PossibleDatastoreProvisioningStateValues() []DatastoreProvisioningState

PossibleDatastoreProvisioningStateValues returns the possible values for the DatastoreProvisioningState const type.

type DatastoreStatus ¶

type DatastoreStatus string

DatastoreStatus - datastore status

const (
	// DatastoreStatusAccessible - is accessible
	DatastoreStatusAccessible DatastoreStatus = "Accessible"
	// DatastoreStatusAttached - is attached
	DatastoreStatusAttached DatastoreStatus = "Attached"
	// DatastoreStatusDeadOrError - is dead or error
	DatastoreStatusDeadOrError DatastoreStatus = "DeadOrError"
	// DatastoreStatusDetached - is detached
	DatastoreStatusDetached DatastoreStatus = "Detached"
	// DatastoreStatusInaccessible - is inaccessible
	DatastoreStatusInaccessible DatastoreStatus = "Inaccessible"
	// DatastoreStatusLostCommunication - is lost communication
	DatastoreStatusLostCommunication DatastoreStatus = "LostCommunication"
	// DatastoreStatusUnknown - is unknown
	DatastoreStatusUnknown DatastoreStatus = "Unknown"
)

func PossibleDatastoreStatusValues ¶

func PossibleDatastoreStatusValues() []DatastoreStatus

PossibleDatastoreStatusValues returns the possible values for the DatastoreStatus const type.

type DatastoresClient ¶

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

DatastoresClient contains the methods for the Datastores group. Don't use this type directly, use NewDatastoresClient() instead.

Generated from API version 2026-03-01

func NewDatastoresClient ¶

func NewDatastoresClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DatastoresClient, error)

NewDatastoresClient creates a new instance of DatastoresClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*DatastoresClient) BeginCreateOrUpdate ¶

func (client *DatastoresClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, datastoreName string, datastore Datastore, options *DatastoresClientBeginCreateOrUpdateOptions) (*runtime.Poller[DatastoresClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a Datastore If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
datastoreName - Name of the datastore
datastore - Resource create parameters.
options - DatastoresClientBeginCreateOrUpdateOptions contains the optional parameters for the DatastoresClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/Datastores_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatastoresClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "cluster1", "datastore1", armavs.Datastore{
		Properties: &armavs.DatastoreProperties{
			NetAppVolume: &armavs.NetAppVolume{
				ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.NetApp/netAppAccounts/NetAppAccount1/capacityPools/CapacityPool1/volumes/NFSVol1"),
			},
		},
	}, 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 poll 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 = armavs.DatastoresClientCreateOrUpdateResponse{
	// 	Datastore: armavs.Datastore{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/datastores/datastore1"),
	// 		Name: to.Ptr("datastore1"),
	// 		Properties: &armavs.DatastoreProperties{
	// 			NetAppVolume: &armavs.NetAppVolume{
	// 				ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.NetApp/netAppAccounts/NetAppAccount1/capacityPools/CapacityPool1/volumes/NFSVol1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
	// 			Status: to.Ptr(armavs.DatastoreStatusAccessible),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/datastores"),
	// 	},
	// }
}

Output:

func (*DatastoresClient) BeginDelete ¶

func (client *DatastoresClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, datastoreName string, options *DatastoresClientBeginDeleteOptions) (*runtime.Poller[DatastoresClientDeleteResponse], error)

BeginDelete - Delete a Datastore If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
datastoreName - Name of the datastore
options - DatastoresClientBeginDeleteOptions contains the optional parameters for the DatastoresClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/Datastores_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatastoresClient().BeginDelete(ctx, "group1", "cloud1", "cluster1", "datastore1", 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 poll 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 = armavs.DatastoresClientDeleteResponse{
	// }
}

Output:

func (*DatastoresClient) Get ¶

func (client *DatastoresClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, datastoreName string, options *DatastoresClientGetOptions) (DatastoresClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
datastoreName - Name of the datastore
options - DatastoresClientGetOptions contains the optional parameters for the DatastoresClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/Datastores_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDatastoresClient().Get(ctx, "group1", "cloud1", "cluster1", "datastore1", 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 = armavs.DatastoresClientGetResponse{
	// 	Datastore: armavs.Datastore{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/datastores/datastore1"),
	// 		Name: to.Ptr("datastore1"),
	// 		Properties: &armavs.DatastoreProperties{
	// 			NetAppVolume: &armavs.NetAppVolume{
	// 				ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.NetApp/netAppAccounts/NetAppAccount1/capacityPools/CapacityPool1/volumes/NFSVol1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
	// 			Status: to.Ptr(armavs.DatastoreStatusAccessible),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/datastores"),
	// 	},
	// }
}

Output:

func (*DatastoresClient) NewListPager ¶

func (client *DatastoresClient) NewListPager(resourceGroupName string, privateCloudName string, clusterName string, options *DatastoresClientListOptions) *runtime.Pager[DatastoresClientListResponse]

NewListPager - List Datastore resources by Cluster

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - DatastoresClientListOptions contains the optional parameters for the DatastoresClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Datastores_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDatastoresClient().NewListPager("group1", "cloud1", "cluster1", 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 = armavs.DatastoresClientListResponse{
		// 	DatastoreList: armavs.DatastoreList{
		// 		Value: []*armavs.Datastore{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/datastores/datastore1"),
		// 				Name: to.Ptr("datastore1"),
		// 				Properties: &armavs.DatastoreProperties{
		// 					NetAppVolume: &armavs.NetAppVolume{
		// 						ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.NetApp/netAppAccounts/NetAppAccount1/capacityPools/CapacityPool1/volumes/NFSVol1"),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
		// 					Status: to.Ptr(armavs.DatastoreStatusAccessible),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/datastores"),
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/datastores/datastore2"),
		// 				Name: to.Ptr("datastore2"),
		// 				Properties: &armavs.DatastoreProperties{
		// 					DiskPoolVolume: &armavs.DiskPoolVolume{
		// 						TargetID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.StoragePool/diskPools/DiskPool1/targets/Target1"),
		// 						LunName: to.Ptr("lun0"),
		// 						MountOption: to.Ptr(armavs.MountOptionEnumMOUNT),
		// 						Path: to.Ptr("/vmfs/devices/disks/naa.6001405f75f6bdf7f6f49db8b4b21723"),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
		// 					Status: to.Ptr(armavs.DatastoreStatusAccessible),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/datastores"),
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/datastores/datastore2"),
		// 				Name: to.Ptr("datastore2"),
		// 				Properties: &armavs.DatastoreProperties{
		// 					ElasticSanVolume: &armavs.ElasticSanVolume{
		// 						TargetID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.ElasticSan/elasticSans/ElasticSan1/volumeGroups/VolumeGroup1/volumes/Volume1"),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
		// 					Status: to.Ptr(armavs.DatastoreStatusAccessible),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/datastores"),
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/datastores/datastore3"),
		// 				Name: to.Ptr("datastore3"),
		// 				Properties: &armavs.DatastoreProperties{
		// 					PureStorageVolume: &armavs.PureStorageVolume{
		// 						StoragePoolID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/PureStorage.Block/storagePools/storagePool1"),
		// 						SizeGb: to.Ptr[int32](64),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
		// 					Status: to.Ptr(armavs.DatastoreStatusAccessible),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/datastores"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type DatastoresClientBeginCreateOrUpdateOptions ¶

type DatastoresClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DatastoresClientBeginCreateOrUpdateOptions contains the optional parameters for the DatastoresClient.BeginCreateOrUpdate method.

type DatastoresClientBeginDeleteOptions ¶

type DatastoresClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DatastoresClientBeginDeleteOptions contains the optional parameters for the DatastoresClient.BeginDelete method.

type DatastoresClientCreateOrUpdateResponse ¶

type DatastoresClientCreateOrUpdateResponse struct {
	// A datastore resource
	Datastore
}

DatastoresClientCreateOrUpdateResponse contains the response from method DatastoresClient.BeginCreateOrUpdate.

type DatastoresClientDeleteResponse ¶

type DatastoresClientDeleteResponse struct {
}

DatastoresClientDeleteResponse contains the response from method DatastoresClient.BeginDelete.

type DatastoresClientGetOptions ¶

type DatastoresClientGetOptions struct {
}

DatastoresClientGetOptions contains the optional parameters for the DatastoresClient.Get method.

type DatastoresClientGetResponse ¶

type DatastoresClientGetResponse struct {
	// A datastore resource
	Datastore
}

DatastoresClientGetResponse contains the response from method DatastoresClient.Get.

type DatastoresClientListOptions ¶

type DatastoresClientListOptions struct {
}

DatastoresClientListOptions contains the optional parameters for the DatastoresClient.NewListPager method.

type DatastoresClientListResponse ¶

type DatastoresClientListResponse struct {
	// The response of a Datastore list operation.
	DatastoreList
}

DatastoresClientListResponse contains the response from method DatastoresClient.NewListPager.

type DhcpTypeEnum ¶

type DhcpTypeEnum string

DhcpTypeEnum - Type of DHCP: SERVER or RELAY.

const (
	DhcpTypeEnumRELAY  DhcpTypeEnum = "RELAY"
	DhcpTypeEnumSERVER DhcpTypeEnum = "SERVER"
)

func PossibleDhcpTypeEnumValues ¶

func PossibleDhcpTypeEnumValues() []DhcpTypeEnum

PossibleDhcpTypeEnumValues returns the possible values for the DhcpTypeEnum const type.

type DiskPoolVolume ¶

type DiskPoolVolume struct {
	// REQUIRED; Name of the LUN to be used for datastore
	LunName *string

	// REQUIRED; Azure resource ID of the iSCSI target
	TargetID *string

	// Mode that describes whether the LUN has to be mounted as a datastore or
	// attached as a LUN
	MountOption *MountOptionEnum

	// READ-ONLY; Device path
	Path *string
}

DiskPoolVolume - An iSCSI volume from Microsoft.StoragePool provider

func (DiskPoolVolume) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type DiskPoolVolume.

func (*DiskPoolVolume) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolVolume.

type ElasticSanVolume ¶

type ElasticSanVolume struct {
	// REQUIRED; Azure resource ID of the Elastic SAN Volume
	TargetID *string
}

ElasticSanVolume - An Elastic SAN volume from Microsoft.ElasticSan provider

func (ElasticSanVolume) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ElasticSanVolume.

func (*ElasticSanVolume) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ElasticSanVolume.

type Encryption ¶

type Encryption struct {
	// The key vault where the encryption key is stored
	KeyVaultProperties *EncryptionKeyVaultProperties

	// Status of customer managed encryption key
	Status *EncryptionState
}

Encryption - The properties of customer managed encryption key

func (Encryption) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type Encryption.

func (*Encryption) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type Encryption.

type EncryptionKeyStatus ¶

type EncryptionKeyStatus string

EncryptionKeyStatus - Whether the the encryption key is connected or access denied

const (
	// EncryptionKeyStatusAccessDenied - is access denied
	EncryptionKeyStatusAccessDenied EncryptionKeyStatus = "AccessDenied"
	// EncryptionKeyStatusConnected - is connected
	EncryptionKeyStatusConnected EncryptionKeyStatus = "Connected"
)

func PossibleEncryptionKeyStatusValues ¶

func PossibleEncryptionKeyStatusValues() []EncryptionKeyStatus

PossibleEncryptionKeyStatusValues returns the possible values for the EncryptionKeyStatus const type.

type EncryptionKeyVaultProperties ¶

type EncryptionKeyVaultProperties struct {
	// The name of the key.
	KeyName *string

	// The URL of the vault.
	KeyVaultURL *string

	// The version of the key.
	KeyVersion *string

	// READ-ONLY; The auto-detected version of the key if versionType is auto-detected.
	AutoDetectedKeyVersion *string

	// READ-ONLY; The state of key provided
	KeyState *EncryptionKeyStatus

	// READ-ONLY; Property of the key if user provided or auto detected
	VersionType *EncryptionVersionType
}

EncryptionKeyVaultProperties - An Encryption Key

func (EncryptionKeyVaultProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type EncryptionKeyVaultProperties.

func (*EncryptionKeyVaultProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionKeyVaultProperties.

type EncryptionState ¶

type EncryptionState string

EncryptionState - Whether encryption is enabled or disabled

const (
	// EncryptionStateDisabled - is disabled
	EncryptionStateDisabled EncryptionState = "Disabled"
	// EncryptionStateEnabled - is enabled
	EncryptionStateEnabled EncryptionState = "Enabled"
)

func PossibleEncryptionStateValues ¶

func PossibleEncryptionStateValues() []EncryptionState

PossibleEncryptionStateValues returns the possible values for the EncryptionState const type.

type EncryptionVersionType ¶

type EncryptionVersionType string

EncryptionVersionType - Whether the encryption version is fixed or auto-detected

const (
	// EncryptionVersionTypeAutoDetected - is auto-detected
	EncryptionVersionTypeAutoDetected EncryptionVersionType = "AutoDetected"
	// EncryptionVersionTypeFixed - is fixed
	EncryptionVersionTypeFixed EncryptionVersionType = "Fixed"
)

func PossibleEncryptionVersionTypeValues ¶

func PossibleEncryptionVersionTypeValues() []EncryptionVersionType

PossibleEncryptionVersionTypeValues returns the possible values for the EncryptionVersionType const type.

type Endpoints ¶

type Endpoints struct {
	// READ-ONLY; Endpoint FQDN for the HCX Cloud Manager
	HcxCloudManager *string

	// READ-ONLY; Endpoint IP for the HCX Cloud Manager
	HcxCloudManagerIP *string

	// READ-ONLY; Endpoint FQDN for the NSX-T Data Center manager
	NsxtManager *string

	// READ-ONLY; Endpoint IP for the NSX-T Data Center manager
	NsxtManagerIP *string

	// READ-ONLY; Endpoint IP for Virtual Center Server Appliance
	VcenterIP *string

	// READ-ONLY; Endpoint FQDN for Virtual Center Server Appliance
	Vcsa *string
}

Endpoints - Endpoint addresses

func (Endpoints) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type Endpoints.

func (*Endpoints) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type Endpoints.

type ExpressRouteAuthorization ¶

type ExpressRouteAuthorization struct {
	// The resource-specific properties for this resource.
	Properties *ExpressRouteAuthorizationProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

ExpressRouteAuthorization - ExpressRoute Circuit Authorization

func (ExpressRouteAuthorization) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ExpressRouteAuthorization.

func (*ExpressRouteAuthorization) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExpressRouteAuthorization.

type ExpressRouteAuthorizationList ¶

type ExpressRouteAuthorizationList struct {
	// REQUIRED; The ExpressRouteAuthorization items on this page
	Value []*ExpressRouteAuthorization

	// The link to the next page of items
	NextLink *string
}

ExpressRouteAuthorizationList - The response of a ExpressRouteAuthorization list operation.

func (ExpressRouteAuthorizationList) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ExpressRouteAuthorizationList.

func (*ExpressRouteAuthorizationList) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExpressRouteAuthorizationList.

type ExpressRouteAuthorizationProperties ¶

type ExpressRouteAuthorizationProperties struct {
	// The ID of the ExpressRoute Circuit
	ExpressRouteID *string

	// READ-ONLY; The ID of the ExpressRoute Circuit Authorization
	ExpressRouteAuthorizationID *string

	// READ-ONLY; The key of the ExpressRoute Circuit Authorization
	ExpressRouteAuthorizationKey *string

	// READ-ONLY; The state of the ExpressRoute Circuit Authorization provisioning
	ProvisioningState *ExpressRouteAuthorizationProvisioningState
}

ExpressRouteAuthorizationProperties - The properties of an ExpressRoute Circuit Authorization resource

func (ExpressRouteAuthorizationProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type ExpressRouteAuthorizationProperties.

func (*ExpressRouteAuthorizationProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExpressRouteAuthorizationProperties.

type ExpressRouteAuthorizationProvisioningState ¶

type ExpressRouteAuthorizationProvisioningState string

ExpressRouteAuthorizationProvisioningState - Express Route Circuit Authorization provisioning state

const (
	// ExpressRouteAuthorizationProvisioningStateCanceled - Resource creation was canceled.
	ExpressRouteAuthorizationProvisioningStateCanceled ExpressRouteAuthorizationProvisioningState = "Canceled"
	// ExpressRouteAuthorizationProvisioningStateFailed - Resource creation failed.
	ExpressRouteAuthorizationProvisioningStateFailed ExpressRouteAuthorizationProvisioningState = "Failed"
	// ExpressRouteAuthorizationProvisioningStateSucceeded - Resource has been created.
	ExpressRouteAuthorizationProvisioningStateSucceeded ExpressRouteAuthorizationProvisioningState = "Succeeded"
	// ExpressRouteAuthorizationProvisioningStateUpdating - is updating
	ExpressRouteAuthorizationProvisioningStateUpdating ExpressRouteAuthorizationProvisioningState = "Updating"
)

func PossibleExpressRouteAuthorizationProvisioningStateValues ¶

func PossibleExpressRouteAuthorizationProvisioningStateValues() []ExpressRouteAuthorizationProvisioningState

PossibleExpressRouteAuthorizationProvisioningStateValues returns the possible values for the ExpressRouteAuthorizationProvisioningState const type.

type GeneralHostProperties ¶ added in v2.1.0

type GeneralHostProperties struct {
	// REQUIRED; The kind of host.
	Kind *HostKind

	// Display name of the host in VMware vCenter.
	DisplayName *string

	// The licenses assigned to the host.
	Licenses []HostLicenseClassification

	// If provided, the host is in maintenance. The value is the reason for maintenance.
	Maintenance *HostMaintenance

	// READ-ONLY
	FaultDomain *string

	// READ-ONLY; Fully qualified domain name of the host.
	Fqdn *string

	// READ-ONLY; vCenter managed object reference ID of the host.
	MoRefID *string

	// READ-ONLY; The state of the host provisioning.
	ProvisioningState *HostProvisioningState
}

GeneralHostProperties - The properties of a general host.

func (*GeneralHostProperties) GetHostProperties ¶ added in v2.1.0

func (g *GeneralHostProperties) GetHostProperties() *HostProperties

GetHostProperties implements the HostPropertiesClassification interface for type GeneralHostProperties.

func (GeneralHostProperties) MarshalJSON ¶ added in v2.1.0

func (g GeneralHostProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GeneralHostProperties.

func (*GeneralHostProperties) UnmarshalJSON ¶ added in v2.1.0

func (g *GeneralHostProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GeneralHostProperties.

type GlobalReachConnection ¶

type GlobalReachConnection struct {
	// The resource-specific properties for this resource.
	Properties *GlobalReachConnectionProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

GlobalReachConnection - A global reach connection resource

func (GlobalReachConnection) MarshalJSON ¶

func (g GlobalReachConnection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GlobalReachConnection.

func (*GlobalReachConnection) UnmarshalJSON ¶

func (g *GlobalReachConnection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GlobalReachConnection.

type GlobalReachConnectionList ¶

type GlobalReachConnectionList struct {
	// REQUIRED; The GlobalReachConnection items on this page
	Value []*GlobalReachConnection

	// The link to the next page of items
	NextLink *string
}

GlobalReachConnectionList - The response of a GlobalReachConnection list operation.

func (GlobalReachConnectionList) MarshalJSON ¶

func (g GlobalReachConnectionList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GlobalReachConnectionList.

func (*GlobalReachConnectionList) UnmarshalJSON ¶

func (g *GlobalReachConnectionList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GlobalReachConnectionList.

type GlobalReachConnectionProperties ¶

type GlobalReachConnectionProperties struct {
	// Authorization key from the peer express route used for the global reach
	// connection
	AuthorizationKey *string

	// The ID of the Private Cloud's ExpressRoute Circuit that is participating in the
	// global reach connection
	ExpressRouteID *string

	// Identifier of the ExpressRoute Circuit to peer with in the global reach
	// connection
	PeerExpressRouteCircuit *string

	// READ-ONLY; The network used for global reach carved out from the original network block
	// provided for the private cloud
	AddressPrefix *string

	// READ-ONLY; The connection status of the global reach connection
	CircuitConnectionStatus *GlobalReachConnectionStatus

	// READ-ONLY; The state of the ExpressRoute Circuit Authorization provisioning
	ProvisioningState *GlobalReachConnectionProvisioningState
}

GlobalReachConnectionProperties - The properties of a global reach connection

func (GlobalReachConnectionProperties) MarshalJSON ¶

func (g GlobalReachConnectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GlobalReachConnectionProperties.

func (*GlobalReachConnectionProperties) UnmarshalJSON ¶

func (g *GlobalReachConnectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GlobalReachConnectionProperties.

type GlobalReachConnectionProvisioningState ¶

type GlobalReachConnectionProvisioningState string

GlobalReachConnectionProvisioningState - Global Reach Connection provisioning state

const (
	// GlobalReachConnectionProvisioningStateCanceled - Resource creation was canceled.
	GlobalReachConnectionProvisioningStateCanceled GlobalReachConnectionProvisioningState = "Canceled"
	// GlobalReachConnectionProvisioningStateFailed - Resource creation failed.
	GlobalReachConnectionProvisioningStateFailed GlobalReachConnectionProvisioningState = "Failed"
	// GlobalReachConnectionProvisioningStateSucceeded - Resource has been created.
	GlobalReachConnectionProvisioningStateSucceeded GlobalReachConnectionProvisioningState = "Succeeded"
	// GlobalReachConnectionProvisioningStateUpdating - is updating
	GlobalReachConnectionProvisioningStateUpdating GlobalReachConnectionProvisioningState = "Updating"
)

func PossibleGlobalReachConnectionProvisioningStateValues ¶

func PossibleGlobalReachConnectionProvisioningStateValues() []GlobalReachConnectionProvisioningState

PossibleGlobalReachConnectionProvisioningStateValues returns the possible values for the GlobalReachConnectionProvisioningState const type.

type GlobalReachConnectionStatus ¶

type GlobalReachConnectionStatus string

GlobalReachConnectionStatus - Global Reach Connection status

const (
	// GlobalReachConnectionStatusConnected - is connected
	GlobalReachConnectionStatusConnected GlobalReachConnectionStatus = "Connected"
	// GlobalReachConnectionStatusConnecting - is connecting
	GlobalReachConnectionStatusConnecting GlobalReachConnectionStatus = "Connecting"
	// GlobalReachConnectionStatusDisconnected - is disconnected
	GlobalReachConnectionStatusDisconnected GlobalReachConnectionStatus = "Disconnected"
)

func PossibleGlobalReachConnectionStatusValues ¶

func PossibleGlobalReachConnectionStatusValues() []GlobalReachConnectionStatus

PossibleGlobalReachConnectionStatusValues returns the possible values for the GlobalReachConnectionStatus const type.

type GlobalReachConnectionsClient ¶

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

GlobalReachConnectionsClient contains the methods for the GlobalReachConnections group. Don't use this type directly, use NewGlobalReachConnectionsClient() instead.

Generated from API version 2026-03-01

func NewGlobalReachConnectionsClient ¶

func NewGlobalReachConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*GlobalReachConnectionsClient, error)

NewGlobalReachConnectionsClient creates a new instance of GlobalReachConnectionsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*GlobalReachConnectionsClient) BeginCreateOrUpdate ¶

func (client *GlobalReachConnectionsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, globalReachConnectionName string, globalReachConnection GlobalReachConnection, options *GlobalReachConnectionsClientBeginCreateOrUpdateOptions) (*runtime.Poller[GlobalReachConnectionsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a GlobalReachConnection If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
globalReachConnectionName - Name of the global reach connection
globalReachConnection - Resource create parameters.
options - GlobalReachConnectionsClientBeginCreateOrUpdateOptions contains the optional parameters for the GlobalReachConnectionsClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/GlobalReachConnections_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewGlobalReachConnectionsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "connection1", armavs.GlobalReachConnection{
		Properties: &armavs.GlobalReachConnectionProperties{
			PeerExpressRouteCircuit: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.Network/expressRouteCircuits/mypeer"),
			AuthorizationKey:        to.Ptr("01010101-0101-0101-0101-010101010101"),
		},
	}, 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 poll 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 = armavs.GlobalReachConnectionsClientCreateOrUpdateResponse{
	// 	GlobalReachConnection: armavs.GlobalReachConnection{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/globalReachConnections/connection1"),
	// 		Name: to.Ptr("connection1"),
	// 		Properties: &armavs.GlobalReachConnectionProperties{
	// 			AddressPrefix: to.Ptr("10.2.3.16/29"),
	// 			AuthorizationKey: to.Ptr("01010101-0101-0101-0101-010101010101"),
	// 			CircuitConnectionStatus: to.Ptr(armavs.GlobalReachConnectionStatusConnected),
	// 			ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 			PeerExpressRouteCircuit: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.Network/expressRouteCircuits/mypeer"),
	// 			ProvisioningState: to.Ptr(armavs.GlobalReachConnectionProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/globalReachConnections"),
	// 	},
	// }
}

Output:

func (*GlobalReachConnectionsClient) BeginDelete ¶

func (client *GlobalReachConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, globalReachConnectionName string, options *GlobalReachConnectionsClientBeginDeleteOptions) (*runtime.Poller[GlobalReachConnectionsClientDeleteResponse], error)

BeginDelete - Delete a GlobalReachConnection If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
globalReachConnectionName - Name of the global reach connection
options - GlobalReachConnectionsClientBeginDeleteOptions contains the optional parameters for the GlobalReachConnectionsClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/GlobalReachConnections_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewGlobalReachConnectionsClient().BeginDelete(ctx, "group1", "cloud1", "connection1", 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 poll 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 = armavs.GlobalReachConnectionsClientDeleteResponse{
	// }
}

Output:

func (*GlobalReachConnectionsClient) Get ¶

func (client *GlobalReachConnectionsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, globalReachConnectionName string, options *GlobalReachConnectionsClientGetOptions) (GlobalReachConnectionsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
globalReachConnectionName - Name of the global reach connection
options - GlobalReachConnectionsClientGetOptions contains the optional parameters for the GlobalReachConnectionsClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/GlobalReachConnections_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewGlobalReachConnectionsClient().Get(ctx, "group1", "cloud1", "connection1", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armavs.GlobalReachConnectionsClientGetResponse{
	// 	GlobalReachConnection: armavs.GlobalReachConnection{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/globalReachConnections/connection1"),
	// 		Name: to.Ptr("connection1"),
	// 		Properties: &armavs.GlobalReachConnectionProperties{
	// 			AddressPrefix: to.Ptr("10.2.3.16/29"),
	// 			AuthorizationKey: to.Ptr("01010101-0101-0101-0101-010101010101"),
	// 			CircuitConnectionStatus: to.Ptr(armavs.GlobalReachConnectionStatusConnected),
	// 			ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 			PeerExpressRouteCircuit: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.Network/expressRouteCircuits/mypeer"),
	// 			ProvisioningState: to.Ptr(armavs.GlobalReachConnectionProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/globalReachConnections"),
	// 	},
	// }
}

Output:

func (*GlobalReachConnectionsClient) NewListPager ¶

func (client *GlobalReachConnectionsClient) NewListPager(resourceGroupName string, privateCloudName string, options *GlobalReachConnectionsClientListOptions) *runtime.Pager[GlobalReachConnectionsClientListResponse]

NewListPager - List GlobalReachConnection resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - GlobalReachConnectionsClientListOptions contains the optional parameters for the GlobalReachConnectionsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/GlobalReachConnections_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewGlobalReachConnectionsClient().NewListPager("group1", "cloud1", 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 = armavs.GlobalReachConnectionsClientListResponse{
		// 	GlobalReachConnectionList: armavs.GlobalReachConnectionList{
		// 		Value: []*armavs.GlobalReachConnection{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/globalReachConnections/connection1"),
		// 				Name: to.Ptr("connection1"),
		// 				Properties: &armavs.GlobalReachConnectionProperties{
		// 					AddressPrefix: to.Ptr("10.2.3.16/29"),
		// 					AuthorizationKey: to.Ptr("01010101-0101-0101-0101-010101010101"),
		// 					CircuitConnectionStatus: to.Ptr(armavs.GlobalReachConnectionStatusConnected),
		// 					ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
		// 					PeerExpressRouteCircuit: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.Network/expressRouteCircuits/mypeer"),
		// 					ProvisioningState: to.Ptr(armavs.GlobalReachConnectionProvisioningStateSucceeded),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/globalReachConnections"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type GlobalReachConnectionsClientBeginCreateOrUpdateOptions ¶

type GlobalReachConnectionsClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

GlobalReachConnectionsClientBeginCreateOrUpdateOptions contains the optional parameters for the GlobalReachConnectionsClient.BeginCreateOrUpdate method.

type GlobalReachConnectionsClientBeginDeleteOptions ¶

type GlobalReachConnectionsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

GlobalReachConnectionsClientBeginDeleteOptions contains the optional parameters for the GlobalReachConnectionsClient.BeginDelete method.

type GlobalReachConnectionsClientCreateOrUpdateResponse ¶

type GlobalReachConnectionsClientCreateOrUpdateResponse struct {
	// A global reach connection resource
	GlobalReachConnection
}

GlobalReachConnectionsClientCreateOrUpdateResponse contains the response from method GlobalReachConnectionsClient.BeginCreateOrUpdate.

type GlobalReachConnectionsClientDeleteResponse ¶

type GlobalReachConnectionsClientDeleteResponse struct {
}

GlobalReachConnectionsClientDeleteResponse contains the response from method GlobalReachConnectionsClient.BeginDelete.

type GlobalReachConnectionsClientGetOptions ¶

type GlobalReachConnectionsClientGetOptions struct {
}

GlobalReachConnectionsClientGetOptions contains the optional parameters for the GlobalReachConnectionsClient.Get method.

type GlobalReachConnectionsClientGetResponse ¶

type GlobalReachConnectionsClientGetResponse struct {
	// A global reach connection resource
	GlobalReachConnection
}

GlobalReachConnectionsClientGetResponse contains the response from method GlobalReachConnectionsClient.Get.

type GlobalReachConnectionsClientListOptions ¶

type GlobalReachConnectionsClientListOptions struct {
}

GlobalReachConnectionsClientListOptions contains the optional parameters for the GlobalReachConnectionsClient.NewListPager method.

type GlobalReachConnectionsClientListResponse ¶

type GlobalReachConnectionsClientListResponse struct {
	// The response of a GlobalReachConnection list operation.
	GlobalReachConnectionList
}

GlobalReachConnectionsClientListResponse contains the response from method GlobalReachConnectionsClient.NewListPager.

type HcxEnterpriseSite ¶

type HcxEnterpriseSite struct {
	// The resource-specific properties for this resource.
	Properties *HcxEnterpriseSiteProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

HcxEnterpriseSite - An HCX Enterprise Site resource

func (HcxEnterpriseSite) MarshalJSON ¶

func (h HcxEnterpriseSite) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HcxEnterpriseSite.

func (*HcxEnterpriseSite) UnmarshalJSON ¶

func (h *HcxEnterpriseSite) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HcxEnterpriseSite.

type HcxEnterpriseSiteList ¶

type HcxEnterpriseSiteList struct {
	// REQUIRED; The HcxEnterpriseSite items on this page
	Value []*HcxEnterpriseSite

	// The link to the next page of items
	NextLink *string
}

HcxEnterpriseSiteList - The response of a HcxEnterpriseSite list operation.

func (HcxEnterpriseSiteList) MarshalJSON ¶

func (h HcxEnterpriseSiteList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HcxEnterpriseSiteList.

func (*HcxEnterpriseSiteList) UnmarshalJSON ¶

func (h *HcxEnterpriseSiteList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HcxEnterpriseSiteList.

type HcxEnterpriseSiteProperties ¶

type HcxEnterpriseSiteProperties struct {
	// READ-ONLY; The activation key
	ActivationKey *string

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

	// READ-ONLY; The status of the HCX Enterprise Site
	Status *HcxEnterpriseSiteStatus
}

HcxEnterpriseSiteProperties - The properties of an HCX Enterprise Site

func (HcxEnterpriseSiteProperties) MarshalJSON ¶

func (h HcxEnterpriseSiteProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HcxEnterpriseSiteProperties.

func (*HcxEnterpriseSiteProperties) UnmarshalJSON ¶

func (h *HcxEnterpriseSiteProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HcxEnterpriseSiteProperties.

type HcxEnterpriseSiteProvisioningState ¶

type HcxEnterpriseSiteProvisioningState string

HcxEnterpriseSiteProvisioningState - HCX Enterprise Site provisioning state

const (
	// HcxEnterpriseSiteProvisioningStateCanceled - Resource creation was canceled.
	HcxEnterpriseSiteProvisioningStateCanceled HcxEnterpriseSiteProvisioningState = "Canceled"
	// HcxEnterpriseSiteProvisioningStateFailed - Resource creation failed.
	HcxEnterpriseSiteProvisioningStateFailed HcxEnterpriseSiteProvisioningState = "Failed"
	// HcxEnterpriseSiteProvisioningStateSucceeded - Resource has been created.
	HcxEnterpriseSiteProvisioningStateSucceeded HcxEnterpriseSiteProvisioningState = "Succeeded"
)

func PossibleHcxEnterpriseSiteProvisioningStateValues ¶

func PossibleHcxEnterpriseSiteProvisioningStateValues() []HcxEnterpriseSiteProvisioningState

PossibleHcxEnterpriseSiteProvisioningStateValues returns the possible values for the HcxEnterpriseSiteProvisioningState const type.

type HcxEnterpriseSiteStatus ¶

type HcxEnterpriseSiteStatus string

HcxEnterpriseSiteStatus - HCX Enterprise Site status

const (
	// HcxEnterpriseSiteStatusAvailable - is available
	HcxEnterpriseSiteStatusAvailable HcxEnterpriseSiteStatus = "Available"
	// HcxEnterpriseSiteStatusConsumed - is consumed
	HcxEnterpriseSiteStatusConsumed HcxEnterpriseSiteStatus = "Consumed"
	// HcxEnterpriseSiteStatusDeactivated - is deactivated
	HcxEnterpriseSiteStatusDeactivated HcxEnterpriseSiteStatus = "Deactivated"
	// HcxEnterpriseSiteStatusDeleted - is deleted
	HcxEnterpriseSiteStatusDeleted HcxEnterpriseSiteStatus = "Deleted"
)

func PossibleHcxEnterpriseSiteStatusValues ¶

func PossibleHcxEnterpriseSiteStatusValues() []HcxEnterpriseSiteStatus

PossibleHcxEnterpriseSiteStatusValues returns the possible values for the HcxEnterpriseSiteStatus const type.

type HcxEnterpriseSitesClient ¶

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

HcxEnterpriseSitesClient contains the methods for the HcxEnterpriseSites group. Don't use this type directly, use NewHcxEnterpriseSitesClient() instead.

Generated from API version 2026-03-01

func NewHcxEnterpriseSitesClient ¶

func NewHcxEnterpriseSitesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*HcxEnterpriseSitesClient, error)

NewHcxEnterpriseSitesClient creates a new instance of HcxEnterpriseSitesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*HcxEnterpriseSitesClient) CreateOrUpdate ¶

func (client *HcxEnterpriseSitesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite HcxEnterpriseSite, options *HcxEnterpriseSitesClientCreateOrUpdateOptions) (HcxEnterpriseSitesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Create a HcxEnterpriseSite If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
hcxEnterpriseSiteName - Name of the HCX Enterprise Site
hcxEnterpriseSite - Resource create parameters.
options - HcxEnterpriseSitesClientCreateOrUpdateOptions contains the optional parameters for the HcxEnterpriseSitesClient.CreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/HcxEnterpriseSites_CreateOrUpdate.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHcxEnterpriseSitesClient().CreateOrUpdate(ctx, "group1", "cloud1", "site1", armavs.HcxEnterpriseSite{}, 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 = armavs.HcxEnterpriseSitesClientCreateOrUpdateResponse{
	// 	HcxEnterpriseSite: armavs.HcxEnterpriseSite{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/hcxEnterpriseSites/site1"),
	// 		Name: to.Ptr("site1"),
	// 		Properties: &armavs.HcxEnterpriseSiteProperties{
	// 			ActivationKey: to.Ptr("0276EF1A9A1749A5A362BF73EA9F8D0D"),
	// 			Status: to.Ptr(armavs.HcxEnterpriseSiteStatusAvailable),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites"),
	// 	},
	// }
}

Output:

func (*HcxEnterpriseSitesClient) Delete ¶

func (client *HcxEnterpriseSitesClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, options *HcxEnterpriseSitesClientDeleteOptions) (HcxEnterpriseSitesClientDeleteResponse, error)

Delete - Delete a HcxEnterpriseSite If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
hcxEnterpriseSiteName - Name of the HCX Enterprise Site
options - HcxEnterpriseSitesClientDeleteOptions contains the optional parameters for the HcxEnterpriseSitesClient.Delete method.

Example ¶

Generated from example definition: 2026-03-01/HcxEnterpriseSites_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHcxEnterpriseSitesClient().Delete(ctx, "group1", "cloud1", "site1", 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 = armavs.HcxEnterpriseSitesClientDeleteResponse{
	// }
}

Output:

func (*HcxEnterpriseSitesClient) Get ¶

func (client *HcxEnterpriseSitesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, options *HcxEnterpriseSitesClientGetOptions) (HcxEnterpriseSitesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
hcxEnterpriseSiteName - Name of the HCX Enterprise Site
options - HcxEnterpriseSitesClientGetOptions contains the optional parameters for the HcxEnterpriseSitesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/HcxEnterpriseSites_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHcxEnterpriseSitesClient().Get(ctx, "group1", "cloud1", "site1", 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 = armavs.HcxEnterpriseSitesClientGetResponse{
	// 	HcxEnterpriseSite: armavs.HcxEnterpriseSite{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/hcxEnterpriseSites/site1"),
	// 		Name: to.Ptr("site1"),
	// 		Properties: &armavs.HcxEnterpriseSiteProperties{
	// 			ActivationKey: to.Ptr("0276EF1A9A1749A5A362BF73EA9F8D0D"),
	// 			Status: to.Ptr(armavs.HcxEnterpriseSiteStatusAvailable),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites"),
	// 	},
	// }
}

Output:

func (*HcxEnterpriseSitesClient) NewListPager ¶

func (client *HcxEnterpriseSitesClient) NewListPager(resourceGroupName string, privateCloudName string, options *HcxEnterpriseSitesClientListOptions) *runtime.Pager[HcxEnterpriseSitesClientListResponse]

NewListPager - List HcxEnterpriseSite resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - HcxEnterpriseSitesClientListOptions contains the optional parameters for the HcxEnterpriseSitesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/HcxEnterpriseSites_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewHcxEnterpriseSitesClient().NewListPager("group1", "cloud1", 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 = armavs.HcxEnterpriseSitesClientListResponse{
		// 	HcxEnterpriseSiteList: armavs.HcxEnterpriseSiteList{
		// 		Value: []*armavs.HcxEnterpriseSite{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/hcxEnterpriseSites/site1"),
		// 				Name: to.Ptr("site1"),
		// 				Properties: &armavs.HcxEnterpriseSiteProperties{
		// 					ActivationKey: to.Ptr("0276EF1A9A1749A5A362BF73EA9F8D0D"),
		// 					Status: to.Ptr(armavs.HcxEnterpriseSiteStatusAvailable),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type HcxEnterpriseSitesClientCreateOrUpdateOptions ¶

type HcxEnterpriseSitesClientCreateOrUpdateOptions struct {
}

HcxEnterpriseSitesClientCreateOrUpdateOptions contains the optional parameters for the HcxEnterpriseSitesClient.CreateOrUpdate method.

type HcxEnterpriseSitesClientCreateOrUpdateResponse ¶

type HcxEnterpriseSitesClientCreateOrUpdateResponse struct {
	// An HCX Enterprise Site resource
	HcxEnterpriseSite
}

HcxEnterpriseSitesClientCreateOrUpdateResponse contains the response from method HcxEnterpriseSitesClient.CreateOrUpdate.

type HcxEnterpriseSitesClientDeleteOptions ¶

type HcxEnterpriseSitesClientDeleteOptions struct {
}

HcxEnterpriseSitesClientDeleteOptions contains the optional parameters for the HcxEnterpriseSitesClient.Delete method.

type HcxEnterpriseSitesClientDeleteResponse ¶

type HcxEnterpriseSitesClientDeleteResponse struct {
}

HcxEnterpriseSitesClientDeleteResponse contains the response from method HcxEnterpriseSitesClient.Delete.

type HcxEnterpriseSitesClientGetOptions ¶

type HcxEnterpriseSitesClientGetOptions struct {
}

HcxEnterpriseSitesClientGetOptions contains the optional parameters for the HcxEnterpriseSitesClient.Get method.

type HcxEnterpriseSitesClientGetResponse ¶

type HcxEnterpriseSitesClientGetResponse struct {
	// An HCX Enterprise Site resource
	HcxEnterpriseSite
}

HcxEnterpriseSitesClientGetResponse contains the response from method HcxEnterpriseSitesClient.Get.

type HcxEnterpriseSitesClientListOptions ¶

type HcxEnterpriseSitesClientListOptions struct {
}

HcxEnterpriseSitesClientListOptions contains the optional parameters for the HcxEnterpriseSitesClient.NewListPager method.

type HcxEnterpriseSitesClientListResponse ¶

type HcxEnterpriseSitesClientListResponse struct {
	// The response of a HcxEnterpriseSite list operation.
	HcxEnterpriseSiteList
}

HcxEnterpriseSitesClientListResponse contains the response from method HcxEnterpriseSitesClient.NewListPager.

type Host ¶ added in v2.1.0

type Host struct {
	// The resource-specific properties for this resource.
	Properties HostPropertiesClassification

	// The SKU (Stock Keeping Unit) assigned to this resource.
	SKU *SKU

	// The availability zones.
	Zones []*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

Host - A host resource

func (Host) MarshalJSON ¶ added in v2.1.0

func (h Host) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Host.

func (*Host) UnmarshalJSON ¶ added in v2.1.0

func (h *Host) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Host.

type HostKind ¶ added in v2.1.0

type HostKind string

HostKind - The kind of host.

const (
	HostKindGeneral     HostKind = "General"
	HostKindSpecialized HostKind = "Specialized"
)

func PossibleHostKindValues ¶ added in v2.1.0

func PossibleHostKindValues() []HostKind

PossibleHostKindValues returns the possible values for the HostKind const type.

type HostLicense ¶

type HostLicense struct {
	// REQUIRED; License kind
	Kind *HostLicenseKind
}

HostLicense - A license assigned to a host.

func (*HostLicense) GetHostLicense ¶

func (h *HostLicense) GetHostLicense() *HostLicense

GetHostLicense implements the HostLicenseClassification interface for type HostLicense.

func (HostLicense) MarshalJSON ¶

func (h HostLicense) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HostLicense.

func (*HostLicense) UnmarshalJSON ¶

func (h *HostLicense) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HostLicense.

type HostLicenseClassification ¶

type HostLicenseClassification interface {
	// GetHostLicense returns the HostLicense content of the underlying type.
	GetHostLicense() *HostLicense
}

HostLicenseClassification provides polymorphic access to related types. Call the interface's GetHostLicense() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *HostLicense, *WindowsServerLicense

type HostLicenseKind ¶

type HostLicenseKind string

HostLicenseKind - The kind of host license.

const (
	// HostLicenseKindWindowsServer - The host is to be used with Azure Hybrid Benefit for Windows Server.
	HostLicenseKindWindowsServer HostLicenseKind = "WindowsServer"
)

func PossibleHostLicenseKindValues ¶

func PossibleHostLicenseKindValues() []HostLicenseKind

PossibleHostLicenseKindValues returns the possible values for the HostLicenseKind const type.

type HostListResult ¶ added in v2.1.0

type HostListResult struct {
	// REQUIRED; The Host items on this page
	Value []*Host

	// The link to the next page of items
	NextLink *string
}

HostListResult - The response of a Host list operation.

func (HostListResult) MarshalJSON ¶ added in v2.1.0

func (h HostListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HostListResult.

func (*HostListResult) UnmarshalJSON ¶ added in v2.1.0

func (h *HostListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HostListResult.

type HostMaintenance ¶ added in v2.1.0

type HostMaintenance string

HostMaintenance - The reason for host maintenance.

const (
	// HostMaintenanceReplacement - The host is a replacement host.
	HostMaintenanceReplacement HostMaintenance = "Replacement"
	// HostMaintenanceUpgrade - The host is for an upgrade, such as an upgrade to ESXi, NSX-T, or other component.
	HostMaintenanceUpgrade HostMaintenance = "Upgrade"
)

func PossibleHostMaintenanceValues ¶ added in v2.1.0

func PossibleHostMaintenanceValues() []HostMaintenance

PossibleHostMaintenanceValues returns the possible values for the HostMaintenance const type.

type HostProperties ¶ added in v2.1.0

type HostProperties struct {
	// REQUIRED; The kind of host
	Kind *HostKind

	// Display name of the host in VMware vCenter.
	DisplayName *string

	// The licenses assigned to the host.
	Licenses []HostLicenseClassification

	// If provided, the host is in maintenance. The value is the reason for maintenance.
	Maintenance *HostMaintenance

	// READ-ONLY
	FaultDomain *string

	// READ-ONLY; Fully qualified domain name of the host.
	Fqdn *string

	// READ-ONLY; vCenter managed object reference ID of the host.
	MoRefID *string

	// READ-ONLY; The state of the host provisioning.
	ProvisioningState *HostProvisioningState
}

HostProperties - The properties of a host.

func (*HostProperties) GetHostProperties ¶ added in v2.1.0

func (h *HostProperties) GetHostProperties() *HostProperties

GetHostProperties implements the HostPropertiesClassification interface for type HostProperties.

func (HostProperties) MarshalJSON ¶ added in v2.1.0

func (h HostProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HostProperties.

func (*HostProperties) UnmarshalJSON ¶ added in v2.1.0

func (h *HostProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HostProperties.

type HostPropertiesClassification ¶ added in v2.1.0

type HostPropertiesClassification interface {
	// GetHostProperties returns the HostProperties content of the underlying type.
	GetHostProperties() *HostProperties
}

HostPropertiesClassification provides polymorphic access to related types. Call the interface's GetHostProperties() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *GeneralHostProperties, *HostProperties, *SpecializedHostProperties

type HostProvisioningState ¶ added in v2.1.0

type HostProvisioningState string

HostProvisioningState - provisioning state of the host

const (
	// HostProvisioningStateCanceled - Resource creation was canceled.
	HostProvisioningStateCanceled HostProvisioningState = "Canceled"
	// HostProvisioningStateFailed - Resource creation failed.
	HostProvisioningStateFailed HostProvisioningState = "Failed"
	// HostProvisioningStateSucceeded - Resource has been created.
	HostProvisioningStateSucceeded HostProvisioningState = "Succeeded"
)

func PossibleHostProvisioningStateValues ¶ added in v2.1.0

func PossibleHostProvisioningStateValues() []HostProvisioningState

PossibleHostProvisioningStateValues returns the possible values for the HostProvisioningState const type.

type HostUpdate ¶

type HostUpdate struct {
	// The properties of a host resource that may be updated
	Properties *HostUpdateProperties
}

HostUpdate - The properties of a host to update.

func (HostUpdate) MarshalJSON ¶

func (h HostUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HostUpdate.

func (*HostUpdate) UnmarshalJSON ¶

func (h *HostUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HostUpdate.

type HostUpdateProperties ¶

type HostUpdateProperties struct {
	// The licenses assigned to the host.
	Licenses []HostLicenseClassification
}

HostUpdateProperties - The properties for updating a host.

func (HostUpdateProperties) MarshalJSON ¶

func (h HostUpdateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HostUpdateProperties.

func (*HostUpdateProperties) UnmarshalJSON ¶

func (h *HostUpdateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HostUpdateProperties.

type HostsClient ¶ added in v2.1.0

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

HostsClient contains the methods for the Hosts group. Don't use this type directly, use NewHostsClient() instead.

Generated from API version 2026-03-01

func NewHostsClient ¶ added in v2.1.0

func NewHostsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*HostsClient, error)

NewHostsClient creates a new instance of HostsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*HostsClient) Get ¶ added in v2.1.0

func (client *HostsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, hostID string, options *HostsClientGetOptions) (HostsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
hostID - The host identifier.
options - HostsClientGetOptions contains the optional parameters for the HostsClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/Hosts_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHostsClient().Get(ctx, "group1", "cloud1", "cluster1", "esx03-r52.1111111111111111111.westcentralus.prod.azure.com", 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 = armavs.HostsClientGetResponse{
	// 	Host: armavs.Host{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/Hosts/esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 		Name: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/hosts"),
	// 		Zones: []*string{
	// 			to.Ptr("1"),
	// 		},
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("av64"),
	// 		},
	// 		Properties: &armavs.GeneralHostProperties{
	// 			Kind: to.Ptr(armavs.HostKindGeneral),
	// 			DisplayName: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 			MoRefID: to.Ptr("host-209"),
	// 			Fqdn: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 			FaultDomain: to.Ptr("1"),
	// 		},
	// 	},
	// }
}

Output:

func (*HostsClient) NewListPager ¶ added in v2.1.0

func (client *HostsClient) NewListPager(resourceGroupName string, privateCloudName string, clusterName string, options *HostsClientListOptions) *runtime.Pager[HostsClientListResponse]

NewListPager - List Host resources by Cluster

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - HostsClientListOptions contains the optional parameters for the HostsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Hosts_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewHostsClient().NewListPager("group1", "cloud1", "cluster1", 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 = armavs.HostsClientListResponse{
		// 	HostListResult: armavs.HostListResult{
		// 		Value: []*armavs.Host{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/hosts/esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
		// 				Name: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/hosts"),
		// 				Zones: []*string{
		// 					to.Ptr("1"),
		// 				},
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("av64"),
		// 				},
		// 				Properties: &armavs.GeneralHostProperties{
		// 					Kind: to.Ptr(armavs.HostKindGeneral),
		// 					DisplayName: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
		// 					MoRefID: to.Ptr("host-209"),
		// 					Fqdn: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
		// 					FaultDomain: to.Ptr("1"),
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/hosts/esx03-r60.1111111111111111111.westcentralus.prod.azure.com"),
		// 				Name: to.Ptr("esx03-r60.1111111111111111111.westcentralus.prod.azure.com"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/hosts"),
		// 				Zones: []*string{
		// 					to.Ptr("1"),
		// 				},
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("av64"),
		// 				},
		// 				Properties: &armavs.GeneralHostProperties{
		// 					Kind: to.Ptr(armavs.HostKindGeneral),
		// 					DisplayName: to.Ptr("esx03-r60.1111111111111111111.westcentralus.prod.azure.com"),
		// 					MoRefID: to.Ptr("host-128"),
		// 					Maintenance: to.Ptr(armavs.HostMaintenanceReplacement),
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/hosts/esx03-r65.1111111111111111111.westcentralus.prod.azure.com"),
		// 				Name: to.Ptr("esx03-r65.1111111111111111111.westcentralus.prod.azure.com"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/hosts"),
		// 				Zones: []*string{
		// 					to.Ptr("1"),
		// 				},
		// 				Properties: &armavs.SpecializedHostProperties{
		// 					Kind: to.Ptr(armavs.HostKindSpecialized),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*HostsClient) Update ¶

func (client *HostsClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, hostID string, properties HostUpdate, options *HostsClientUpdateOptions) (HostsClientUpdateResponse, error)

Update - Update a Host If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
hostID - The host identifier.
properties - The resource properties to be updated.
options - HostsClientUpdateOptions contains the optional parameters for the HostsClient.Update method.

Example ¶

Generated from example definition: 2026-03-01/Hosts_Update.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHostsClient().Update(ctx, "group1", "cloud1", "cluster1", "esx03-r52.1111111111111111111.westcentralus.prod.azure.com", armavs.HostUpdate{
		Properties: &armavs.HostUpdateProperties{
			Licenses: []armavs.HostLicenseClassification{
				&armavs.WindowsServerLicense{
					Kind: to.Ptr(armavs.HostLicenseKindWindowsServer),
				},
			},
		},
	}, 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 = armavs.HostsClientUpdateResponse{
	// 	Host: armavs.Host{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/Hosts/esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 		Name: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/hosts"),
	// 		Zones: []*string{
	// 			to.Ptr("1"),
	// 		},
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("av64"),
	// 		},
	// 		Properties: &armavs.GeneralHostProperties{
	// 			Kind: to.Ptr(armavs.HostKindGeneral),
	// 			DisplayName: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 			MoRefID: to.Ptr("host-209"),
	// 			Fqdn: to.Ptr("esx03-r52.1111111111111111111.westcentralus.prod.azure.com"),
	// 			FaultDomain: to.Ptr("1"),
	// 			Licenses: []armavs.HostLicenseClassification{
	// 				&armavs.WindowsServerLicense{
	// 					Kind: to.Ptr(armavs.HostLicenseKindWindowsServer),
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}

Output:

type HostsClientGetOptions ¶ added in v2.1.0

type HostsClientGetOptions struct {
}

HostsClientGetOptions contains the optional parameters for the HostsClient.Get method.

type HostsClientGetResponse ¶ added in v2.1.0

type HostsClientGetResponse struct {
	// A host resource
	Host
}

HostsClientGetResponse contains the response from method HostsClient.Get.

type HostsClientListOptions ¶ added in v2.1.0

type HostsClientListOptions struct {
}

HostsClientListOptions contains the optional parameters for the HostsClient.NewListPager method.

type HostsClientListResponse ¶ added in v2.1.0

type HostsClientListResponse struct {
	// The response of a Host list operation.
	HostListResult
}

HostsClientListResponse contains the response from method HostsClient.NewListPager.

type HostsClientUpdateOptions ¶

type HostsClientUpdateOptions struct {
}

HostsClientUpdateOptions contains the optional parameters for the HostsClient.Update method.

type HostsClientUpdateResponse ¶

type HostsClientUpdateResponse struct {
	// A host resource
	Host
}

HostsClientUpdateResponse contains the response from method HostsClient.Update.

type IdentitySource ¶

type IdentitySource struct {
	// The domain's NetBIOS name
	Alias *string

	// The base distinguished name for groups
	BaseGroupDN *string

	// The base distinguished name for users
	BaseUserDN *string

	// The domain's DNS name
	Domain *string

	// The name of the identity source
	Name *string

	// The password of the Active Directory user with a minimum of read-only access to
	// Base DN for users and groups.
	Password *string

	// Primary server URL
	PrimaryServer *string

	// Protect LDAP communication using SSL certificate (LDAPS)
	SSL *SSLEnum

	// Secondary server URL
	SecondaryServer *string

	// The ID of an Active Directory user with a minimum of read-only access to Base
	// DN for users and group
	Username *string
}

IdentitySource - vCenter Single Sign On Identity Source

func (IdentitySource) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type IdentitySource.

func (*IdentitySource) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type IdentitySource.

type ImpactedMaintenanceResource ¶ added in v2.2.0

type ImpactedMaintenanceResource struct {
	// READ-ONLY; A list of errors associated with the impacted resource
	Errors []*ImpactedMaintenanceResourceError

	// READ-ONLY; The ID of the impacted resource
	ID *string
}

ImpactedMaintenanceResource - Details about a resource impacted by a failed check

func (ImpactedMaintenanceResource) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type ImpactedMaintenanceResource.

func (*ImpactedMaintenanceResource) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type ImpactedMaintenanceResource.

type ImpactedMaintenanceResourceError ¶ added in v2.2.0

type ImpactedMaintenanceResourceError struct {
	// READ-ONLY; Indicates whether action is required by the customer
	ActionRequired *bool

	// READ-ONLY; Additional details about the error
	Details *string

	// READ-ONLY; The error code
	ErrorCode *string

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

	// READ-ONLY; Steps to resolve the error
	ResolutionSteps []*string
}

ImpactedMaintenanceResourceError - Details about an error affecting a resource

func (ImpactedMaintenanceResourceError) MarshalJSON ¶ added in v2.2.0

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

MarshalJSON implements the json.Marshaller interface for type ImpactedMaintenanceResourceError.

func (*ImpactedMaintenanceResourceError) UnmarshalJSON ¶ added in v2.2.0

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

UnmarshalJSON implements the json.Unmarshaller interface for type ImpactedMaintenanceResourceError.

type InternetEnum ¶

type InternetEnum string

InternetEnum - Whether internet is enabled or disabled

const (
	// InternetEnumDisabled - is disabled
	InternetEnumDisabled InternetEnum = "Disabled"
	// InternetEnumEnabled - is enabled
	InternetEnumEnabled InternetEnum = "Enabled"
)

func PossibleInternetEnumValues ¶

func PossibleInternetEnumValues() []InternetEnum

PossibleInternetEnumValues returns the possible values for the InternetEnum const type.

type IscsiPath ¶

type IscsiPath struct {
	// The resource-specific properties for this resource.
	Properties *IscsiPathProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

IscsiPath - An iSCSI path resource

func (IscsiPath) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type IscsiPath.

func (*IscsiPath) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiPath.

type IscsiPathListResult ¶

type IscsiPathListResult struct {
	// REQUIRED; The IscsiPath items on this page
	Value []*IscsiPath

	// The link to the next page of items
	NextLink *string
}

IscsiPathListResult - The response of a IscsiPath list operation.

func (IscsiPathListResult) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type IscsiPathListResult.

func (*IscsiPathListResult) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiPathListResult.

type IscsiPathProperties ¶

type IscsiPathProperties struct {
	// REQUIRED; CIDR Block for iSCSI path.
	NetworkBlock *string

	// READ-ONLY; The state of the iSCSI path provisioning
	ProvisioningState *IscsiPathProvisioningState
}

IscsiPathProperties - The properties of an iSCSI path resource

func (IscsiPathProperties) MarshalJSON ¶

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

MarshalJSON implements the json.Marshaller interface for type IscsiPathProperties.

func (*IscsiPathProperties) UnmarshalJSON ¶

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

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiPathProperties.

type IscsiPathProvisioningState ¶

type IscsiPathProvisioningState string

IscsiPathProvisioningState - private cloud provisioning state

const (
	// IscsiPathProvisioningStateBuilding - is building
	IscsiPathProvisioningStateBuilding IscsiPathProvisioningState = "Building"
	// IscsiPathProvisioningStateCanceled - Resource creation was canceled.
	IscsiPathProvisioningStateCanceled IscsiPathProvisioningState = "Canceled"
	// IscsiPathProvisioningStateDeleting - is deleting
	IscsiPathProvisioningStateDeleting IscsiPathProvisioningState = "Deleting"
	// IscsiPathProvisioningStateFailed - Resource creation failed.
	IscsiPathProvisioningStateFailed IscsiPathProvisioningState = "Failed"
	// IscsiPathProvisioningStatePending - is pending
	IscsiPathProvisioningStatePending IscsiPathProvisioningState = "Pending"
	// IscsiPathProvisioningStateSucceeded - Resource has been created.
	IscsiPathProvisioningStateSucceeded IscsiPathProvisioningState = "Succeeded"
	// IscsiPathProvisioningStateUpdating - is updating
	IscsiPathProvisioningStateUpdating IscsiPathProvisioningState = "Updating"
)

func PossibleIscsiPathProvisioningStateValues ¶

func PossibleIscsiPathProvisioningStateValues() []IscsiPathProvisioningState

PossibleIscsiPathProvisioningStateValues returns the possible values for the IscsiPathProvisioningState const type.

type IscsiPathsClient ¶

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

IscsiPathsClient contains the methods for the IscsiPaths group. Don't use this type directly, use NewIscsiPathsClient() instead.

Generated from API version 2026-03-01

func NewIscsiPathsClient ¶

func NewIscsiPathsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IscsiPathsClient, error)

NewIscsiPathsClient creates a new instance of IscsiPathsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*IscsiPathsClient) BeginCreateOrUpdate ¶

func (client *IscsiPathsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, resource IscsiPath, options *IscsiPathsClientBeginCreateOrUpdateOptions) (*runtime.Poller[IscsiPathsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a IscsiPath If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
resource - Resource create parameters.
options - IscsiPathsClientBeginCreateOrUpdateOptions contains the optional parameters for the IscsiPathsClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/IscsiPaths_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIscsiPathsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", armavs.IscsiPath{
		Properties: &armavs.IscsiPathProperties{
			NetworkBlock: to.Ptr("192.168.0.0/24"),
		},
	}, 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 poll 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 = armavs.IscsiPathsClientCreateOrUpdateResponse{
	// 	IscsiPath: armavs.IscsiPath{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/iscsiPaths/default"),
	// 		Name: to.Ptr("default"),
	// 		Properties: &armavs.IscsiPathProperties{
	// 			NetworkBlock: to.Ptr("192.168.0.0/24"),
	// 			ProvisioningState: to.Ptr(armavs.IscsiPathProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/iscsiPaths"),
	// 	},
	// }
}

Output:

func (*IscsiPathsClient) BeginDelete ¶

func (client *IscsiPathsClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, options *IscsiPathsClientBeginDeleteOptions) (*runtime.Poller[IscsiPathsClientDeleteResponse], error)

BeginDelete - Delete a IscsiPath If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - IscsiPathsClientBeginDeleteOptions contains the optional parameters for the IscsiPathsClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/IscsiPaths_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIscsiPathsClient().BeginDelete(ctx, "group1", "cloud1", 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 poll 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 = armavs.IscsiPathsClientDeleteResponse{
	// }
}

Output:

func (*IscsiPathsClient) Get ¶

func (client *IscsiPathsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, options *IscsiPathsClientGetOptions) (IscsiPathsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - IscsiPathsClientGetOptions contains the optional parameters for the IscsiPathsClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/IscsiPaths_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIscsiPathsClient().Get(ctx, "group1", "cloud1", 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 = armavs.IscsiPathsClientGetResponse{
	// 	IscsiPath: armavs.IscsiPath{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/iscsiPaths/default"),
	// 		Name: to.Ptr("default"),
	// 		Properties: &armavs.IscsiPathProperties{
	// 			NetworkBlock: to.Ptr("192.168.0.0/24"),
	// 			ProvisioningState: to.Ptr(armavs.IscsiPathProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/iscsiPaths"),
	// 	},
	// }
}

Output:

func (*IscsiPathsClient) NewListByPrivateCloudPager ¶

func (client *IscsiPathsClient) NewListByPrivateCloudPager(resourceGroupName string, privateCloudName string, options *IscsiPathsClientListByPrivateCloudOptions) *runtime.Pager[IscsiPathsClientListByPrivateCloudResponse]

NewListByPrivateCloudPager - List IscsiPath resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - IscsiPathsClientListByPrivateCloudOptions contains the optional parameters for the IscsiPathsClient.NewListByPrivateCloudPager method.

Example ¶

Generated from example definition: 2026-03-01/IscsiPaths_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIscsiPathsClient().NewListByPrivateCloudPager("group1", "cloud1", 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 = armavs.IscsiPathsClientListByPrivateCloudResponse{
		// 	IscsiPathListResult: armavs.IscsiPathListResult{
		// 		Value: []*armavs.IscsiPath{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/iscsiPaths/default"),
		// 				Name: to.Ptr("default"),
		// 				Properties: &armavs.IscsiPathProperties{
		// 					NetworkBlock: to.Ptr("192.168.0.0/24"),
		// 					ProvisioningState: to.Ptr(armavs.IscsiPathProvisioningStateSucceeded),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/iscsiPaths"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type IscsiPathsClientBeginCreateOrUpdateOptions ¶

type IscsiPathsClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

IscsiPathsClientBeginCreateOrUpdateOptions contains the optional parameters for the IscsiPathsClient.BeginCreateOrUpdate method.

type IscsiPathsClientBeginDeleteOptions ¶

type IscsiPathsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

IscsiPathsClientBeginDeleteOptions contains the optional parameters for the IscsiPathsClient.BeginDelete method.

type IscsiPathsClientCreateOrUpdateResponse ¶

type IscsiPathsClientCreateOrUpdateResponse struct {
	// An iSCSI path resource
	IscsiPath
}

IscsiPathsClientCreateOrUpdateResponse contains the response from method IscsiPathsClient.BeginCreateOrUpdate.

type IscsiPathsClientDeleteResponse ¶

type IscsiPathsClientDeleteResponse struct {
}

IscsiPathsClientDeleteResponse contains the response from method IscsiPathsClient.BeginDelete.

type IscsiPathsClientGetOptions ¶

type IscsiPathsClientGetOptions struct {
}

IscsiPathsClientGetOptions contains the optional parameters for the IscsiPathsClient.Get method.

type IscsiPathsClientGetResponse ¶

type IscsiPathsClientGetResponse struct {
	// An iSCSI path resource
	IscsiPath
}

IscsiPathsClientGetResponse contains the response from method IscsiPathsClient.Get.

type IscsiPathsClientListByPrivateCloudOptions ¶

type IscsiPathsClientListByPrivateCloudOptions struct {
}

IscsiPathsClientListByPrivateCloudOptions contains the optional parameters for the IscsiPathsClient.NewListByPrivateCloudPager method.

type IscsiPathsClientListByPrivateCloudResponse ¶

type IscsiPathsClientListByPrivateCloudResponse struct {
	// The response of a IscsiPath list operation.
	IscsiPathListResult
}

IscsiPathsClientListByPrivateCloudResponse contains the response from method IscsiPathsClient.NewListByPrivateCloudPager.

type Label ¶ added in v2.2.0

type Label struct {
	// REQUIRED; The key of the label.
	Key *string

	// REQUIRED; The value of the label.
	Value *string
}

Label - A key-value pair representing a label.

func (Label) MarshalJSON ¶ added in v2.2.0

func (l Label) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Label.

func (*Label) UnmarshalJSON ¶ added in v2.2.0

func (l *Label) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Label.

type License ¶ added in v2.2.0

type License struct {
	// The resource-specific properties for this resource.
	Properties LicensePropertiesClassification

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

License - A license resource

func (License) MarshalJSON ¶ added in v2.2.0

func (l License) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type License.

func (*License) UnmarshalJSON ¶ added in v2.2.0

func (l *License) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type License.

type LicenseKind ¶ added in v2.2.0

type LicenseKind string

LicenseKind - The kind of license.

const (
	LicenseKindVmwareFirewall LicenseKind = "VmwareFirewall"
)

func PossibleLicenseKindValues ¶ added in v2.2.0

func PossibleLicenseKindValues() []LicenseKind

PossibleLicenseKindValues returns the possible values for the LicenseKind const type.

type LicenseListResult ¶ added in v2.2.0

type LicenseListResult struct {
	// REQUIRED; The License items on this page
	Value []*License

	// The link to the next page of items
	NextLink *string
}

LicenseListResult - The response of a License list operation.

func (LicenseListResult) MarshalJSON ¶ added in v2.2.0

func (l LicenseListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LicenseListResult.

func (*LicenseListResult) UnmarshalJSON ¶ added in v2.2.0

func (l *LicenseListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LicenseListResult.

type LicenseName ¶ added in v2.2.0

type LicenseName string

LicenseName - The name of the license.

const (
	// LicenseNameVmwareFirewall - VMware Firewall license
	LicenseNameVmwareFirewall LicenseName = "VmwareFirewall"
)

func PossibleLicenseNameValues ¶ added in v2.2.0

func PossibleLicenseNameValues() []LicenseName

PossibleLicenseNameValues returns the possible values for the LicenseName const type.

type LicenseProperties ¶ added in v2.2.0

type LicenseProperties struct {
	// REQUIRED; License kind
	Kind *LicenseKind

	// READ-ONLY; The state of the license provisioning
	ProvisioningState *LicenseProvisioningState
}

LicenseProperties - The properties of a license

func (*LicenseProperties) GetLicenseProperties ¶ added in v2.2.0

func (l *LicenseProperties) GetLicenseProperties() *LicenseProperties

GetLicenseProperties implements the LicensePropertiesClassification interface for type LicenseProperties.

func (LicenseProperties) MarshalJSON ¶ added in v2.2.0

func (l LicenseProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LicenseProperties.

func (*LicenseProperties) UnmarshalJSON ¶ added in v2.2.0

func (l *LicenseProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LicenseProperties.

type LicensePropertiesClassification ¶ added in v2.2.0

type LicensePropertiesClassification interface {
	// GetLicenseProperties returns the LicenseProperties content of the underlying type.
	GetLicenseProperties() *LicenseProperties
}

LicensePropertiesClassification provides polymorphic access to related types. Call the interface's GetLicenseProperties() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *LicenseProperties, *VmwareFirewallLicenseProperties

type LicenseProvisioningState ¶ added in v2.2.0

type LicenseProvisioningState string

LicenseProvisioningState - provisioning state of the license

const (
	// LicenseProvisioningStateCanceled - Resource creation was canceled.
	LicenseProvisioningStateCanceled LicenseProvisioningState = "Canceled"
	// LicenseProvisioningStateFailed - Resource creation failed.
	LicenseProvisioningStateFailed LicenseProvisioningState = "Failed"
	// LicenseProvisioningStateSucceeded - Resource has been created.
	LicenseProvisioningStateSucceeded LicenseProvisioningState = "Succeeded"
)

func PossibleLicenseProvisioningStateValues ¶ added in v2.2.0

func PossibleLicenseProvisioningStateValues() []LicenseProvisioningState

PossibleLicenseProvisioningStateValues returns the possible values for the LicenseProvisioningState const type.

type LicensesClient ¶ added in v2.2.0

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

LicensesClient contains the methods for the Licenses group. Don't use this type directly, use NewLicensesClient() instead.

Generated from API version 2026-03-01

func NewLicensesClient ¶ added in v2.2.0

func NewLicensesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LicensesClient, error)

NewLicensesClient creates a new instance of LicensesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*LicensesClient) BeginCreateOrUpdate ¶ added in v2.2.0

func (client *LicensesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, licenseName LicenseName, resource License, options *LicensesClientBeginCreateOrUpdateOptions) (*runtime.Poller[LicensesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a License If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
licenseName - Name of the license.
resource - Resource create parameters.
options - LicensesClientBeginCreateOrUpdateOptions contains the optional parameters for the LicensesClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/Licenses_CreateOrUpdate.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewLicensesClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", armavs.LicenseNameVmwareFirewall, armavs.License{}, 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 poll 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 = armavs.LicensesClientCreateOrUpdateResponse{
	// 	License: armavs.License{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/licenses/VmwareFirewall"),
	// 		Name: to.Ptr("VmwareFirewall"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/licenses"),
	// 		Properties: &armavs.VmwareFirewallLicenseProperties{
	// 			Kind: to.Ptr(armavs.LicenseKindVmwareFirewall),
	// 			EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 			Cores: to.Ptr[int32](16),
	// 			BroadcomSiteID: to.Ptr("123456"),
	// 			BroadcomContractNumber: to.Ptr("123456"),
	// 			ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 		},
	// 	},
	// }
}

Output:

func (*LicensesClient) BeginDelete ¶ added in v2.2.0

func (client *LicensesClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, licenseName LicenseName, options *LicensesClientBeginDeleteOptions) (*runtime.Poller[LicensesClientDeleteResponse], error)

BeginDelete - Delete a License If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
licenseName - Name of the license.
options - LicensesClientBeginDeleteOptions contains the optional parameters for the LicensesClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/Licenses_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewLicensesClient().BeginDelete(ctx, "group1", "cloud1", armavs.LicenseNameVmwareFirewall, 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 poll the result: %v", err)
	}
}

Output:

func (*LicensesClient) Get ¶ added in v2.2.0

func (client *LicensesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, licenseName LicenseName, options *LicensesClientGetOptions) (LicensesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
licenseName - Name of the license.
options - LicensesClientGetOptions contains the optional parameters for the LicensesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/Licenses_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLicensesClient().Get(ctx, "group1", "cloud1", armavs.LicenseNameVmwareFirewall, 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 = armavs.LicensesClientGetResponse{
	// 	License: armavs.License{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/licenses/VmwareFirewall"),
	// 		Name: to.Ptr("VmwareFirewall"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/licenses"),
	// 		Properties: &armavs.VmwareFirewallLicenseProperties{
	// 			Kind: to.Ptr(armavs.LicenseKindVmwareFirewall),
	// 			ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 			EndDate: to.Ptr(time.Date(2025, time.June, 1, 0, 0, 0, 0, time.UTC)),
	// 			Cores: to.Ptr[int32](16),
	// 			BroadcomSiteID: to.Ptr("123456"),
	// 			BroadcomContractNumber: to.Ptr("123456"),
	// 		},
	// 	},
	// }
}

Output:

func (*LicensesClient) GetProperties ¶ added in v2.2.0

func (client *LicensesClient) GetProperties(ctx context.Context, resourceGroupName string, privateCloudName string, licenseName LicenseName, options *LicensesClientGetPropertiesOptions) (LicensesClientGetPropertiesResponse, error)

GetProperties - Just like ArmResourceActionSync, but with no request body. If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
licenseName - Name of the license.
options - LicensesClientGetPropertiesOptions contains the optional parameters for the LicensesClient.GetProperties method.

Example ¶

Generated from example definition: 2026-03-01/Licenses_GetProperties.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLicensesClient().GetProperties(ctx, "group1", "cloud1", armavs.LicenseNameVmwareFirewall, 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 = armavs.LicensesClientGetPropertiesResponse{
	// 	LicensePropertiesClassification: &armavs.VmwareFirewallLicenseProperties{
	// 		LicenseKey: to.Ptr("12345-12345-12345-12345-12345"),
	// 		EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 		Cores: to.Ptr[int32](16),
	// 		BroadcomSiteID: to.Ptr("123456"),
	// 		BroadcomContractNumber: to.Ptr("123456"),
	// 		Kind: to.Ptr(armavs.LicenseKindVmwareFirewall),
	// 		ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*LicensesClient) NewListPager ¶ added in v2.2.0

func (client *LicensesClient) NewListPager(resourceGroupName string, privateCloudName string, options *LicensesClientListOptions) *runtime.Pager[LicensesClientListResponse]

NewListPager - List License resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - LicensesClientListOptions contains the optional parameters for the LicensesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Licenses_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewLicensesClient().NewListPager("group1", "cloud1", 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 = armavs.LicensesClientListResponse{
		// 	LicenseListResult: armavs.LicenseListResult{
		// 		Value: []*armavs.License{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/licenses/vcf-license-001"),
		// 				Name: to.Ptr("VmwareFirewall"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/licenses"),
		// 				Properties: &armavs.VmwareFirewallLicenseProperties{
		// 					Kind: to.Ptr(armavs.LicenseKindVmwareFirewall),
		// 					ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
		// 					EndDate: to.Ptr(time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC)),
		// 					Cores: to.Ptr[int32](64),
		// 					BroadcomSiteID: to.Ptr("123456"),
		// 					BroadcomContractNumber: to.Ptr("123456"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type LicensesClientBeginCreateOrUpdateOptions ¶ added in v2.2.0

type LicensesClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

LicensesClientBeginCreateOrUpdateOptions contains the optional parameters for the LicensesClient.BeginCreateOrUpdate method.

type LicensesClientBeginDeleteOptions ¶ added in v2.2.0

type LicensesClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

LicensesClientBeginDeleteOptions contains the optional parameters for the LicensesClient.BeginDelete method.

type LicensesClientCreateOrUpdateResponse ¶ added in v2.2.0

type LicensesClientCreateOrUpdateResponse struct {
	// A license resource
	License
}

LicensesClientCreateOrUpdateResponse contains the response from method LicensesClient.BeginCreateOrUpdate.

type LicensesClientDeleteResponse ¶ added in v2.2.0

type LicensesClientDeleteResponse struct {
}

LicensesClientDeleteResponse contains the response from method LicensesClient.BeginDelete.

type LicensesClientGetOptions ¶ added in v2.2.0

type LicensesClientGetOptions struct {
}

LicensesClientGetOptions contains the optional parameters for the LicensesClient.Get method.

type LicensesClientGetPropertiesOptions ¶ added in v2.2.0

type LicensesClientGetPropertiesOptions struct {
}

LicensesClientGetPropertiesOptions contains the optional parameters for the LicensesClient.GetProperties method.

type LicensesClientGetPropertiesResponse ¶ added in v2.2.0

type LicensesClientGetPropertiesResponse struct {
	// The properties of a license
	LicensePropertiesClassification
}

LicensesClientGetPropertiesResponse contains the response from method LicensesClient.GetProperties.

func (*LicensesClientGetPropertiesResponse) UnmarshalJSON ¶ added in v2.2.0

func (l *LicensesClientGetPropertiesResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LicensesClientGetPropertiesResponse.

type LicensesClientGetResponse ¶ added in v2.2.0

type LicensesClientGetResponse struct {
	// A license resource
	License
}

LicensesClientGetResponse contains the response from method LicensesClient.Get.

type LicensesClientListOptions ¶ added in v2.2.0

type LicensesClientListOptions struct {
}

LicensesClientListOptions contains the optional parameters for the LicensesClient.NewListPager method.

type LicensesClientListResponse ¶ added in v2.2.0

type LicensesClientListResponse struct {
	// The response of a License list operation.
	LicenseListResult
}

LicensesClientListResponse contains the response from method LicensesClient.NewListPager.

type LocationsClient ¶

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

LocationsClient contains the methods for the Locations group. Don't use this type directly, use NewLocationsClient() instead.

Generated from API version 2026-03-01

func NewLocationsClient ¶

func NewLocationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LocationsClient, error)

NewLocationsClient creates a new instance of LocationsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*LocationsClient) CheckQuotaAvailability ¶

func (client *LocationsClient) CheckQuotaAvailability(ctx context.Context, location string, options *LocationsClientCheckQuotaAvailabilityOptions) (LocationsClientCheckQuotaAvailabilityResponse, error)

CheckQuotaAvailability - Return quota for subscription by region If the operation fails it returns an *azcore.ResponseError type.

location - A location in a subscription
options - LocationsClientCheckQuotaAvailabilityOptions contains the optional parameters for the LocationsClient.CheckQuotaAvailability method.

Example ¶

Generated from example definition: 2026-03-01/Locations_CheckQuotaAvailability.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLocationsClient().CheckQuotaAvailability(ctx, "eastus", 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 = armavs.LocationsClientCheckQuotaAvailabilityResponse{
	// 	Quota: armavs.Quota{
	// 		HostsRemaining: map[string]*int32{
	// 			"AV20": to.Ptr[int32](0),
	// 			"AV36": to.Ptr[int32](999),
	// 		},
	// 		QuotaEnabled: to.Ptr(armavs.QuotaEnabledEnabled),
	// 	},
	// }
}

Output:

func (*LocationsClient) CheckTrialAvailability ¶

func (client *LocationsClient) CheckTrialAvailability(ctx context.Context, location string, options *LocationsClientCheckTrialAvailabilityOptions) (LocationsClientCheckTrialAvailabilityResponse, error)

CheckTrialAvailability - Return trial status for subscription by region If the operation fails it returns an *azcore.ResponseError type.

location - A location in a subscription
options - LocationsClientCheckTrialAvailabilityOptions contains the optional parameters for the LocationsClient.CheckTrialAvailability method.

Example (LocationsCheckTrialAvailability) ¶

Generated from example definition: 2026-03-01/Locations_CheckTrialAvailability.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLocationsClient().CheckTrialAvailability(ctx, "eastus", 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 = armavs.LocationsClientCheckTrialAvailabilityResponse{
	// 	Trial: armavs.Trial{
	// 		Status: to.Ptr(armavs.TrialStatusTrialAvailable),
	// 		AvailableHosts: to.Ptr[int32](4),
	// 	},
	// }
}

Output:

Example (LocationsCheckTrialAvailabilityWithSku) ¶

Generated from example definition: 2026-03-01/Locations_CheckTrialAvailabilityWithSku.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLocationsClient().CheckTrialAvailability(ctx, "eastus", &armavs.LocationsClientCheckTrialAvailabilityOptions{
		SKU: &armavs.SKU{
			Name: to.Ptr("avs52t"),
		}})
	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 = armavs.LocationsClientCheckTrialAvailabilityResponse{
	// 	Trial: armavs.Trial{
	// 		Status: to.Ptr(armavs.TrialStatusTrialAvailable),
	// 		AvailableHosts: to.Ptr[int32](4),
	// 	},
	// }
}

Output:

type LocationsClientCheckQuotaAvailabilityOptions ¶

type LocationsClientCheckQuotaAvailabilityOptions struct {
}

LocationsClientCheckQuotaAvailabilityOptions contains the optional parameters for the LocationsClient.CheckQuotaAvailability method.

type LocationsClientCheckQuotaAvailabilityResponse ¶

type LocationsClientCheckQuotaAvailabilityResponse struct {
	// Subscription quotas
	Quota
}

LocationsClientCheckQuotaAvailabilityResponse contains the response from method LocationsClient.CheckQuotaAvailability.

type LocationsClientCheckTrialAvailabilityOptions ¶

type LocationsClientCheckTrialAvailabilityOptions struct {
	// Optionally, check for a specific SKU
	SKU *SKU
}

LocationsClientCheckTrialAvailabilityOptions contains the optional parameters for the LocationsClient.CheckTrialAvailability method.

type LocationsClientCheckTrialAvailabilityResponse ¶

type LocationsClientCheckTrialAvailabilityResponse struct {
	// Subscription trial availability
	Trial
}

LocationsClientCheckTrialAvailabilityResponse contains the response from method LocationsClient.CheckTrialAvailability.

type Maintenance ¶ added in v2.2.0

type Maintenance struct {
	// The resource-specific properties for this resource.
	Properties *MaintenanceProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

Maintenance - A cluster resource

func (Maintenance) MarshalJSON ¶ added in v2.2.0

func (m Maintenance) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Maintenance.

func (*Maintenance) UnmarshalJSON ¶ added in v2.2.0

func (m *Maintenance) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Maintenance.

type MaintenanceActivity ¶

type MaintenanceActivity struct {
	// READ-ONLY; The component on which the activity is performed
	Component *string

	// READ-ONLY; The type of activity
	Kind *MaintenanceActivityKind

	// READ-ONLY; Target version of the component
	Version *string

	// READ-ONLY; Describes impact of the activity
	Impact *string

	// READ-ONLY; Optional link containing more details about the activity
	InfoLink *string
}

MaintenanceActivity - Represents a maintenance activity performed as part of an operation

func (MaintenanceActivity) MarshalJSON ¶

func (m MaintenanceActivity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceActivity.

func (*MaintenanceActivity) UnmarshalJSON ¶

func (m *MaintenanceActivity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceActivity.

type MaintenanceActivityKind ¶

type MaintenanceActivityKind string

MaintenanceActivityKind - Defines the type of maintenance activity

const (
	// MaintenanceActivityKindBackup - Backup activity
	MaintenanceActivityKindBackup MaintenanceActivityKind = "Backup"
	// MaintenanceActivityKindCertificateRotation - Certificate rotation activity
	MaintenanceActivityKindCertificateRotation MaintenanceActivityKind = "CertificateRotation"
	// MaintenanceActivityKindDowngrade - Downgrade activity
	MaintenanceActivityKindDowngrade MaintenanceActivityKind = "Downgrade"
	// MaintenanceActivityKindUpgrade - Upgrade activity
	MaintenanceActivityKindUpgrade MaintenanceActivityKind = "Upgrade"
)

func PossibleMaintenanceActivityKindValues ¶

func PossibleMaintenanceActivityKindValues() []MaintenanceActivityKind

PossibleMaintenanceActivityKindValues returns the possible values for the MaintenanceActivityKind const type.

type MaintenanceCheckType ¶ added in v2.2.0

type MaintenanceCheckType string

MaintenanceCheckType - Defines the type of maintenance readiness check

const (
	// MaintenanceCheckTypePrecheck - Pre-check maintenance readiness
	MaintenanceCheckTypePrecheck MaintenanceCheckType = "Precheck"
	// MaintenanceCheckTypePreflight - Pre-flight maintenance readiness
	MaintenanceCheckTypePreflight MaintenanceCheckType = "Preflight"
)

func PossibleMaintenanceCheckTypeValues ¶ added in v2.2.0

func PossibleMaintenanceCheckTypeValues() []MaintenanceCheckType

PossibleMaintenanceCheckTypeValues returns the possible values for the MaintenanceCheckType const type.

type MaintenanceFailedCheck ¶ added in v2.2.0

type MaintenanceFailedCheck struct {
	// READ-ONLY; A list of resources impacted by the failed check
	ImpactedResources []*ImpactedMaintenanceResource

	// READ-ONLY; The name of the failed check
	Name *string
}

MaintenanceFailedCheck - Details about a failed maintenance check

func (MaintenanceFailedCheck) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceFailedCheck) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceFailedCheck.

func (*MaintenanceFailedCheck) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceFailedCheck) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceFailedCheck.

type MaintenanceGroup ¶

type MaintenanceGroup struct {
	// READ-ONLY; Unique identifier of the group
	ID *string

	// READ-ONLY; Type of the group
	Kind *MaintenanceGroupKind

	// READ-ONLY; Display name of the group
	Name *string
}

MaintenanceGroup - Represents a maintenance group

func (MaintenanceGroup) MarshalJSON ¶

func (m MaintenanceGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceGroup.

func (*MaintenanceGroup) UnmarshalJSON ¶

func (m *MaintenanceGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceGroup.

type MaintenanceGroupKind ¶

type MaintenanceGroupKind string

MaintenanceGroupKind - Defines the kind of group

const (
	// MaintenanceGroupKindConsolidation - Consolidation grouping of maintenance operations
	MaintenanceGroupKindConsolidation MaintenanceGroupKind = "Consolidation"
	// MaintenanceGroupKindLogical - Logical grouping of maintenance operations
	MaintenanceGroupKindLogical MaintenanceGroupKind = "Logical"
)

func PossibleMaintenanceGroupKindValues ¶

func PossibleMaintenanceGroupKindValues() []MaintenanceGroupKind

PossibleMaintenanceGroupKindValues returns the possible values for the MaintenanceGroupKind const type.

type MaintenanceListResult ¶ added in v2.2.0

type MaintenanceListResult struct {
	// REQUIRED; The Maintenance items on this page
	Value []*Maintenance

	// The link to the next page of items
	NextLink *string
}

MaintenanceListResult - The response of a Maintenance list operation.

func (MaintenanceListResult) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceListResult.

func (*MaintenanceListResult) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceListResult.

type MaintenanceManagementOperation ¶ added in v2.2.0

type MaintenanceManagementOperation struct {
	// READ-ONLY; The kind of operation
	Kind *MaintenanceManagementOperationKind
}

MaintenanceManagementOperation - Defines operations that can be performed on maintenance

func (*MaintenanceManagementOperation) GetMaintenanceManagementOperation ¶ added in v2.2.0

func (m *MaintenanceManagementOperation) GetMaintenanceManagementOperation() *MaintenanceManagementOperation

GetMaintenanceManagementOperation implements the MaintenanceManagementOperationClassification interface for type MaintenanceManagementOperation.

func (MaintenanceManagementOperation) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceManagementOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceManagementOperation.

func (*MaintenanceManagementOperation) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceManagementOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceManagementOperation.

type MaintenanceManagementOperationClassification ¶ added in v2.2.0

type MaintenanceManagementOperationClassification interface {
	// GetMaintenanceManagementOperation returns the MaintenanceManagementOperation content of the underlying type.
	GetMaintenanceManagementOperation() *MaintenanceManagementOperation
}

MaintenanceManagementOperationClassification provides polymorphic access to related types. Call the interface's GetMaintenanceManagementOperation() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *MaintenanceManagementOperation, *MaintenanceReadinessRefreshOperation, *RescheduleOperation, *ScheduleOperation

type MaintenanceManagementOperationKind ¶ added in v2.2.0

type MaintenanceManagementOperationKind string

MaintenanceManagementOperationKind - Defines the type of operation

const (
	// MaintenanceManagementOperationKindMaintenanceReadinessRefresh - Represents a maintenance readiness refresh operation
	MaintenanceManagementOperationKindMaintenanceReadinessRefresh MaintenanceManagementOperationKind = "MaintenanceReadinessRefresh"
	// MaintenanceManagementOperationKindReschedule - Represents a rescheduling operation
	MaintenanceManagementOperationKindReschedule MaintenanceManagementOperationKind = "Reschedule"
	// MaintenanceManagementOperationKindSchedule - Represents a scheduling operation
	MaintenanceManagementOperationKindSchedule MaintenanceManagementOperationKind = "Schedule"
)

func PossibleMaintenanceManagementOperationKindValues ¶ added in v2.2.0

func PossibleMaintenanceManagementOperationKindValues() []MaintenanceManagementOperationKind

PossibleMaintenanceManagementOperationKindValues returns the possible values for the MaintenanceManagementOperationKind const type.

type MaintenanceProperties ¶ added in v2.2.0

type MaintenanceProperties struct {
	// READ-ONLY; Activities performed as part of maintenance
	Activities []*MaintenanceActivity

	// READ-ONLY; Cluster ID for on which maintenance will be applied. Empty if maintenance is at private cloud level
	ClusterID *int32

	// READ-ONLY; type of maintenance
	Component *MaintenanceType

	// READ-ONLY; Display name for maintenance
	DisplayName *string

	// READ-ONLY; Estimated time maintenance will take in minutes
	EstimatedDurationInMinutes *int64

	// READ-ONLY; Group details if maintenance is part of a group
	Group *MaintenanceGroup

	// READ-ONLY; Impact on the resource during maintenance period
	Impact *string

	// READ-ONLY; Link to maintenance info
	InfoLink *string

	// READ-ONLY; Indicates whether the maintenance is ready to proceed
	MaintenanceReadiness *MaintenanceReadiness

	// READ-ONLY; Operations on maintenance
	Operations []MaintenanceManagementOperationClassification

	// READ-ONLY; The provisioning state
	ProvisioningState *MaintenanceProvisioningState

	// READ-ONLY; Relationships with other maintenances like dependencies and prerequisites
	Relationships *MaintenanceRelationships

	// READ-ONLY; If maintenance is scheduled by Microsoft
	ScheduledByMicrosoft *bool

	// READ-ONLY; Scheduled maintenance start time
	ScheduledStartTime *time.Time

	// READ-ONLY; The state of the maintenance
	State *MaintenanceState
}

MaintenanceProperties - properties of a maintenance

func (MaintenanceProperties) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceProperties.

func (*MaintenanceProperties) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceProperties.

type MaintenanceProvisioningState ¶ added in v2.2.0

type MaintenanceProvisioningState string

MaintenanceProvisioningState - provisioning state of the maintenance

const (
	// MaintenanceProvisioningStateCanceled - Resource creation was canceled.
	MaintenanceProvisioningStateCanceled MaintenanceProvisioningState = "Canceled"
	// MaintenanceProvisioningStateFailed - Resource creation failed.
	MaintenanceProvisioningStateFailed MaintenanceProvisioningState = "Failed"
	// MaintenanceProvisioningStateSucceeded - Resource has been created.
	MaintenanceProvisioningStateSucceeded MaintenanceProvisioningState = "Succeeded"
	// MaintenanceProvisioningStateUpdating - is updating
	MaintenanceProvisioningStateUpdating MaintenanceProvisioningState = "Updating"
)

func PossibleMaintenanceProvisioningStateValues ¶ added in v2.2.0

func PossibleMaintenanceProvisioningStateValues() []MaintenanceProvisioningState

PossibleMaintenanceProvisioningStateValues returns the possible values for the MaintenanceProvisioningState const type.

type MaintenanceReadiness ¶ added in v2.2.0

type MaintenanceReadiness struct {
	// READ-ONLY; The current readiness status of maintenance
	Status *MaintenanceReadinessStatus

	// READ-ONLY; The type of maintenance readiness check
	Type *MaintenanceCheckType

	// READ-ONLY; A list of failed checks, if any
	FailedChecks []*MaintenanceFailedCheck

	// READ-ONLY; The timestamp of the last readiness update
	LastUpdated *time.Time

	// READ-ONLY; A summary message of the readiness check result
	Message *string
}

MaintenanceReadiness - Maintenance readiness details

func (MaintenanceReadiness) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceReadiness) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceReadiness.

func (*MaintenanceReadiness) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceReadiness) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceReadiness.

type MaintenanceReadinessRefreshOperation ¶ added in v2.2.0

type MaintenanceReadinessRefreshOperation struct {
	// REQUIRED; The kind of operation
	Kind *MaintenanceManagementOperationKind

	// READ-ONLY; Reason disabling refresh for maintenanceReadiness
	DisabledReason *string

	// READ-ONLY; If maintenanceReadiness refresh is disabled
	IsDisabled *bool

	// READ-ONLY; Additional message about the operation
	Message *string

	// READ-ONLY; Indicates if the operation was refreshed by Microsoft
	RefreshedByMicrosoft *bool

	// READ-ONLY; Status of the operation
	Status *MaintenanceReadinessRefreshOperationStatus
}

MaintenanceReadinessRefreshOperation - Refresh MaintenanceReadiness status

func (*MaintenanceReadinessRefreshOperation) GetMaintenanceManagementOperation ¶ added in v2.2.0

func (m *MaintenanceReadinessRefreshOperation) GetMaintenanceManagementOperation() *MaintenanceManagementOperation

GetMaintenanceManagementOperation implements the MaintenanceManagementOperationClassification interface for type MaintenanceReadinessRefreshOperation.

func (MaintenanceReadinessRefreshOperation) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceReadinessRefreshOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceReadinessRefreshOperation.

func (*MaintenanceReadinessRefreshOperation) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceReadinessRefreshOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceReadinessRefreshOperation.

type MaintenanceReadinessRefreshOperationStatus ¶ added in v2.2.0

type MaintenanceReadinessRefreshOperationStatus string

MaintenanceReadinessRefreshOperationStatus - The status of an MaintenanceReadinessRefresh operation

const (
	// MaintenanceReadinessRefreshOperationStatusFailed - Operation has failed
	MaintenanceReadinessRefreshOperationStatusFailed MaintenanceReadinessRefreshOperationStatus = "Failed"
	// MaintenanceReadinessRefreshOperationStatusInProgress - Operation is in progress
	MaintenanceReadinessRefreshOperationStatusInProgress MaintenanceReadinessRefreshOperationStatus = "InProgress"
	// MaintenanceReadinessRefreshOperationStatusNotApplicable - Operation is not applicable
	MaintenanceReadinessRefreshOperationStatusNotApplicable MaintenanceReadinessRefreshOperationStatus = "NotApplicable"
	// MaintenanceReadinessRefreshOperationStatusNotStarted - Operation has not started
	MaintenanceReadinessRefreshOperationStatusNotStarted MaintenanceReadinessRefreshOperationStatus = "NotStarted"
)

func PossibleMaintenanceReadinessRefreshOperationStatusValues ¶ added in v2.2.0

func PossibleMaintenanceReadinessRefreshOperationStatusValues() []MaintenanceReadinessRefreshOperationStatus

PossibleMaintenanceReadinessRefreshOperationStatusValues returns the possible values for the MaintenanceReadinessRefreshOperationStatus const type.

type MaintenanceReadinessStatus ¶ added in v2.2.0

type MaintenanceReadinessStatus string

MaintenanceReadinessStatus - Defines the readiness status of maintenance

const (
	// MaintenanceReadinessStatusDataNotAvailable - Data is not available to determine readiness
	MaintenanceReadinessStatusDataNotAvailable MaintenanceReadinessStatus = "DataNotAvailable"
	// MaintenanceReadinessStatusNotApplicable - Readiness check is not applicable
	MaintenanceReadinessStatusNotApplicable MaintenanceReadinessStatus = "NotApplicable"
	// MaintenanceReadinessStatusNotReady - The system is not ready for maintenance
	MaintenanceReadinessStatusNotReady MaintenanceReadinessStatus = "NotReady"
	// MaintenanceReadinessStatusReady - The system is ready for maintenance
	MaintenanceReadinessStatusReady MaintenanceReadinessStatus = "Ready"
)

func PossibleMaintenanceReadinessStatusValues ¶ added in v2.2.0

func PossibleMaintenanceReadinessStatusValues() []MaintenanceReadinessStatus

PossibleMaintenanceReadinessStatusValues returns the possible values for the MaintenanceReadinessStatus const type.

type MaintenanceRecommendation ¶

type MaintenanceRecommendation struct {
	// READ-ONLY; List of recommended maintenance windows
	MaintenanceWindows []*MaintenanceWindowRecommendation
}

MaintenanceRecommendation - Recommendation details for scheduling/rescheduling maintenance

func (MaintenanceRecommendation) MarshalJSON ¶

func (m MaintenanceRecommendation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceRecommendation.

func (*MaintenanceRecommendation) UnmarshalJSON ¶

func (m *MaintenanceRecommendation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceRecommendation.

type MaintenanceRelationships ¶

type MaintenanceRelationships struct {
	// READ-ONLY; List of dependent group identifiers
	Dependencies []*string

	// READ-ONLY; List of prerequisite group identifiers
	Prerequisites []*string
}

MaintenanceRelationships - Defines relationship details between maintenance groups

func (MaintenanceRelationships) MarshalJSON ¶

func (m MaintenanceRelationships) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceRelationships.

func (*MaintenanceRelationships) UnmarshalJSON ¶

func (m *MaintenanceRelationships) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceRelationships.

type MaintenanceReschedule ¶ added in v2.2.0

type MaintenanceReschedule struct {
	// rescheduling reason
	Message *string

	// reschedule time
	RescheduleTime *time.Time
}

MaintenanceReschedule - reschedule a maintenance

func (MaintenanceReschedule) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceReschedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceReschedule.

func (*MaintenanceReschedule) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceReschedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceReschedule.

type MaintenanceSchedule ¶ added in v2.2.0

type MaintenanceSchedule struct {
	// scheduling message
	Message *string

	// schedule time
	ScheduleTime *time.Time
}

MaintenanceSchedule - schedule a maintenance

func (MaintenanceSchedule) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceSchedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceSchedule.

func (*MaintenanceSchedule) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceSchedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceSchedule.

type MaintenanceState ¶ added in v2.2.0

type MaintenanceState struct {
	// Time when current state ended
	EndedAt *time.Time

	// Failure/Success info
	Message *string

	// Customer presentable maintenance state
	Name *MaintenanceStateName

	// Time when current state started
	StartedAt *time.Time
}

MaintenanceState - state of the maintenance

func (MaintenanceState) MarshalJSON ¶ added in v2.2.0

func (m MaintenanceState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceState.

func (*MaintenanceState) UnmarshalJSON ¶ added in v2.2.0

func (m *MaintenanceState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceState.

type MaintenanceStateName ¶ added in v2.2.0

type MaintenanceStateName string

MaintenanceStateName - Customer presentable maintenance state

const (
	// MaintenanceStateNameCanceled - Maintenance Cancelled
	MaintenanceStateNameCanceled MaintenanceStateName = "Canceled"
	// MaintenanceStateNameFailed - Maintenance Failed
	MaintenanceStateNameFailed MaintenanceStateName = "Failed"
	// MaintenanceStateNameInProgress - Maintenance In Progress
	MaintenanceStateNameInProgress MaintenanceStateName = "InProgress"
	// MaintenanceStateNameNotScheduled - Maintenance Not Scheduled
	MaintenanceStateNameNotScheduled MaintenanceStateName = "NotScheduled"
	// MaintenanceStateNameScheduled - Maintenance Scheduled
	MaintenanceStateNameScheduled MaintenanceStateName = "Scheduled"
	// MaintenanceStateNameSuccess - Maintenance Succeeded
	MaintenanceStateNameSuccess MaintenanceStateName = "Success"
)

func PossibleMaintenanceStateNameValues ¶ added in v2.2.0

func PossibleMaintenanceStateNameValues() []MaintenanceStateName

PossibleMaintenanceStateNameValues returns the possible values for the MaintenanceStateName const type.

type MaintenanceStatusFilter ¶ added in v2.2.0

type MaintenanceStatusFilter string

MaintenanceStatusFilter - status filter for the maintenance

const (
	// MaintenanceStatusFilterActive - is active
	MaintenanceStatusFilterActive MaintenanceStatusFilter = "Active"
	// MaintenanceStatusFilterInactive - is inactive
	MaintenanceStatusFilterInactive MaintenanceStatusFilter = "Inactive"
)

func PossibleMaintenanceStatusFilterValues ¶ added in v2.2.0

func PossibleMaintenanceStatusFilterValues() []MaintenanceStatusFilter

PossibleMaintenanceStatusFilterValues returns the possible values for the MaintenanceStatusFilter const type.

type MaintenanceType ¶ added in v2.2.0

type MaintenanceType string

MaintenanceType - type of the maintenance

const (
	// MaintenanceTypeESXI - maintenance for ESXi
	MaintenanceTypeESXI MaintenanceType = "ESXI"
	// MaintenanceTypeNSXT - maintenance for NSX-T
	MaintenanceTypeNSXT MaintenanceType = "NSXT"
	// MaintenanceTypeVCSA - maintenance for vCenter Server Appliance
	MaintenanceTypeVCSA MaintenanceType = "VCSA"
)

func PossibleMaintenanceTypeValues ¶ added in v2.2.0

func PossibleMaintenanceTypeValues() []MaintenanceType

PossibleMaintenanceTypeValues returns the possible values for the MaintenanceType const type.

type MaintenanceWindowRecommendation ¶

type MaintenanceWindowRecommendation struct {
	// READ-ONLY; Recommended start time for maintenance
	StartTime *time.Time

	// READ-ONLY; Reason for recommending this window
	Reason *string
}

MaintenanceWindowRecommendation - Represents a recommended maintenance start window

func (MaintenanceWindowRecommendation) MarshalJSON ¶

func (m MaintenanceWindowRecommendation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceWindowRecommendation.

func (*MaintenanceWindowRecommendation) UnmarshalJSON ¶

func (m *MaintenanceWindowRecommendation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceWindowRecommendation.

type MaintenancesClient ¶ added in v2.2.0

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

MaintenancesClient contains the methods for the Maintenances group. Don't use this type directly, use NewMaintenancesClient() instead.

Generated from API version 2026-03-01

func NewMaintenancesClient ¶ added in v2.2.0

func NewMaintenancesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MaintenancesClient, error)

NewMaintenancesClient creates a new instance of MaintenancesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*MaintenancesClient) Get ¶ added in v2.2.0

func (client *MaintenancesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, maintenanceName string, options *MaintenancesClientGetOptions) (MaintenancesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
maintenanceName - Name of the maintenance
options - MaintenancesClientGetOptions contains the optional parameters for the MaintenancesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/Maintenances_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewMaintenancesClient().Get(ctx, "group1", "cloud1", "maintenance1", 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 = armavs.MaintenancesClientGetResponse{
	// 	Maintenance: armavs.Maintenance{
	// 		ID: to.Ptr("/subscriptions/00000001-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/maintenances/maintenance1"),
	// 		Name: to.Ptr("maintenance1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/maintenances"),
	// 		Properties: &armavs.MaintenanceProperties{
	// 			Component: to.Ptr(armavs.MaintenanceTypeVCSA),
	// 			DisplayName: to.Ptr("vcsa 7.0 upgrade"),
	// 			ClusterID: to.Ptr[int32](1),
	// 			InfoLink: to.Ptr("https://vmwarekb/article"),
	// 			Impact: to.Ptr("This upgrade will update your vcsa to 7.0. Control plane performance will be impacted for the duration"),
	// 			ScheduledStartTime: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
	// 			EstimatedDurationInMinutes: to.Ptr[int64](960),
	// 			State: &armavs.MaintenanceState{
	// 				Message: to.Ptr("CD rom mounted"),
	// 				StartedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
	// 				EndedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
	// 				Name: to.Ptr(armavs.MaintenanceStateNameScheduled),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.MaintenanceProvisioningStateSucceeded),
	// 			ScheduledByMicrosoft: to.Ptr(true),
	// 			Activities: []*armavs.MaintenanceActivity{
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindUpgrade),
	// 					Component: to.Ptr("ESXi"),
	// 					Version: to.Ptr("7.0.3.01500"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("This upgrade will update your esxi to 7.0. Control plane performance will be impacted for the duration"),
	// 				},
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindCertificateRotation),
	// 					Component: to.Ptr("vCSA"),
	// 					Version: to.Ptr("notapplicable"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("During this time, we expect no impact to Azure VMware Solution services or to the workloads"),
	// 				},
	// 			},
	// 			Group: &armavs.MaintenanceGroup{
	// 				ID: to.Ptr("SKUMigrationID"),
	// 				Name: to.Ptr("SKUMigration"),
	// 				Kind: to.Ptr(armavs.MaintenanceGroupKindConsolidation),
	// 			},
	// 			Relationships: &armavs.MaintenanceRelationships{
	// 				Dependencies: []*string{
	// 					to.Ptr("dependentMaintenanceName1"),
	// 					to.Ptr("dependentMaintenanceName2"),
	// 				},
	// 				Prerequisites: []*string{
	// 					to.Ptr("prerequisiteMaintenanceName1"),
	// 				},
	// 			},
	// 			Operations: []armavs.MaintenanceManagementOperationClassification{
	// 				&armavs.ScheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindSchedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical upgrade"),
	// 					Constraints: []armavs.ScheduleOperationConstraintClassification{
	// 						&armavs.SchedulingWindow{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindSchedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.AvailableWindowForMaintenanceWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.WeekendSchedulingConstraint{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindWeekendScheduling),
	// 							DisabledReason: to.Ptr("Schedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("2024 Summer Opening Ceremony"),
	// 								},
	// 							},
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryQuotaExhausted),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.April, 14, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.April, 15, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.September, 13, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.September, 26, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.RescheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindReschedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical Update"),
	// 					Constraints: []armavs.RescheduleOperationConstraintClassification{
	// 						&armavs.AvailableWindowForMaintenanceWhileRescheduleOperation{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.ReschedulingWindowConstraint{
	// 							EndsAt: to.Ptr(time.Date(2026, time.February, 8, 21, 59, 56, 0, time.UTC)),
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindReschedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2026, time.January, 29, 21, 59, 56, 0, time.UTC)),
	// 						},
	// 						&armavs.WeekendReschedulingConstraint{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindWeekendRescheduling),
	// 							DisabledReason: to.Ptr("Reschedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileRescheduleOperation{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindBlockedWhileRescheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.August, 10, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.August, 19, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("US General Election 2024"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.MaintenanceReadinessRefreshOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindMaintenanceReadinessRefresh),
	// 					IsDisabled: to.Ptr(false),
	// 					Status: to.Ptr(armavs.MaintenanceReadinessRefreshOperationStatusInProgress),
	// 					RefreshedByMicrosoft: to.Ptr(true),
	// 				},
	// 			},
	// 			MaintenanceReadiness: &armavs.MaintenanceReadiness{
	// 				Type: to.Ptr(armavs.MaintenanceCheckTypePrecheck),
	// 				Status: to.Ptr(armavs.MaintenanceReadinessStatusNotReady),
	// 				Message: to.Ptr("Some checks failed"),
	// 				FailedChecks: []*armavs.MaintenanceFailedCheck{
	// 					{
	// 						Name: to.Ptr("HostMaintPrecheck"),
	// 						ImpactedResources: []*armavs.ImpactedMaintenanceResource{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster2"),
	// 								Errors: []*armavs.ImpactedMaintenanceResourceError{
	// 									{
	// 										ErrorCode: to.Ptr("EVCINTERNALEPR_CDUNMOUNT"),
	// 										Name: to.Ptr("CD-ROM Mounted"),
	// 										Details: to.Ptr("Failed to unmount CD ROM  mounted on vm"),
	// 										ResolutionSteps: []*string{
	// 											to.Ptr("Please remove CDROM /usr/lib/vmware/isoimages/windows.iso mounted in VD000535 VM present in esx10-r06.p01.dummy.com Host"),
	// 										},
	// 										ActionRequired: to.Ptr(true),
	// 									},
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 				LastUpdated: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

func (*MaintenancesClient) InitiateChecks ¶ added in v2.2.0

func (client *MaintenancesClient) InitiateChecks(ctx context.Context, resourceGroupName string, privateCloudName string, maintenanceName string, options *MaintenancesClientInitiateChecksOptions) (MaintenancesClientInitiateChecksResponse, error)

InitiateChecks - Initiate maintenance readiness checks If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
maintenanceName - Name of the maintenance
options - MaintenancesClientInitiateChecksOptions contains the optional parameters for the MaintenancesClient.InitiateChecks method.

Example ¶

Generated from example definition: 2026-03-01/Maintenances_InitiateChecks.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewMaintenancesClient().InitiateChecks(ctx, "group1", "cloud1", "maintenance1", 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 = armavs.MaintenancesClientInitiateChecksResponse{
	// 	Maintenance: armavs.Maintenance{
	// 		ID: to.Ptr("/subscriptions/00000001-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/maintenances/maintenance1"),
	// 		Name: to.Ptr("maintenance1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/maintenances"),
	// 		Properties: &armavs.MaintenanceProperties{
	// 			Component: to.Ptr(armavs.MaintenanceTypeVCSA),
	// 			DisplayName: to.Ptr("vcsa 7.0 upgrade"),
	// 			ClusterID: to.Ptr[int32](1),
	// 			InfoLink: to.Ptr("https://vmwarekb/article"),
	// 			Impact: to.Ptr("This upgrade will update your vcsa to 7.0. Control plane performance will be impacted for the duration"),
	// 			ScheduledStartTime: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
	// 			EstimatedDurationInMinutes: to.Ptr[int64](960),
	// 			State: &armavs.MaintenanceState{
	// 				Message: to.Ptr("CD rom mounted"),
	// 				StartedAt: to.Ptr(time.Date(2025, time.November, 12, 11, 0, 11, 830000000, time.UTC)),
	// 				EndedAt: to.Ptr(time.Date(2025, time.November, 12, 16, 0, 11, 830000000, time.UTC)),
	// 				Name: to.Ptr(armavs.MaintenanceStateNameScheduled),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.MaintenanceProvisioningStateSucceeded),
	// 			ScheduledByMicrosoft: to.Ptr(true),
	// 			Activities: []*armavs.MaintenanceActivity{
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindUpgrade),
	// 					Component: to.Ptr("ESXi"),
	// 					Version: to.Ptr("7.0.3.01500"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("This upgrade will update your esxi to 7.0. Control plane performance will be impacted for the duration"),
	// 				},
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindCertificateRotation),
	// 					Component: to.Ptr("vCSA"),
	// 					Version: to.Ptr("notapplicable"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("During this time, we expect no impact to Azure VMware Solution services or to the workloads"),
	// 				},
	// 			},
	// 			Group: &armavs.MaintenanceGroup{
	// 				ID: to.Ptr("SKUMigrationID"),
	// 				Name: to.Ptr("SKUMigration"),
	// 				Kind: to.Ptr(armavs.MaintenanceGroupKindConsolidation),
	// 			},
	// 			Relationships: &armavs.MaintenanceRelationships{
	// 				Dependencies: []*string{
	// 					to.Ptr("dependentMaintenanceName1"),
	// 					to.Ptr("dependentMaintenanceName2"),
	// 				},
	// 				Prerequisites: []*string{
	// 					to.Ptr("prerequisiteMaintenanceName1"),
	// 				},
	// 			},
	// 			Operations: []armavs.MaintenanceManagementOperationClassification{
	// 				&armavs.ScheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindSchedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical upgrade"),
	// 					Constraints: []armavs.ScheduleOperationConstraintClassification{
	// 						&armavs.SchedulingWindow{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindSchedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.AvailableWindowForMaintenanceWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.WeekendSchedulingConstraint{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindWeekendScheduling),
	// 							DisabledReason: to.Ptr("Schedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("2024 Summer Opening Ceremony"),
	// 								},
	// 							},
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryQuotaExhausted),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.April, 14, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.April, 15, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.September, 13, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.September, 26, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.RescheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindReschedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical Update"),
	// 					Constraints: []armavs.RescheduleOperationConstraintClassification{
	// 						&armavs.AvailableWindowForMaintenanceWhileRescheduleOperation{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.ReschedulingWindowConstraint{
	// 							EndsAt: to.Ptr(time.Date(2026, time.February, 8, 21, 59, 56, 0, time.UTC)),
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindReschedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2026, time.January, 29, 21, 59, 56, 0, time.UTC)),
	// 						},
	// 						&armavs.WeekendReschedulingConstraint{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindWeekendRescheduling),
	// 							DisabledReason: to.Ptr("Reschedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileRescheduleOperation{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindBlockedWhileRescheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.August, 10, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.August, 19, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("US General Election 2024"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.MaintenanceReadinessRefreshOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindMaintenanceReadinessRefresh),
	// 					IsDisabled: to.Ptr(false),
	// 					Status: to.Ptr(armavs.MaintenanceReadinessRefreshOperationStatusInProgress),
	// 					RefreshedByMicrosoft: to.Ptr(true),
	// 				},
	// 			},
	// 			MaintenanceReadiness: &armavs.MaintenanceReadiness{
	// 				Type: to.Ptr(armavs.MaintenanceCheckTypePrecheck),
	// 				Status: to.Ptr(armavs.MaintenanceReadinessStatusNotReady),
	// 				Message: to.Ptr("Some checks failed"),
	// 				FailedChecks: []*armavs.MaintenanceFailedCheck{
	// 					{
	// 						Name: to.Ptr("HostMaintPrecheck"),
	// 						ImpactedResources: []*armavs.ImpactedMaintenanceResource{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster2"),
	// 								Errors: []*armavs.ImpactedMaintenanceResourceError{
	// 									{
	// 										ErrorCode: to.Ptr("EVCINTERNALEPR_CDUNMOUNT"),
	// 										Name: to.Ptr("CD-ROM Mounted"),
	// 										Details: to.Ptr("Failed to unmount CD ROM  mounted on vm"),
	// 										ResolutionSteps: []*string{
	// 											to.Ptr("Please remove CDROM /usr/lib/vmware/isoimages/windows.iso mounted in VD000535 VM present in esx10-r06.p01.dummy.com Host"),
	// 										},
	// 										ActionRequired: to.Ptr(true),
	// 									},
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 				LastUpdated: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

func (*MaintenancesClient) NewListPager ¶ added in v2.2.0

func (client *MaintenancesClient) NewListPager(resourceGroupName string, privateCloudName string, options *MaintenancesClientListOptions) *runtime.Pager[MaintenancesClientListResponse]

NewListPager - List Maintenance resources by subscription ID

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - MaintenancesClientListOptions contains the optional parameters for the MaintenancesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Maintenances_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewMaintenancesClient().NewListPager("group1", "cloud1", 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 = armavs.MaintenancesClientListResponse{
		// 	MaintenanceListResult: armavs.MaintenanceListResult{
		// 		Value: []*armavs.Maintenance{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/maintenances/maintenance1"),
		// 				Name: to.Ptr("maintenance1"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/maintenances"),
		// 				Properties: &armavs.MaintenanceProperties{
		// 					Component: to.Ptr(armavs.MaintenanceTypeVCSA),
		// 					DisplayName: to.Ptr("vcsa 7.0 upgrade"),
		// 					ClusterID: to.Ptr[int32](1),
		// 					InfoLink: to.Ptr("https://vmwarekb/article"),
		// 					Impact: to.Ptr("This upgrade will update your vcsa to 7.0. Control plane performance will be impacted for the duration"),
		// 					ScheduledStartTime: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
		// 					EstimatedDurationInMinutes: to.Ptr[int64](960),
		// 					State: &armavs.MaintenanceState{
		// 						Message: to.Ptr("CD rom mounted"),
		// 						StartedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
		// 						EndedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
		// 						Name: to.Ptr(armavs.MaintenanceStateNameScheduled),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.MaintenanceProvisioningStateSucceeded),
		// 					ScheduledByMicrosoft: to.Ptr(true),
		// 					Activities: []*armavs.MaintenanceActivity{
		// 						{
		// 							Kind: to.Ptr(armavs.MaintenanceActivityKindUpgrade),
		// 							Component: to.Ptr("ESXi"),
		// 							Version: to.Ptr("7.0.3.01500"),
		// 							InfoLink: to.Ptr("https://vmwarekb/article"),
		// 							Impact: to.Ptr("This upgrade will update your esxi to 7.0. Control plane performance will be impacted for the duration"),
		// 						},
		// 						{
		// 							Kind: to.Ptr(armavs.MaintenanceActivityKindCertificateRotation),
		// 							Component: to.Ptr("vCSA"),
		// 							Version: to.Ptr("notapplicable"),
		// 							InfoLink: to.Ptr("https://vmwarekb/article"),
		// 							Impact: to.Ptr("During this time, we expect no impact to Azure VMware Solution services or to the workloads"),
		// 						},
		// 					},
		// 					Group: &armavs.MaintenanceGroup{
		// 						ID: to.Ptr("SKUMigrationID"),
		// 						Name: to.Ptr("SKUMigration"),
		// 						Kind: to.Ptr(armavs.MaintenanceGroupKindConsolidation),
		// 					},
		// 					Relationships: &armavs.MaintenanceRelationships{
		// 						Dependencies: []*string{
		// 							to.Ptr("dependentMaintenanceName1"),
		// 							to.Ptr("dependentMaintenanceName2"),
		// 						},
		// 						Prerequisites: []*string{
		// 							to.Ptr("prerequisiteMaintenanceName1"),
		// 						},
		// 					},
		// 					Operations: []armavs.MaintenanceManagementOperationClassification{
		// 						&armavs.ScheduleOperation{
		// 							Kind: to.Ptr(armavs.MaintenanceManagementOperationKindSchedule),
		// 							IsDisabled: to.Ptr(true),
		// 							DisabledReason: to.Ptr("Critical upgrade"),
		// 							Constraints: []armavs.ScheduleOperationConstraintClassification{
		// 								&armavs.SchedulingWindow{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindSchedulingWindow),
		// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 								},
		// 								&armavs.AvailableWindowForMaintenanceWhileScheduleOperation{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation),
		// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 								},
		// 								&armavs.BlockedWhileScheduleOperation{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
		// 									Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
		// 									TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 											Reason: to.Ptr("2024 Summer Opening Ceremony"),
		// 										},
		// 									},
		// 								},
		// 								&armavs.BlockedWhileScheduleOperation{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
		// 									Category: to.Ptr(armavs.BlockedDatesConstraintCategoryQuotaExhausted),
		// 									TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2024, time.April, 14, 17, 3, 28, 609000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2024, time.April, 15, 17, 3, 28, 609000000, time.UTC)),
		// 											Reason: to.Ptr("No slots available"),
		// 										},
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2024, time.September, 13, 17, 3, 28, 609000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2024, time.September, 26, 17, 3, 28, 609000000, time.UTC)),
		// 											Reason: to.Ptr("No slots available"),
		// 										},
		// 									},
		// 								},
		// 							},
		// 							Recommendation: &armavs.MaintenanceRecommendation{
		// 								MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
		// 									{
		// 										StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
		// 										Reason: to.Ptr("Historically preferred time"),
		// 									},
		// 									{
		// 										StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
		// 										Reason: to.Ptr("Historically preferred day"),
		// 									},
		// 								},
		// 							},
		// 						},
		// 						&armavs.RescheduleOperation{
		// 							Kind: to.Ptr(armavs.MaintenanceManagementOperationKindReschedule),
		// 							IsDisabled: to.Ptr(true),
		// 							DisabledReason: to.Ptr("Critical Update"),
		// 							Constraints: []armavs.RescheduleOperationConstraintClassification{
		// 								&armavs.AvailableWindowForMaintenanceWhileRescheduleOperation{
		// 									Kind: to.Ptr(armavs.RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation),
		// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 								},
		// 								&armavs.BlockedWhileRescheduleOperation{
		// 									Kind: to.Ptr(armavs.RescheduleOperationConstraintKindBlockedWhileRescheduleOperation),
		// 									Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
		// 									TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2025, time.August, 10, 6, 21, 31, 961000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2025, time.August, 19, 6, 21, 31, 961000000, time.UTC)),
		// 											Reason: to.Ptr("US General Election 2024"),
		// 										},
		// 									},
		// 								},
		// 							},
		// 							Recommendation: &armavs.MaintenanceRecommendation{
		// 								MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
		// 									{
		// 										StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
		// 										Reason: to.Ptr("Historically preferred time"),
		// 									},
		// 									{
		// 										StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
		// 										Reason: to.Ptr("Historically preferred day"),
		// 									},
		// 								},
		// 							},
		// 						},
		// 						&armavs.MaintenanceReadinessRefreshOperation{
		// 							Kind: to.Ptr(armavs.MaintenanceManagementOperationKindMaintenanceReadinessRefresh),
		// 							IsDisabled: to.Ptr(true),
		// 							DisabledReason: to.Ptr("Refresh in Progress"),
		// 							Status: to.Ptr(armavs.MaintenanceReadinessRefreshOperationStatusInProgress),
		// 							RefreshedByMicrosoft: to.Ptr(true),
		// 							Message: to.Ptr("Please try again later"),
		// 						},
		// 					},
		// 					MaintenanceReadiness: &armavs.MaintenanceReadiness{
		// 						Type: to.Ptr(armavs.MaintenanceCheckTypePrecheck),
		// 						Status: to.Ptr(armavs.MaintenanceReadinessStatusNotReady),
		// 						Message: to.Ptr("Some checks failed"),
		// 						FailedChecks: []*armavs.MaintenanceFailedCheck{
		// 							{
		// 								Name: to.Ptr("HostMaintPrecheck"),
		// 								ImpactedResources: []*armavs.ImpactedMaintenanceResource{
		// 									{
		// 										ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster2"),
		// 										Errors: []*armavs.ImpactedMaintenanceResourceError{
		// 											{
		// 												ErrorCode: to.Ptr("EVCINTERNALEPR_CDUNMOUNT"),
		// 												Name: to.Ptr("CD-ROM Mounted"),
		// 												Details: to.Ptr("Failed to unmount CD ROM  mounted on vm"),
		// 												ResolutionSteps: []*string{
		// 													to.Ptr("Please remove CDROM /usr/lib/vmware/isoimages/windows.iso mounted in VD000535 VM present in esx10-r06.p01.dummy.com Host"),
		// 												},
		// 												ActionRequired: to.Ptr(true),
		// 											},
		// 										},
		// 									},
		// 								},
		// 							},
		// 						},
		// 						LastUpdated: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 					},
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/maintenances/maintenance2"),
		// 				Name: to.Ptr("maintenance2"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/maintenances"),
		// 				Properties: &armavs.MaintenanceProperties{
		// 					Component: to.Ptr(armavs.MaintenanceTypeVCSA),
		// 					DisplayName: to.Ptr("vcsa 7.0 upgrade"),
		// 					ClusterID: to.Ptr[int32](1),
		// 					InfoLink: to.Ptr("https://vmwarekb/article"),
		// 					Impact: to.Ptr("This upgrade will update your vcsa to 7.0. Control plane performance will be impacted for the duration"),
		// 					ScheduledStartTime: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
		// 					EstimatedDurationInMinutes: to.Ptr[int64](960),
		// 					State: &armavs.MaintenanceState{
		// 						Message: to.Ptr("CD rom mounted"),
		// 						StartedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
		// 						EndedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
		// 						Name: to.Ptr(armavs.MaintenanceStateNameScheduled),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.MaintenanceProvisioningStateSucceeded),
		// 					ScheduledByMicrosoft: to.Ptr(true),
		// 					Activities: []*armavs.MaintenanceActivity{
		// 						{
		// 							Kind: to.Ptr(armavs.MaintenanceActivityKindUpgrade),
		// 							Component: to.Ptr("ESXi"),
		// 							Version: to.Ptr("7.0.3.01500"),
		// 							InfoLink: to.Ptr("https://vmwarekb/article"),
		// 							Impact: to.Ptr("This upgrade will update your esxi to 7.0. Control plane performance will be impacted for the duration"),
		// 						},
		// 						{
		// 							Kind: to.Ptr(armavs.MaintenanceActivityKindCertificateRotation),
		// 							Component: to.Ptr("vCSA"),
		// 							Version: to.Ptr("notapplicable"),
		// 							InfoLink: to.Ptr("https://vmwarekb/article"),
		// 							Impact: to.Ptr("During this time, we expect no impact to Azure VMware Solution services or to the workloads"),
		// 						},
		// 					},
		// 					Group: &armavs.MaintenanceGroup{
		// 						ID: to.Ptr("SKUMigrationID"),
		// 						Name: to.Ptr("SKUMigration"),
		// 						Kind: to.Ptr(armavs.MaintenanceGroupKindConsolidation),
		// 					},
		// 					Relationships: &armavs.MaintenanceRelationships{
		// 						Dependencies: []*string{
		// 							to.Ptr("dependentMaintenanceName1"),
		// 							to.Ptr("dependentMaintenanceName2"),
		// 						},
		// 						Prerequisites: []*string{
		// 							to.Ptr("prerequisiteMaintenanceName1"),
		// 						},
		// 					},
		// 					Operations: []armavs.MaintenanceManagementOperationClassification{
		// 						&armavs.ScheduleOperation{
		// 							Kind: to.Ptr(armavs.MaintenanceManagementOperationKindSchedule),
		// 							IsDisabled: to.Ptr(true),
		// 							DisabledReason: to.Ptr("Critical upgrade"),
		// 							Constraints: []armavs.ScheduleOperationConstraintClassification{
		// 								&armavs.SchedulingWindow{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindSchedulingWindow),
		// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 								},
		// 								&armavs.AvailableWindowForMaintenanceWhileScheduleOperation{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation),
		// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 								},
		// 								&armavs.BlockedWhileScheduleOperation{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
		// 									Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
		// 									TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 											Reason: to.Ptr("2024 Summer Opening Ceremony"),
		// 										},
		// 									},
		// 								},
		// 								&armavs.BlockedWhileScheduleOperation{
		// 									Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
		// 									Category: to.Ptr(armavs.BlockedDatesConstraintCategoryQuotaExhausted),
		// 									TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2024, time.April, 14, 17, 3, 28, 609000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2024, time.April, 15, 17, 3, 28, 609000000, time.UTC)),
		// 											Reason: to.Ptr("No slots available"),
		// 										},
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2024, time.September, 13, 17, 3, 28, 609000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2024, time.September, 26, 17, 3, 28, 609000000, time.UTC)),
		// 											Reason: to.Ptr("No slots available"),
		// 										},
		// 									},
		// 								},
		// 							},
		// 						},
		// 						&armavs.RescheduleOperation{
		// 							Kind: to.Ptr(armavs.MaintenanceManagementOperationKindReschedule),
		// 							IsDisabled: to.Ptr(true),
		// 							DisabledReason: to.Ptr("Critical Update"),
		// 							Constraints: []armavs.RescheduleOperationConstraintClassification{
		// 								&armavs.AvailableWindowForMaintenanceWhileRescheduleOperation{
		// 									Kind: to.Ptr(armavs.RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation),
		// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
		// 								},
		// 								&armavs.BlockedWhileRescheduleOperation{
		// 									Kind: to.Ptr(armavs.RescheduleOperationConstraintKindBlockedWhileRescheduleOperation),
		// 									Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
		// 									TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
		// 										{
		// 											StartsAt: to.Ptr(time.Date(2025, time.August, 10, 6, 21, 31, 961000000, time.UTC)),
		// 											EndsAt: to.Ptr(time.Date(2025, time.August, 19, 6, 21, 31, 961000000, time.UTC)),
		// 											Reason: to.Ptr("US General Election 2024"),
		// 										},
		// 									},
		// 								},
		// 							},
		// 						},
		// 						&armavs.MaintenanceReadinessRefreshOperation{
		// 							Kind: to.Ptr(armavs.MaintenanceManagementOperationKindMaintenanceReadinessRefresh),
		// 							IsDisabled: to.Ptr(false),
		// 							Status: to.Ptr(armavs.MaintenanceReadinessRefreshOperationStatusInProgress),
		// 							RefreshedByMicrosoft: to.Ptr(true),
		// 						},
		// 					},
		// 					MaintenanceReadiness: &armavs.MaintenanceReadiness{
		// 						Type: to.Ptr(armavs.MaintenanceCheckTypePrecheck),
		// 						Status: to.Ptr(armavs.MaintenanceReadinessStatusNotReady),
		// 						Message: to.Ptr("Some checks failed"),
		// 						FailedChecks: []*armavs.MaintenanceFailedCheck{
		// 							{
		// 								Name: to.Ptr("HostMaintPrecheck"),
		// 								ImpactedResources: []*armavs.ImpactedMaintenanceResource{
		// 									{
		// 										ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster2"),
		// 										Errors: []*armavs.ImpactedMaintenanceResourceError{
		// 											{
		// 												ErrorCode: to.Ptr("EVCINTERNALEPR_CDUNMOUNT"),
		// 												Name: to.Ptr("CD-ROM Mounted"),
		// 												Details: to.Ptr("Failed to unmount CD ROM  mounted on vm"),
		// 												ResolutionSteps: []*string{
		// 													to.Ptr("Please remove CDROM /usr/lib/vmware/isoimages/windows.iso mounted in VD000535 VM present in esx10-r06.p01.dummy.com Host"),
		// 												},
		// 												ActionRequired: to.Ptr(true),
		// 											},
		// 										},
		// 									},
		// 								},
		// 							},
		// 						},
		// 						LastUpdated: to.Ptr(time.Date(2025, time.January, 19, 6, 21, 31, 961000000, time.UTC)),
		// 					},
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*MaintenancesClient) Reschedule ¶ added in v2.2.0

func (client *MaintenancesClient) Reschedule(ctx context.Context, resourceGroupName string, privateCloudName string, maintenanceName string, body MaintenanceReschedule, options *MaintenancesClientRescheduleOptions) (MaintenancesClientRescheduleResponse, error)

Reschedule - Reschedule a maintenance If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
maintenanceName - Name of the maintenance
body - The content of the action request
options - MaintenancesClientRescheduleOptions contains the optional parameters for the MaintenancesClient.Reschedule method.

Example ¶

Generated from example definition: 2026-03-01/Maintenances_Reschedule.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
	"time"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewMaintenancesClient().Reschedule(ctx, "group1", "cloud1", "maintenance1", armavs.MaintenanceReschedule{
		RescheduleTime: to.Ptr(time.Date(2023, time.January, 12, 16, 17, 55, 237000000, time.UTC)),
		Message:        to.Ptr("Rescheduled due to xyz"),
	}, 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 = armavs.MaintenancesClientRescheduleResponse{
	// 	Maintenance: armavs.Maintenance{
	// 		ID: to.Ptr("/subscriptions/00000001-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/maintenances/maintenance1"),
	// 		Name: to.Ptr("maintenance1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/maintenances"),
	// 		Properties: &armavs.MaintenanceProperties{
	// 			Component: to.Ptr(armavs.MaintenanceTypeVCSA),
	// 			DisplayName: to.Ptr("vcsa 7.0 upgrade"),
	// 			ClusterID: to.Ptr[int32](1),
	// 			InfoLink: to.Ptr("https://vmwarekb/article"),
	// 			Impact: to.Ptr("This upgrade will update your vcsa to 7.0. Control plane performance will be impacted for the duration"),
	// 			ScheduledStartTime: to.Ptr(time.Date(2023, time.January, 12, 16, 17, 55, 237000000, time.UTC)),
	// 			EstimatedDurationInMinutes: to.Ptr[int64](960),
	// 			State: &armavs.MaintenanceState{
	// 				Message: to.Ptr("CD rom mounted"),
	// 				StartedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
	// 				EndedAt: to.Ptr(time.Date(2023, time.January, 12, 11, 0, 11, 830000000, time.UTC)),
	// 				Name: to.Ptr(armavs.MaintenanceStateNameScheduled),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.MaintenanceProvisioningStateSucceeded),
	// 			ScheduledByMicrosoft: to.Ptr(true),
	// 			Activities: []*armavs.MaintenanceActivity{
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindUpgrade),
	// 					Component: to.Ptr("ESXi"),
	// 					Version: to.Ptr("7.0.3.01500"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("This upgrade will update your esxi to 7.0. Control plane performance will be impacted for the duration"),
	// 				},
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindCertificateRotation),
	// 					Component: to.Ptr("vCSA"),
	// 					Version: to.Ptr("notapplicable"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("During this time, we expect no impact to Azure VMware Solution services or to the workloads"),
	// 				},
	// 			},
	// 			Group: &armavs.MaintenanceGroup{
	// 				ID: to.Ptr("SKUMigrationID"),
	// 				Name: to.Ptr("SKUMigration"),
	// 				Kind: to.Ptr(armavs.MaintenanceGroupKindConsolidation),
	// 			},
	// 			Relationships: &armavs.MaintenanceRelationships{
	// 				Dependencies: []*string{
	// 					to.Ptr("dependentMaintenanceName1"),
	// 					to.Ptr("dependentMaintenanceName2"),
	// 				},
	// 				Prerequisites: []*string{
	// 					to.Ptr("prerequisiteMaintenanceName1"),
	// 				},
	// 			},
	// 			Operations: []armavs.MaintenanceManagementOperationClassification{
	// 				&armavs.ScheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindSchedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical upgrade"),
	// 					Constraints: []armavs.ScheduleOperationConstraintClassification{
	// 						&armavs.SchedulingWindow{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindSchedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.AvailableWindowForMaintenanceWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.WeekendSchedulingConstraint{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindWeekendScheduling),
	// 							DisabledReason: to.Ptr("Schedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("2024 Summer Opening Ceremony"),
	// 								},
	// 							},
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryQuotaExhausted),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.April, 14, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.April, 15, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.September, 13, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.September, 26, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.RescheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindReschedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical Update"),
	// 					Constraints: []armavs.RescheduleOperationConstraintClassification{
	// 						&armavs.AvailableWindowForMaintenanceWhileRescheduleOperation{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.ReschedulingWindowConstraint{
	// 							EndsAt: to.Ptr(time.Date(2026, time.February, 8, 21, 59, 56, 0, time.UTC)),
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindReschedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2026, time.January, 29, 21, 59, 56, 0, time.UTC)),
	// 						},
	// 						&armavs.WeekendReschedulingConstraint{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindWeekendRescheduling),
	// 							DisabledReason: to.Ptr("Reschedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileRescheduleOperation{
	// 							Kind: to.Ptr(armavs.RescheduleOperationConstraintKindBlockedWhileRescheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.August, 10, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.August, 19, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("US General Election 2024"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.MaintenanceReadinessRefreshOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindMaintenanceReadinessRefresh),
	// 					IsDisabled: to.Ptr(false),
	// 					Status: to.Ptr(armavs.MaintenanceReadinessRefreshOperationStatusInProgress),
	// 					RefreshedByMicrosoft: to.Ptr(true),
	// 				},
	// 			},
	// 			MaintenanceReadiness: &armavs.MaintenanceReadiness{
	// 				Type: to.Ptr(armavs.MaintenanceCheckTypePrecheck),
	// 				Status: to.Ptr(armavs.MaintenanceReadinessStatusNotReady),
	// 				Message: to.Ptr("Some checks failed"),
	// 				FailedChecks: []*armavs.MaintenanceFailedCheck{
	// 					{
	// 						Name: to.Ptr("HostMaintPrecheck"),
	// 						ImpactedResources: []*armavs.ImpactedMaintenanceResource{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster2"),
	// 								Errors: []*armavs.ImpactedMaintenanceResourceError{
	// 									{
	// 										ErrorCode: to.Ptr("EVCINTERNALEPR_CDUNMOUNT"),
	// 										Name: to.Ptr("CD-ROM Mounted"),
	// 										Details: to.Ptr("Failed to unmount CD ROM  mounted on vm"),
	// 										ResolutionSteps: []*string{
	// 											to.Ptr("Please remove CDROM /usr/lib/vmware/isoimages/windows.iso mounted in VD000535 VM present in esx10-r06.p01.dummy.com Host"),
	// 										},
	// 										ActionRequired: to.Ptr(true),
	// 									},
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 				LastUpdated: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

func (*MaintenancesClient) Schedule ¶ added in v2.2.0

func (client *MaintenancesClient) Schedule(ctx context.Context, resourceGroupName string, privateCloudName string, maintenanceName string, body MaintenanceSchedule, options *MaintenancesClientScheduleOptions) (MaintenancesClientScheduleResponse, error)

Schedule - Schedule a maintenance If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
maintenanceName - Name of the maintenance
body - The content of the action request
options - MaintenancesClientScheduleOptions contains the optional parameters for the MaintenancesClient.Schedule method.

Example ¶

Generated from example definition: 2026-03-01/Maintenances_Schedule.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
	"time"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewMaintenancesClient().Schedule(ctx, "group1", "cloud1", "maintenance1", armavs.MaintenanceSchedule{
		ScheduleTime: to.Ptr(time.Date(2025, time.September, 12, 16, 17, 55, 237000000, time.UTC)),
		Message:      to.Ptr("scheduled due to xyz"),
	}, 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 = armavs.MaintenancesClientScheduleResponse{
	// 	Maintenance: armavs.Maintenance{
	// 		ID: to.Ptr("/subscriptions/00000001-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/maintenances/maintenance1"),
	// 		Name: to.Ptr("maintenance1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/maintenances"),
	// 		Properties: &armavs.MaintenanceProperties{
	// 			Component: to.Ptr(armavs.MaintenanceTypeVCSA),
	// 			DisplayName: to.Ptr("vcsa 7.0 upgrade"),
	// 			ClusterID: to.Ptr[int32](1),
	// 			InfoLink: to.Ptr("https://vmwarekb/article"),
	// 			Impact: to.Ptr("This upgrade will update your vcsa to 7.0. Control plane performance will be impacted for the duration"),
	// 			ScheduledStartTime: to.Ptr(time.Date(2023, time.January, 12, 16, 17, 55, 237000000, time.UTC)),
	// 			EstimatedDurationInMinutes: to.Ptr[int64](960),
	// 			State: &armavs.MaintenanceState{
	// 				Message: to.Ptr("Please schedule maintenance in scheduling window"),
	// 				StartedAt: to.Ptr(time.Date(2025, time.September, 12, 16, 17, 55, 237000000, time.UTC)),
	// 				EndedAt: to.Ptr(time.Date(2025, time.September, 12, 19, 0, 11, 830000000, time.UTC)),
	// 				Name: to.Ptr(armavs.MaintenanceStateNameNotScheduled),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.MaintenanceProvisioningStateSucceeded),
	// 			ScheduledByMicrosoft: to.Ptr(true),
	// 			Activities: []*armavs.MaintenanceActivity{
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindUpgrade),
	// 					Component: to.Ptr("ESXi"),
	// 					Version: to.Ptr("7.0.3.01500"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("This upgrade will update your esxi to 7.0. Control plane performance will be impacted for the duration"),
	// 				},
	// 				{
	// 					Kind: to.Ptr(armavs.MaintenanceActivityKindCertificateRotation),
	// 					Component: to.Ptr("vCSA"),
	// 					Version: to.Ptr("notapplicable"),
	// 					InfoLink: to.Ptr("https://vmwarekb/article"),
	// 					Impact: to.Ptr("During this time, we expect no impact to Azure VMware Solution services or to the workloads"),
	// 				},
	// 			},
	// 			Group: &armavs.MaintenanceGroup{
	// 				ID: to.Ptr("SKUMigrationID"),
	// 				Name: to.Ptr("SKUMigration"),
	// 				Kind: to.Ptr(armavs.MaintenanceGroupKindConsolidation),
	// 			},
	// 			Relationships: &armavs.MaintenanceRelationships{
	// 				Dependencies: []*string{
	// 					to.Ptr("dependentMaintenanceName1"),
	// 					to.Ptr("dependentMaintenanceName2"),
	// 				},
	// 				Prerequisites: []*string{
	// 					to.Ptr("prerequisiteMaintenanceName1"),
	// 				},
	// 			},
	// 			Operations: []armavs.MaintenanceManagementOperationClassification{
	// 				&armavs.ScheduleOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindSchedule),
	// 					IsDisabled: to.Ptr(true),
	// 					DisabledReason: to.Ptr("Critical upgrade"),
	// 					Constraints: []armavs.ScheduleOperationConstraintClassification{
	// 						&armavs.SchedulingWindow{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindSchedulingWindow),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.AvailableWindowForMaintenanceWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation),
	// 							StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 							EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 						},
	// 						&armavs.WeekendSchedulingConstraint{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindWeekendScheduling),
	// 							DisabledReason: to.Ptr("Schedule operation is disabled for maintenance on weekends"),
	// 							IsDisabled: to.Ptr(true),
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryHiPriorityEvent),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 									Reason: to.Ptr("2024 Summer Opening Ceremony"),
	// 								},
	// 							},
	// 						},
	// 						&armavs.BlockedWhileScheduleOperation{
	// 							Kind: to.Ptr(armavs.ScheduleOperationConstraintKindBlockedWhileScheduleOperation),
	// 							Category: to.Ptr(armavs.BlockedDatesConstraintCategoryQuotaExhausted),
	// 							TimeRanges: []*armavs.BlockedDatesConstraintTimeRange{
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.April, 14, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.April, 15, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 								{
	// 									StartsAt: to.Ptr(time.Date(2024, time.September, 13, 17, 3, 28, 609000000, time.UTC)),
	// 									EndsAt: to.Ptr(time.Date(2024, time.September, 26, 17, 3, 28, 609000000, time.UTC)),
	// 									Reason: to.Ptr("No slots available"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 					Recommendation: &armavs.MaintenanceRecommendation{
	// 						MaintenanceWindows: []*armavs.MaintenanceWindowRecommendation{
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred time"),
	// 							},
	// 							{
	// 								StartTime: to.Ptr(time.Date(2025, time.December, 14, 16, 0, 0, 0, time.UTC)),
	// 								Reason: to.Ptr("Historically preferred day"),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				&armavs.MaintenanceReadinessRefreshOperation{
	// 					Kind: to.Ptr(armavs.MaintenanceManagementOperationKindMaintenanceReadinessRefresh),
	// 					IsDisabled: to.Ptr(false),
	// 					Status: to.Ptr(armavs.MaintenanceReadinessRefreshOperationStatusInProgress),
	// 					RefreshedByMicrosoft: to.Ptr(true),
	// 				},
	// 			},
	// 			MaintenanceReadiness: &armavs.MaintenanceReadiness{
	// 				Type: to.Ptr(armavs.MaintenanceCheckTypePrecheck),
	// 				Status: to.Ptr(armavs.MaintenanceReadinessStatusNotReady),
	// 				Message: to.Ptr("Some checks failed"),
	// 				FailedChecks: []*armavs.MaintenanceFailedCheck{
	// 					{
	// 						Name: to.Ptr("HostMaintPrecheck"),
	// 						ImpactedResources: []*armavs.ImpactedMaintenanceResource{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster2"),
	// 								Errors: []*armavs.ImpactedMaintenanceResourceError{
	// 									{
	// 										ErrorCode: to.Ptr("EVCINTERNALEPR_CDUNMOUNT"),
	// 										Name: to.Ptr("CD-ROM Mounted"),
	// 										Details: to.Ptr("Failed to unmount CD ROM  mounted on vm"),
	// 										ResolutionSteps: []*string{
	// 											to.Ptr("Please remove CDROM /usr/lib/vmware/isoimages/windows.iso mounted in VD000535 VM present in esx10-r06.p01.dummy.com Host"),
	// 										},
	// 										ActionRequired: to.Ptr(true),
	// 									},
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 				LastUpdated: to.Ptr(time.Date(2025, time.January, 16, 6, 21, 31, 961000000, time.UTC)),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

type MaintenancesClientGetOptions ¶ added in v2.2.0

type MaintenancesClientGetOptions struct {
}

MaintenancesClientGetOptions contains the optional parameters for the MaintenancesClient.Get method.

type MaintenancesClientGetResponse ¶ added in v2.2.0

type MaintenancesClientGetResponse struct {
	// A cluster resource
	Maintenance
}

MaintenancesClientGetResponse contains the response from method MaintenancesClient.Get.

type MaintenancesClientInitiateChecksOptions ¶ added in v2.2.0

type MaintenancesClientInitiateChecksOptions struct {
}

MaintenancesClientInitiateChecksOptions contains the optional parameters for the MaintenancesClient.InitiateChecks method.

type MaintenancesClientInitiateChecksResponse ¶ added in v2.2.0

type MaintenancesClientInitiateChecksResponse struct {
	// A cluster resource
	Maintenance
}

MaintenancesClientInitiateChecksResponse contains the response from method MaintenancesClient.InitiateChecks.

type MaintenancesClientListOptions ¶ added in v2.2.0

type MaintenancesClientListOptions struct {
	// date from which result should be returned. ie. scheduledStartTime >= from
	From *time.Time

	// Filter maintenances based on state
	StateName *MaintenanceStateName

	// Filter active or inactive maintenances
	Status *MaintenanceStatusFilter

	// date till which result should be returned. i.e. scheduledStartTime <= to
	To *time.Time
}

MaintenancesClientListOptions contains the optional parameters for the MaintenancesClient.NewListPager method.

type MaintenancesClientListResponse ¶ added in v2.2.0

type MaintenancesClientListResponse struct {
	// The response of a Maintenance list operation.
	MaintenanceListResult
}

MaintenancesClientListResponse contains the response from method MaintenancesClient.NewListPager.

type MaintenancesClientRescheduleOptions ¶ added in v2.2.0

type MaintenancesClientRescheduleOptions struct {
}

MaintenancesClientRescheduleOptions contains the optional parameters for the MaintenancesClient.Reschedule method.

type MaintenancesClientRescheduleResponse ¶ added in v2.2.0

type MaintenancesClientRescheduleResponse struct {
	// A cluster resource
	Maintenance
}

MaintenancesClientRescheduleResponse contains the response from method MaintenancesClient.Reschedule.

type MaintenancesClientScheduleOptions ¶ added in v2.2.0

type MaintenancesClientScheduleOptions struct {
}

MaintenancesClientScheduleOptions contains the optional parameters for the MaintenancesClient.Schedule method.

type MaintenancesClientScheduleResponse ¶ added in v2.2.0

type MaintenancesClientScheduleResponse struct {
	// A cluster resource
	Maintenance
}

MaintenancesClientScheduleResponse contains the response from method MaintenancesClient.Schedule.

type ManagementCluster ¶

type ManagementCluster struct {
	// The cluster size
	ClusterSize *int32

	// The hosts
	Hosts []*string

	// Name of the vsan datastore associated with the cluster
	VsanDatastoreName *string

	// READ-ONLY; The identity
	ClusterID *int32

	// READ-ONLY; The state of the cluster provisioning
	ProvisioningState *ClusterProvisioningState
}

ManagementCluster - The properties of a management cluster

func (ManagementCluster) MarshalJSON ¶

func (m ManagementCluster) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagementCluster.

func (*ManagementCluster) UnmarshalJSON ¶

func (m *ManagementCluster) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagementCluster.

type MountOptionEnum ¶

type MountOptionEnum string

MountOptionEnum - mount option

const (
	// MountOptionEnumATTACH - is attach
	MountOptionEnumATTACH MountOptionEnum = "ATTACH"
	// MountOptionEnumMOUNT - is mount
	MountOptionEnumMOUNT MountOptionEnum = "MOUNT"
)

func PossibleMountOptionEnumValues ¶

func PossibleMountOptionEnumValues() []MountOptionEnum

PossibleMountOptionEnumValues returns the possible values for the MountOptionEnum const type.

type NetAppVolume ¶

type NetAppVolume struct {
	// REQUIRED; Azure resource ID of the NetApp volume
	ID *string
}

NetAppVolume - An Azure NetApp Files volume from Microsoft.NetApp provider

func (NetAppVolume) MarshalJSON ¶

func (n NetAppVolume) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetAppVolume.

func (*NetAppVolume) UnmarshalJSON ¶

func (n *NetAppVolume) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetAppVolume.

type NsxPublicIPQuotaRaisedEnum ¶

type NsxPublicIPQuotaRaisedEnum string

NsxPublicIPQuotaRaisedEnum - NSX public IP quota raised

const (
	// NsxPublicIPQuotaRaisedEnumDisabled - is disabled
	NsxPublicIPQuotaRaisedEnumDisabled NsxPublicIPQuotaRaisedEnum = "Disabled"
	// NsxPublicIPQuotaRaisedEnumEnabled - is enabled
	NsxPublicIPQuotaRaisedEnumEnabled NsxPublicIPQuotaRaisedEnum = "Enabled"
)

func PossibleNsxPublicIPQuotaRaisedEnumValues ¶

func PossibleNsxPublicIPQuotaRaisedEnumValues() []NsxPublicIPQuotaRaisedEnum

PossibleNsxPublicIPQuotaRaisedEnumValues returns the possible values for the NsxPublicIPQuotaRaisedEnum const type.

type Operation ¶

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Extensible 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 Azure
	// Resource Manager/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 - REST API 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 an 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 {
	// REQUIRED; The Operation items on this page
	Value []*Operation

	// The link to the next page of items
	NextLink *string
}

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.

Generated from API version 2026-03-01

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 - Contains optional client configuration. Pass nil to accept the default values.

func (*OperationsClient) NewListPager ¶

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - List the operations for the provider

options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Operations_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("", 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 = armavs.OperationsClientListResponse{
		// 	OperationListResult: armavs.OperationListResult{
		// 		Value: []*armavs.Operation{
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Lists operations available on Microsoft.AVS resource provider."),
		// 					Operation: to.Ptr("List available Microsoft.AVS operations"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("operations"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/operations/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Register Subscription for Microsoft.AVS resource provider."),
		// 					Operation: to.Ptr("Register Subscription for Microsoft.AVS"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr(""),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/register/action"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Unregister Subscription for Microsoft.AVS resource provider."),
		// 					Operation: to.Ptr("Unregister Subscription for Microsoft.AVS"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr(""),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/unregister/action"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Checks if the privateCloud Name is available"),
		// 					Operation: to.Ptr("Check Name Availability"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("checkNameAvailability"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/checkNameAvailability/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Checks if the privateCloud Name is available"),
		// 					Operation: to.Ptr("Check Name Availability"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("locations/checkNameAvailability"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/locations/checkNameAvailability/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Checks if quota is available for the subscription"),
		// 					Operation: to.Ptr("Check Quota Availability"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("locations/checkQuotaAvailability"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/locations/checkQuotaAvailability/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Checks if trial is available for the subscription"),
		// 					Operation: to.Ptr("Check Trial Availability"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("locations/checkTrialAvailability"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/locations/checkTrialAvailability/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Registers the Microsoft Microsoft.AVS resource provider and enables creation of Private Clouds."),
		// 					Operation: to.Ptr("Register Microsoft.AVS resource provider."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/register/action"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Creates or updates a PrivateCloud resource."),
		// 					Operation: to.Ptr("Create or update a PrivateCloud."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/write"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Gets the settings for the specified PrivateCloud."),
		// 					Operation: to.Ptr("Read PrivateCloud settings"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Delete a specific PrivateCloud."),
		// 					Operation: to.Ptr("Delete a PrivateCloud."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/delete"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Reads privateClouds operationstatuses."),
		// 					Operation: to.Ptr("Read privateClouds operationstatuses"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/operationstatuses"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/operationstatuses/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Gets the cluster settings for a PrivateCloud cluster."),
		// 					Operation: to.Ptr("Read Cluster settings."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/clusters"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Create or update a PrivateCloud cluster resource."),
		// 					Operation: to.Ptr("Create or update a PrivateCloud cluster."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/clusters"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/write"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Delete a specific PrivateCloud cluster."),
		// 					Operation: to.Ptr("Delete a PriveCloud cluster."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/clusters"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/delete"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Reads privateClouds/clusters operationstatuses."),
		// 					Operation: to.Ptr("Read privateClouds/clusters operationstatuses"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/clusters/operationstatuses"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/operationstatuses/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Reads privateClouds/clusters operationresults."),
		// 					Operation: to.Ptr("Read privateClouds/clusters operationresults"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateclouds/clusters/operationresults"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateclouds/clusters/operationresults/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Reads privateClouds operationresults."),
		// 					Operation: to.Ptr("Read privateClouds operationresults"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/operationresults"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/operationresults/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Gets the authorization settings for a PrivateCloud cluster."),
		// 					Operation: to.Ptr("Read Authorization settings."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/authorizations"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/authorizations/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Create or update a PrivateCloud authorization resource."),
		// 					Operation: to.Ptr("Create or update a PrivateCloud authorization."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/authorizations"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/authorizations/write"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Delete a specific PrivateCloud authorization."),
		// 					Operation: to.Ptr("Delete a PriveCloud authorization."),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/authorizations"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/authorizations/delete"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Lists the AdminCredentials for privateClouds."),
		// 					Operation: to.Ptr("List privateClouds AdminCredentials"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds"),
		// 				},
		// 				IsDataAction: to.Ptr(true),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/listAdminCredentials/action"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Gets the hcxEnterpriseSites for a PrivateCloud."),
		// 					Operation: to.Ptr("Read hcxEnterpriseSites"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/hcxEnterpriseSites"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Create or update a hcxEnterpriseSites."),
		// 					Operation: to.Ptr("Create or update a hcxEnterpriseSites"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/hcxEnterpriseSites"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites/write"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Delete a specific hcxEnterpriseSites."),
		// 					Operation: to.Ptr("Delete a hcxEnterpriseSites"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/hcxEnterpriseSites"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites/delete"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Gets the hostInstances for a PrivateCloud."),
		// 					Operation: to.Ptr("Read hostInstances"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/hostInstances"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/hostInstances/read"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Create or update a hostInstances."),
		// 					Operation: to.Ptr("Create or update a hostInstances"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/hostInstances"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/hostInstances/write"),
		// 				Origin: to.Ptr(armavs.OriginUserSystem),
		// 			},
		// 			{
		// 				Display: &armavs.OperationDisplay{
		// 					Description: to.Ptr("Delete a specific hostInstances."),
		// 					Operation: to.Ptr("Delete a hostInstances"),
		// 					Provider: to.Ptr("Microsoft.AVS"),
		// 					Resource: to.Ptr("privateClouds/hostInstances"),
		// 				},
		// 				IsDataAction: to.Ptr(false),
		// 				Name: to.Ptr("Microsoft.AVS/privateClouds/hostInstances/delete"),
		// 				Origin: to.Ptr(armavs.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 OptionalParamEnum ¶

type OptionalParamEnum string

OptionalParamEnum - Optional Param

const (
	// OptionalParamEnumOptional - is optional
	OptionalParamEnumOptional OptionalParamEnum = "Optional"
	// OptionalParamEnumRequired - is required
	OptionalParamEnumRequired OptionalParamEnum = "Required"
)

func PossibleOptionalParamEnumValues ¶

func PossibleOptionalParamEnumValues() []OptionalParamEnum

PossibleOptionalParamEnumValues returns the possible values for the OptionalParamEnum const type.

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 - Indicates the operation is initiated by a system.
	OriginSystem Origin = "system"
	// OriginUser - Indicates the operation is initiated by a user.
	OriginUser Origin = "user"
	// OriginUserSystem - Indicates the operation is initiated by a user or system.
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues ¶

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PSCredentialExecutionParameter ¶

type PSCredentialExecutionParameter struct {
	// REQUIRED; The parameter name
	Name *string

	// CONSTANT; The type of execution parameter
	// Field has constant value ScriptExecutionParameterTypeCredential, any specified value is ignored.
	Type *ScriptExecutionParameterType

	// password for login
	Password *string

	// username for login
	Username *string
}

PSCredentialExecutionParameter - a powershell credential object

func (*PSCredentialExecutionParameter) GetScriptExecutionParameter ¶

func (p *PSCredentialExecutionParameter) GetScriptExecutionParameter() *ScriptExecutionParameter

GetScriptExecutionParameter implements the ScriptExecutionParameterClassification interface for type PSCredentialExecutionParameter.

func (PSCredentialExecutionParameter) MarshalJSON ¶

func (p PSCredentialExecutionParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PSCredentialExecutionParameter.

func (*PSCredentialExecutionParameter) UnmarshalJSON ¶

func (p *PSCredentialExecutionParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PSCredentialExecutionParameter.

type PagedResourceSKU ¶ added in v2.1.0

type PagedResourceSKU struct {
	// REQUIRED; The ResourceSku items on this page
	Value []*ResourceSKU

	// The link to the next page of items
	NextLink *string
}

PagedResourceSKU - Paged collection of ResourceSku items

func (PagedResourceSKU) MarshalJSON ¶ added in v2.1.0

func (p PagedResourceSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PagedResourceSKU.

func (*PagedResourceSKU) UnmarshalJSON ¶ added in v2.1.0

func (p *PagedResourceSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PagedResourceSKU.

type PlacementPoliciesClient ¶

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

PlacementPoliciesClient contains the methods for the PlacementPolicies group. Don't use this type directly, use NewPlacementPoliciesClient() instead.

Generated from API version 2026-03-01

func NewPlacementPoliciesClient ¶

func NewPlacementPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PlacementPoliciesClient, error)

NewPlacementPoliciesClient creates a new instance of PlacementPoliciesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*PlacementPoliciesClient) BeginCreateOrUpdate ¶

func (client *PlacementPoliciesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, placementPolicyName string, placementPolicy PlacementPolicy, options *PlacementPoliciesClientBeginCreateOrUpdateOptions) (*runtime.Poller[PlacementPoliciesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a PlacementPolicy If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
placementPolicyName - Name of the placement policy.
placementPolicy - Resource create parameters.
options - PlacementPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PlacementPoliciesClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/PlacementPolicies_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPlacementPoliciesClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "cluster1", "policy1", armavs.PlacementPolicy{
		Properties: &armavs.VMHostPlacementPolicyProperties{
			Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
			VMMembers: []*string{
				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
			},
			HostMembers: []*string{
				to.Ptr("fakehost22.nyc1.kubernetes.center"),
				to.Ptr("fakehost23.nyc1.kubernetes.center"),
				to.Ptr("fakehost24.nyc1.kubernetes.center"),
			},
			AffinityType:           to.Ptr(armavs.AffinityTypeAntiAffinity),
			AffinityStrength:       to.Ptr(armavs.AffinityStrengthMust),
			AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
		},
	}, 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 poll 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 = armavs.PlacementPoliciesClientCreateOrUpdateResponse{
	// 	PlacementPolicy: armavs.PlacementPolicy{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
	// 		Name: to.Ptr("policy1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
	// 		Properties: &armavs.VMHostPlacementPolicyProperties{
	// 			DisplayName: to.Ptr("policy1"),
	// 			Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
	// 			State: to.Ptr(armavs.PlacementPolicyStateEnabled),
	// 			VMMembers: []*string{
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
	// 			},
	// 			HostMembers: []*string{
	// 				to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 			},
	// 			AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
	// 			AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
	// 			AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
	// 			ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
	// 		},
	// 	},
	// }
}

Output:

func (*PlacementPoliciesClient) BeginDelete ¶

func (client *PlacementPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, placementPolicyName string, options *PlacementPoliciesClientBeginDeleteOptions) (*runtime.Poller[PlacementPoliciesClientDeleteResponse], error)

BeginDelete - Delete a PlacementPolicy If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
placementPolicyName - Name of the placement policy.
options - PlacementPoliciesClientBeginDeleteOptions contains the optional parameters for the PlacementPoliciesClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/PlacementPolicies_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPlacementPoliciesClient().BeginDelete(ctx, "group1", "cloud1", "cluster1", "policy1", 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 poll 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 = armavs.PlacementPoliciesClientDeleteResponse{
	// }
}

Output:

func (*PlacementPoliciesClient) BeginUpdate ¶

func (client *PlacementPoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, placementPolicyName string, placementPolicyUpdate PlacementPolicyUpdate, options *PlacementPoliciesClientBeginUpdateOptions) (*runtime.Poller[PlacementPoliciesClientUpdateResponse], error)

BeginUpdate - Update a PlacementPolicy If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
placementPolicyName - Name of the placement policy.
placementPolicyUpdate - The resource properties to be updated.
options - PlacementPoliciesClientBeginUpdateOptions contains the optional parameters for the PlacementPoliciesClient.BeginUpdate method.

Example ¶

Generated from example definition: 2026-03-01/PlacementPolicies_Update.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPlacementPoliciesClient().BeginUpdate(ctx, "group1", "cloud1", "cluster1", "policy1", armavs.PlacementPolicyUpdate{
		Properties: &armavs.PlacementPolicyUpdateProperties{
			State: to.Ptr(armavs.PlacementPolicyStateDisabled),
			VMMembers: []*string{
				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
			},
			HostMembers: []*string{
				to.Ptr("fakehost22.nyc1.kubernetes.center"),
				to.Ptr("fakehost23.nyc1.kubernetes.center"),
				to.Ptr("fakehost24.nyc1.kubernetes.center"),
			},
			AffinityStrength:       to.Ptr(armavs.AffinityStrengthMust),
			AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
		},
	}, 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 poll 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 = armavs.PlacementPoliciesClientUpdateResponse{
	// 	PlacementPolicy: armavs.PlacementPolicy{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
	// 		Name: to.Ptr("policy1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
	// 		Properties: &armavs.VMHostPlacementPolicyProperties{
	// 			DisplayName: to.Ptr("policy1"),
	// 			Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
	// 			State: to.Ptr(armavs.PlacementPolicyStateDisabled),
	// 			VMMembers: []*string{
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
	// 			},
	// 			HostMembers: []*string{
	// 				to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 			},
	// 			AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
	// 			AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
	// 			AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
	// 			ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
	// 		},
	// 	},
	// }
}

Output:

func (*PlacementPoliciesClient) Get ¶

func (client *PlacementPoliciesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, placementPolicyName string, options *PlacementPoliciesClientGetOptions) (PlacementPoliciesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
placementPolicyName - Name of the placement policy.
options - PlacementPoliciesClientGetOptions contains the optional parameters for the PlacementPoliciesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/PlacementPolicies_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPlacementPoliciesClient().Get(ctx, "group1", "cloud1", "cluster1", "policy1", 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 = armavs.PlacementPoliciesClientGetResponse{
	// 	PlacementPolicy: armavs.PlacementPolicy{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
	// 		Name: to.Ptr("policy1"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
	// 		Properties: &armavs.VMHostPlacementPolicyProperties{
	// 			DisplayName: to.Ptr("policy1"),
	// 			Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
	// 			State: to.Ptr(armavs.PlacementPolicyStateEnabled),
	// 			VMMembers: []*string{
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
	// 			},
	// 			HostMembers: []*string{
	// 				to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 				to.Ptr("fakehost24.nyc1.kubernetes.center"),
	// 			},
	// 			AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
	// 			AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
	// 			AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
	// 			ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
	// 		},
	// 	},
	// }
}

Output:

func (*PlacementPoliciesClient) NewListPager ¶

func (client *PlacementPoliciesClient) NewListPager(resourceGroupName string, privateCloudName string, clusterName string, options *PlacementPoliciesClientListOptions) *runtime.Pager[PlacementPoliciesClientListResponse]

NewListPager - List PlacementPolicy resources by Cluster

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - PlacementPoliciesClientListOptions contains the optional parameters for the PlacementPoliciesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/PlacementPolicies_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPlacementPoliciesClient().NewListPager("group1", "cloud1", "cluster1", 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 = armavs.PlacementPoliciesClientListResponse{
		// 	PlacementPoliciesList: armavs.PlacementPoliciesList{
		// 		Value: []*armavs.PlacementPolicy{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
		// 				Name: to.Ptr("policy1"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
		// 				Properties: &armavs.VMHostPlacementPolicyProperties{
		// 					DisplayName: to.Ptr("policy1"),
		// 					Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
		// 					State: to.Ptr(armavs.PlacementPolicyStateEnabled),
		// 					VMMembers: []*string{
		// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
		// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
		// 					},
		// 					HostMembers: []*string{
		// 						to.Ptr("fakehost22.nyc1.kubernetes.center"),
		// 						to.Ptr("fakehost23.nyc1.kubernetes.center"),
		// 						to.Ptr("fakehost24.nyc1.kubernetes.center"),
		// 					},
		// 					AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
		// 					AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
		// 					AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
		// 					ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy2"),
		// 				Name: to.Ptr("policy2"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
		// 				Properties: &armavs.VMPlacementPolicyProperties{
		// 					DisplayName: to.Ptr("policy2"),
		// 					Type: to.Ptr(armavs.PlacementPolicyTypeVMVM),
		// 					State: to.Ptr(armavs.PlacementPolicyStateEnabled),
		// 					VMMembers: []*string{
		// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
		// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-256"),
		// 					},
		// 					AffinityType: to.Ptr(armavs.AffinityTypeAffinity),
		// 					ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type PlacementPoliciesClientBeginCreateOrUpdateOptions ¶

type PlacementPoliciesClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PlacementPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PlacementPoliciesClient.BeginCreateOrUpdate method.

type PlacementPoliciesClientBeginDeleteOptions ¶

type PlacementPoliciesClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PlacementPoliciesClientBeginDeleteOptions contains the optional parameters for the PlacementPoliciesClient.BeginDelete method.

type PlacementPoliciesClientBeginUpdateOptions ¶

type PlacementPoliciesClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PlacementPoliciesClientBeginUpdateOptions contains the optional parameters for the PlacementPoliciesClient.BeginUpdate method.

type PlacementPoliciesClientCreateOrUpdateResponse ¶

type PlacementPoliciesClientCreateOrUpdateResponse struct {
	// A vSphere Distributed Resource Scheduler (DRS) placement policy
	PlacementPolicy
}

PlacementPoliciesClientCreateOrUpdateResponse contains the response from method PlacementPoliciesClient.BeginCreateOrUpdate.

type PlacementPoliciesClientDeleteResponse ¶

type PlacementPoliciesClientDeleteResponse struct {
}

PlacementPoliciesClientDeleteResponse contains the response from method PlacementPoliciesClient.BeginDelete.

type PlacementPoliciesClientGetOptions ¶

type PlacementPoliciesClientGetOptions struct {
}

PlacementPoliciesClientGetOptions contains the optional parameters for the PlacementPoliciesClient.Get method.

type PlacementPoliciesClientGetResponse ¶

type PlacementPoliciesClientGetResponse struct {
	// A vSphere Distributed Resource Scheduler (DRS) placement policy
	PlacementPolicy
}

PlacementPoliciesClientGetResponse contains the response from method PlacementPoliciesClient.Get.

type PlacementPoliciesClientListOptions ¶

type PlacementPoliciesClientListOptions struct {
}

PlacementPoliciesClientListOptions contains the optional parameters for the PlacementPoliciesClient.NewListPager method.

type PlacementPoliciesClientListResponse ¶

type PlacementPoliciesClientListResponse struct {
	// The response of a PlacementPolicy list operation.
	PlacementPoliciesList
}

PlacementPoliciesClientListResponse contains the response from method PlacementPoliciesClient.NewListPager.

type PlacementPoliciesClientUpdateResponse ¶

type PlacementPoliciesClientUpdateResponse struct {
	// A vSphere Distributed Resource Scheduler (DRS) placement policy
	PlacementPolicy
}

PlacementPoliciesClientUpdateResponse contains the response from method PlacementPoliciesClient.BeginUpdate.

type PlacementPoliciesList ¶

type PlacementPoliciesList struct {
	// REQUIRED; The PlacementPolicy items on this page
	Value []*PlacementPolicy

	// The link to the next page of items
	NextLink *string
}

PlacementPoliciesList - The response of a PlacementPolicy list operation.

func (PlacementPoliciesList) MarshalJSON ¶

func (p PlacementPoliciesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlacementPoliciesList.

func (*PlacementPoliciesList) UnmarshalJSON ¶

func (p *PlacementPoliciesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlacementPoliciesList.

type PlacementPolicy ¶

type PlacementPolicy struct {
	// The resource-specific properties for this resource.
	Properties PlacementPolicyPropertiesClassification

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

PlacementPolicy - A vSphere Distributed Resource Scheduler (DRS) placement policy

func (PlacementPolicy) MarshalJSON ¶

func (p PlacementPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlacementPolicy.

func (*PlacementPolicy) UnmarshalJSON ¶

func (p *PlacementPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlacementPolicy.

type PlacementPolicyProperties ¶

type PlacementPolicyProperties struct {
	// REQUIRED; Placement Policy type
	Type *PlacementPolicyType

	// Display name of the placement policy
	DisplayName *string

	// Whether the placement policy is enabled or disabled
	State *PlacementPolicyState

	// READ-ONLY; The provisioning state
	ProvisioningState *PlacementPolicyProvisioningState
}

PlacementPolicyProperties - Abstract placement policy properties

func (*PlacementPolicyProperties) GetPlacementPolicyProperties ¶

func (p *PlacementPolicyProperties) GetPlacementPolicyProperties() *PlacementPolicyProperties

GetPlacementPolicyProperties implements the PlacementPolicyPropertiesClassification interface for type PlacementPolicyProperties.

func (PlacementPolicyProperties) MarshalJSON ¶

func (p PlacementPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlacementPolicyProperties.

func (*PlacementPolicyProperties) UnmarshalJSON ¶

func (p *PlacementPolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlacementPolicyProperties.

type PlacementPolicyPropertiesClassification ¶

type PlacementPolicyPropertiesClassification interface {
	// GetPlacementPolicyProperties returns the PlacementPolicyProperties content of the underlying type.
	GetPlacementPolicyProperties() *PlacementPolicyProperties
}

PlacementPolicyPropertiesClassification provides polymorphic access to related types. Call the interface's GetPlacementPolicyProperties() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *PlacementPolicyProperties, *VMHostPlacementPolicyProperties, *VMPlacementPolicyProperties

type PlacementPolicyProvisioningState ¶

type PlacementPolicyProvisioningState string

PlacementPolicyProvisioningState - Placement Policy provisioning state

const (
	// PlacementPolicyProvisioningStateBuilding - is building
	PlacementPolicyProvisioningStateBuilding PlacementPolicyProvisioningState = "Building"
	// PlacementPolicyProvisioningStateCanceled - Resource creation was canceled.
	PlacementPolicyProvisioningStateCanceled PlacementPolicyProvisioningState = "Canceled"
	// PlacementPolicyProvisioningStateDeleting - is deleting
	PlacementPolicyProvisioningStateDeleting PlacementPolicyProvisioningState = "Deleting"
	// PlacementPolicyProvisioningStateFailed - Resource creation failed.
	PlacementPolicyProvisioningStateFailed PlacementPolicyProvisioningState = "Failed"
	// PlacementPolicyProvisioningStateSucceeded - Resource has been created.
	PlacementPolicyProvisioningStateSucceeded PlacementPolicyProvisioningState = "Succeeded"
	// PlacementPolicyProvisioningStateUpdating - is updating
	PlacementPolicyProvisioningStateUpdating PlacementPolicyProvisioningState = "Updating"
)

func PossiblePlacementPolicyProvisioningStateValues ¶

func PossiblePlacementPolicyProvisioningStateValues() []PlacementPolicyProvisioningState

PossiblePlacementPolicyProvisioningStateValues returns the possible values for the PlacementPolicyProvisioningState const type.

type PlacementPolicyState ¶

type PlacementPolicyState string

PlacementPolicyState - Placement Policy state

const (
	// PlacementPolicyStateDisabled - is disabled
	PlacementPolicyStateDisabled PlacementPolicyState = "Disabled"
	// PlacementPolicyStateEnabled - is enabled
	PlacementPolicyStateEnabled PlacementPolicyState = "Enabled"
)

func PossiblePlacementPolicyStateValues ¶

func PossiblePlacementPolicyStateValues() []PlacementPolicyState

PossiblePlacementPolicyStateValues returns the possible values for the PlacementPolicyState const type.

type PlacementPolicyType ¶

type PlacementPolicyType string

PlacementPolicyType - Placement Policy type

const (
	PlacementPolicyTypeVMHost PlacementPolicyType = "VmHost"
	PlacementPolicyTypeVMVM   PlacementPolicyType = "VmVm"
)

func PossiblePlacementPolicyTypeValues ¶

func PossiblePlacementPolicyTypeValues() []PlacementPolicyType

PossiblePlacementPolicyTypeValues returns the possible values for the PlacementPolicyType const type.

type PlacementPolicyUpdate ¶

type PlacementPolicyUpdate struct {
	// The properties of a placement policy resource that may be updated
	Properties *PlacementPolicyUpdateProperties
}

PlacementPolicyUpdate - An update of a DRS placement policy resource

func (PlacementPolicyUpdate) MarshalJSON ¶

func (p PlacementPolicyUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlacementPolicyUpdate.

func (*PlacementPolicyUpdate) UnmarshalJSON ¶

func (p *PlacementPolicyUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlacementPolicyUpdate.

type PlacementPolicyUpdateProperties ¶

type PlacementPolicyUpdateProperties struct {
	// vm-host placement policy affinity strength (should/must)
	AffinityStrength *AffinityStrength

	// placement policy azure hybrid benefit opt-in type
	AzureHybridBenefitType *AzureHybridBenefitType

	// Host members list
	HostMembers []*string

	// Whether the placement policy is enabled or disabled
	State *PlacementPolicyState

	// Virtual machine members list
	VMMembers []*string
}

PlacementPolicyUpdateProperties - The properties of a placement policy resource that may be updated

func (PlacementPolicyUpdateProperties) MarshalJSON ¶

func (p PlacementPolicyUpdateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlacementPolicyUpdateProperties.

func (*PlacementPolicyUpdateProperties) UnmarshalJSON ¶

func (p *PlacementPolicyUpdateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlacementPolicyUpdateProperties.

type PortMirroringDirectionEnum ¶

type PortMirroringDirectionEnum string

PortMirroringDirectionEnum - Port Mirroring Direction

const (
	// PortMirroringDirectionEnumBIDIRECTIONAL - is bidirectional
	PortMirroringDirectionEnumBIDIRECTIONAL PortMirroringDirectionEnum = "BIDIRECTIONAL"
	// PortMirroringDirectionEnumEGRESS - is egress
	PortMirroringDirectionEnumEGRESS PortMirroringDirectionEnum = "EGRESS"
	// PortMirroringDirectionEnumINGRESS - is ingress
	PortMirroringDirectionEnumINGRESS PortMirroringDirectionEnum = "INGRESS"
)

func PossiblePortMirroringDirectionEnumValues ¶

func PossiblePortMirroringDirectionEnumValues() []PortMirroringDirectionEnum

PossiblePortMirroringDirectionEnumValues returns the possible values for the PortMirroringDirectionEnum const type.

type PortMirroringStatusEnum ¶

type PortMirroringStatusEnum string

PortMirroringStatusEnum - Port Mirroring status

const (
	// PortMirroringStatusEnumFAILURE - is failure
	PortMirroringStatusEnumFAILURE PortMirroringStatusEnum = "FAILURE"
	// PortMirroringStatusEnumSUCCESS - is success
	PortMirroringStatusEnumSUCCESS PortMirroringStatusEnum = "SUCCESS"
)

func PossiblePortMirroringStatusEnumValues ¶

func PossiblePortMirroringStatusEnumValues() []PortMirroringStatusEnum

PossiblePortMirroringStatusEnumValues returns the possible values for the PortMirroringStatusEnum const type.

type PrivateCloud ¶

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

	// REQUIRED; The SKU (Stock Keeping Unit) assigned to this resource.
	SKU *SKU

	// The managed service identities assigned to this resource.
	Identity *PrivateCloudIdentity

	// The resource-specific properties for this resource.
	Properties *PrivateCloudProperties

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

	// The availability zones.
	Zones []*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

PrivateCloud - A private cloud resource

func (PrivateCloud) MarshalJSON ¶

func (p PrivateCloud) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateCloud.

func (*PrivateCloud) UnmarshalJSON ¶

func (p *PrivateCloud) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloud.

type PrivateCloudIdentity ¶

type PrivateCloudIdentity struct {
	// REQUIRED; The type of managed identity assigned to this resource.
	Type *ResourceIdentityType

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string
}

PrivateCloudIdentity - Managed service identity (either system assigned, or none)

func (PrivateCloudIdentity) MarshalJSON ¶

func (p PrivateCloudIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateCloudIdentity.

func (*PrivateCloudIdentity) UnmarshalJSON ¶

func (p *PrivateCloudIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloudIdentity.

type PrivateCloudList ¶

type PrivateCloudList struct {
	// REQUIRED; The PrivateCloud items on this page
	Value []*PrivateCloud

	// The link to the next page of items
	NextLink *string
}

PrivateCloudList - The response of a PrivateCloud list operation.

func (PrivateCloudList) MarshalJSON ¶

func (p PrivateCloudList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateCloudList.

func (*PrivateCloudList) UnmarshalJSON ¶

func (p *PrivateCloudList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloudList.

type PrivateCloudProperties ¶

type PrivateCloudProperties struct {
	// REQUIRED; The default cluster used for management
	ManagementCluster *ManagementCluster

	// REQUIRED; The block of addresses should be unique across VNet in your subscription as
	// well as on-premise. Make sure the CIDR format is conformed to (A.B.C.D/X) where
	// A,B,C,D are between 0 and 255, and X is between 0 and 22
	NetworkBlock *string

	// Properties describing how the cloud is distributed across availability zones
	Availability *AvailabilityProperties

	// An ExpressRoute Circuit
	Circuit *Circuit

	// The type of DNS zone to use.
	DNSZoneType *DNSZoneType

	// Customer managed key encryption, can be enabled or disabled
	Encryption *Encryption

	// Array of additional networks noncontiguous with networkBlock. Networks must be
	// unique and non-overlapping across VNet in your subscription, on-premise, and
	// this privateCloud networkBlock attribute. Make sure the CIDR format conforms to
	// (A.B.C.D/X).
	ExtendedNetworkBlocks []*string

	// vCenter Single Sign On Identity Sources
	IdentitySources []*IdentitySource

	// Connectivity to internet is enabled or disabled
	Internet *InternetEnum

	// Optionally, set the NSX-T Manager password when the private cloud is created
	NsxtPassword *string

	// A secondary expressRoute circuit from a separate AZ. Only present in a
	// stretched private cloud
	SecondaryCircuit *Circuit

	// Optionally, set the vCenter admin password when the private cloud is created
	VcenterPassword *string

	// The private cloud license
	VcfLicense VcfLicenseClassification

	// Azure resource ID of the virtual network
	VirtualNetworkID *string

	// READ-ONLY; The endpoints
	Endpoints *Endpoints

	// READ-ONLY; Array of cloud link IDs from other clouds that connect to this one
	ExternalCloudLinks []*string

	// READ-ONLY; Network used to access vCenter Server and NSX-T Manager
	ManagementNetwork *string

	// READ-ONLY; Flag to indicate whether the private cloud has the quota for provisioned NSX
	// Public IP count raised from 64 to 1024
	NsxPublicIPQuotaRaised *NsxPublicIPQuotaRaisedEnum

	// READ-ONLY; Thumbprint of the NSX-T Manager SSL certificate
	NsxtCertificateThumbprint *string

	// READ-ONLY; Used for virtual machine cold migration, cloning, and snapshot migration
	ProvisioningNetwork *string

	// READ-ONLY; The provisioning state
	ProvisioningState *PrivateCloudProvisioningState

	// READ-ONLY; Thumbprint of the vCenter Server SSL certificate
	VcenterCertificateThumbprint *string

	// READ-ONLY; Used for live migration of virtual machines
	VmotionNetwork *string
}

PrivateCloudProperties - The properties of a private cloud resource

func (PrivateCloudProperties) MarshalJSON ¶

func (p PrivateCloudProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateCloudProperties.

func (*PrivateCloudProperties) UnmarshalJSON ¶

func (p *PrivateCloudProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloudProperties.

type PrivateCloudProvisioningState ¶

type PrivateCloudProvisioningState string

PrivateCloudProvisioningState - private cloud provisioning state

const (
	// PrivateCloudProvisioningStateBuilding - is building
	PrivateCloudProvisioningStateBuilding PrivateCloudProvisioningState = "Building"
	// PrivateCloudProvisioningStateCanceled - Resource creation was canceled.
	PrivateCloudProvisioningStateCanceled PrivateCloudProvisioningState = "Canceled"
	// PrivateCloudProvisioningStateCancelled - is cancelled
	PrivateCloudProvisioningStateCancelled PrivateCloudProvisioningState = "Cancelled"
	// PrivateCloudProvisioningStateDeleting - is deleting
	PrivateCloudProvisioningStateDeleting PrivateCloudProvisioningState = "Deleting"
	// PrivateCloudProvisioningStateFailed - Resource creation failed.
	PrivateCloudProvisioningStateFailed PrivateCloudProvisioningState = "Failed"
	// PrivateCloudProvisioningStatePending - is pending
	PrivateCloudProvisioningStatePending PrivateCloudProvisioningState = "Pending"
	// PrivateCloudProvisioningStateSucceeded - Resource has been created.
	PrivateCloudProvisioningStateSucceeded PrivateCloudProvisioningState = "Succeeded"
	// PrivateCloudProvisioningStateUpdating - is updating
	PrivateCloudProvisioningStateUpdating PrivateCloudProvisioningState = "Updating"
)

func PossiblePrivateCloudProvisioningStateValues ¶

func PossiblePrivateCloudProvisioningStateValues() []PrivateCloudProvisioningState

PossiblePrivateCloudProvisioningStateValues returns the possible values for the PrivateCloudProvisioningState const type.

type PrivateCloudUpdate ¶

type PrivateCloudUpdate struct {
	// The managed service identities assigned to this resource.
	Identity *PrivateCloudIdentity

	// The updatable properties of a private cloud resource
	Properties *PrivateCloudUpdateProperties

	// The SKU (Stock Keeping Unit) assigned to this resource.
	SKU *SKU

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

PrivateCloudUpdate - An update to a private cloud resource

func (PrivateCloudUpdate) MarshalJSON ¶

func (p PrivateCloudUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateCloudUpdate.

func (*PrivateCloudUpdate) UnmarshalJSON ¶

func (p *PrivateCloudUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloudUpdate.

type PrivateCloudUpdateProperties ¶

type PrivateCloudUpdateProperties struct {
	// Properties describing how the cloud is distributed across availability zones
	Availability *AvailabilityProperties

	// The type of DNS zone to use.
	DNSZoneType *DNSZoneType

	// Customer managed key encryption, can be enabled or disabled
	Encryption *Encryption

	// Array of additional networks noncontiguous with networkBlock. Networks must be
	// unique and non-overlapping across VNet in your subscription, on-premise, and
	// this privateCloud networkBlock attribute. Make sure the CIDR format conforms to
	// (A.B.C.D/X).
	ExtendedNetworkBlocks []*string

	// vCenter Single Sign On Identity Sources
	IdentitySources []*IdentitySource

	// Connectivity to internet is enabled or disabled
	Internet *InternetEnum

	// The default cluster used for management
	ManagementCluster *ManagementCluster
}

PrivateCloudUpdateProperties - The properties of a private cloud resource that may be updated

func (PrivateCloudUpdateProperties) MarshalJSON ¶

func (p PrivateCloudUpdateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateCloudUpdateProperties.

func (*PrivateCloudUpdateProperties) UnmarshalJSON ¶

func (p *PrivateCloudUpdateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloudUpdateProperties.

type PrivateCloudsClient ¶

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

PrivateCloudsClient contains the methods for the PrivateClouds group. Don't use this type directly, use NewPrivateCloudsClient() instead.

Generated from API version 2026-03-01

func NewPrivateCloudsClient ¶

func NewPrivateCloudsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateCloudsClient, error)

NewPrivateCloudsClient creates a new instance of PrivateCloudsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*PrivateCloudsClient) BeginCreateOrUpdate ¶

func (client *PrivateCloudsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud, options *PrivateCloudsClientBeginCreateOrUpdateOptions) (*runtime.Poller[PrivateCloudsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a PrivateCloud If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
privateCloud - Resource create parameters.
options - PrivateCloudsClientBeginCreateOrUpdateOptions contains the optional parameters for the PrivateCloudsClient.BeginCreateOrUpdate method.

Example (PrivateCloudsCreateOrUpdate) ¶

Generated from example definition: 2026-03-01/PrivateClouds_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
	"time"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", armavs.PrivateCloud{
		Location: to.Ptr("eastus2"),
		SKU: &armavs.SKU{
			Name: to.Ptr("AV36"),
		},
		Identity: &armavs.PrivateCloudIdentity{
			Type: to.Ptr(armavs.ResourceIdentityTypeSystemAssigned),
		},
		Properties: &armavs.PrivateCloudProperties{
			NetworkBlock: to.Ptr("192.168.48.0/22"),
			ManagementCluster: &armavs.ManagementCluster{
				ClusterSize: to.Ptr[int32](4),
			},
			VcfLicense: &armavs.Vcf5License{
				Kind:                   to.Ptr(armavs.VcfLicenseKindVcf5),
				LicenseKey:             to.Ptr("12345-12345-12345-12345-12345"),
				EndDate:                to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
				Cores:                  to.Ptr[int32](16),
				BroadcomSiteID:         to.Ptr("123456"),
				BroadcomContractNumber: to.Ptr("123456"),
			},
		},
		Tags: map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armavs.PrivateCloudsClientCreateOrUpdateResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
	// 				Zone: to.Ptr[int32](1),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				VsanDatastoreName: to.Ptr("vsanDatastore1"),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://192.168.50.3/"),
	// 				Vcsa: to.Ptr("https://192.168.50.2/"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			VcfLicense: &armavs.Vcf5License{
	// 				Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 				EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 				Cores: to.Ptr[int32](16),
	// 				BroadcomSiteID: to.Ptr("123456"),
	// 				BroadcomContractNumber: to.Ptr("123456"),
	// 				ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

Example (PrivateCloudsCreateOrUpdateFleetNative) ¶

Generated from example definition: 2026-03-01/PrivateClouds_CreateOrUpdate_FleetNative.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
	"time"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", armavs.PrivateCloud{
		Location: to.Ptr("eastus2"),
		SKU: &armavs.SKU{
			Name: to.Ptr("AV64"),
		},
		Properties: &armavs.PrivateCloudProperties{
			NetworkBlock:     to.Ptr("192.168.48.0/22"),
			VirtualNetworkID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/virtualNetworks/vnet"),
			DNSZoneType:      to.Ptr(armavs.DNSZoneTypePrivate),
			ManagementCluster: &armavs.ManagementCluster{
				ClusterSize: to.Ptr[int32](4),
			},
			VcfLicense: &armavs.Vcf5License{
				Kind:                   to.Ptr(armavs.VcfLicenseKindVcf5),
				LicenseKey:             to.Ptr("12345-12345-12345-12345-12345"),
				EndDate:                to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
				Cores:                  to.Ptr[int32](16),
				BroadcomSiteID:         to.Ptr("123456"),
				BroadcomContractNumber: to.Ptr("123456"),
			},
		},
		Tags: map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armavs.PrivateCloudsClientCreateOrUpdateResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("cloud1"),
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
	// 			},
	// 			DNSZoneType: to.Ptr(armavs.DNSZoneTypePrivate),
	// 			Encryption: &armavs.Encryption{
	// 				Status: to.Ptr(armavs.EncryptionStateDisabled),
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				HcxCloudManager: to.Ptr("https://hcx.c2e20fa95ec249939dc7e3.mockenvavs.azure.com/"),
	// 				HcxCloudManagerIP: to.Ptr("10.31.0.37"),
	// 				NsxtManager: to.Ptr("https://nsx.c2e20fa95ec249939dc7e3.mockenvavs.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("10.31.0.4"),
	// 				VcenterIP: to.Ptr("10.31.0.36"),
	// 				Vcsa: to.Ptr("https://vc.c2e20fa95ec249939dc7e3.mockenvavs.azure.com/"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 				ProvisioningState: to.Ptr(armavs.ClusterProvisioningState("Building")),
	// 				VsanDatastoreName: to.Ptr("vsanDatastore"),
	// 			},
	// 			ManagementNetwork: to.Ptr("10.31.0.0/26"),
	// 			NetworkBlock: to.Ptr("10.31.0.0/22"),
	// 			NsxPublicIPQuotaRaised: to.Ptr(armavs.NsxPublicIPQuotaRaisedEnumDisabled),
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateBuilding),
	// 			VirtualNetworkID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup/providers/Microsoft.Network/virtualNetworks/mock-vnet"),
	// 			VmotionNetwork: to.Ptr("10.31.2.0/24"),
	// 			VcfLicense: &armavs.Vcf5License{
	// 				Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 				EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 				Cores: to.Ptr[int32](16),
	// 				BroadcomSiteID: to.Ptr("123456"),
	// 				BroadcomContractNumber: to.Ptr("123456"),
	// 				ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 			},
	// 		},
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("av64"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

Example (PrivateCloudsCreateOrUpdateStretched) ¶

Generated from example definition: 2026-03-01/PrivateClouds_CreateOrUpdate_Stretched.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
	"time"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", armavs.PrivateCloud{
		Location: to.Ptr("eastus2"),
		SKU: &armavs.SKU{
			Name: to.Ptr("AV36"),
		},
		Properties: &armavs.PrivateCloudProperties{
			Availability: &armavs.AvailabilityProperties{
				Strategy:      to.Ptr(armavs.AvailabilityStrategyDualZone),
				Zone:          to.Ptr[int32](1),
				SecondaryZone: to.Ptr[int32](2),
			},
			NetworkBlock: to.Ptr("192.168.48.0/22"),
			ManagementCluster: &armavs.ManagementCluster{
				ClusterSize: to.Ptr[int32](4),
			},
			VcfLicense: &armavs.Vcf5License{
				Kind:                   to.Ptr(armavs.VcfLicenseKindVcf5),
				LicenseKey:             to.Ptr("12345-12345-12345-12345-12345"),
				EndDate:                to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
				Cores:                  to.Ptr[int32](16),
				BroadcomSiteID:         to.Ptr("123456"),
				BroadcomContractNumber: to.Ptr("123456"),
			},
		},
		Tags: map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armavs.PrivateCloudsClientCreateOrUpdateResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Zones: []*string{
	// 			to.Ptr("1"),
	// 			to.Ptr("2"),
	// 		},
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
	// 				Zone: to.Ptr[int32](1),
	// 				SecondaryZone: to.Ptr[int32](2),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 			},
	// 			SecondaryCircuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect2"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 				VcenterIP: to.Ptr("192.168.50.2"),
	// 				HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			VcfLicense: &armavs.Vcf5License{
	// 				Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 				EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 				Cores: to.Ptr[int32](16),
	// 				BroadcomSiteID: to.Ptr("123456"),
	// 				BroadcomContractNumber: to.Ptr("123456"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

Example (PrivateCloudsCreateOrUpdateStretchedZones) ¶

Generated from example definition: 2026-03-01/PrivateClouds_CreateOrUpdate_StretchedZones.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
	"time"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", armavs.PrivateCloud{
		Location: to.Ptr("eastus2"),
		Zones: []*string{
			to.Ptr("1"),
			to.Ptr("2"),
		},
		SKU: &armavs.SKU{
			Name: to.Ptr("AV36"),
		},
		Properties: &armavs.PrivateCloudProperties{
			NetworkBlock: to.Ptr("192.168.48.0/22"),
			ManagementCluster: &armavs.ManagementCluster{
				ClusterSize: to.Ptr[int32](4),
			},
			VcfLicense: &armavs.Vcf5License{
				Kind:                   to.Ptr(armavs.VcfLicenseKindVcf5),
				LicenseKey:             to.Ptr("12345-12345-12345-12345-12345"),
				EndDate:                to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
				Cores:                  to.Ptr[int32](16),
				BroadcomSiteID:         to.Ptr("123456"),
				BroadcomContractNumber: to.Ptr("123456"),
			},
		},
		Tags: map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armavs.PrivateCloudsClientCreateOrUpdateResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Zones: []*string{
	// 			to.Ptr("1"),
	// 			to.Ptr("2"),
	// 		},
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
	// 				Zone: to.Ptr[int32](1),
	// 				SecondaryZone: to.Ptr[int32](2),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 			},
	// 			SecondaryCircuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect2"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 				VcenterIP: to.Ptr("192.168.50.2"),
	// 				HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			VcfLicense: &armavs.Vcf5License{
	// 				Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 				EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 				Cores: to.Ptr[int32](16),
	// 				BroadcomSiteID: to.Ptr("123456"),
	// 				BroadcomContractNumber: to.Ptr("123456"),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

func (*PrivateCloudsClient) BeginDelete ¶

func (client *PrivateCloudsClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, options *PrivateCloudsClientBeginDeleteOptions) (*runtime.Poller[PrivateCloudsClientDeleteResponse], error)

BeginDelete - Delete a PrivateCloud If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PrivateCloudsClientBeginDeleteOptions contains the optional parameters for the PrivateCloudsClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/PrivateClouds_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginDelete(ctx, "group1", "cloud1", 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 poll 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 = armavs.PrivateCloudsClientDeleteResponse{
	// }
}

Output:

func (*PrivateCloudsClient) BeginRotateNsxtPassword ¶

func (client *PrivateCloudsClient) BeginRotateNsxtPassword(ctx context.Context, resourceGroupName string, privateCloudName string, options *PrivateCloudsClientBeginRotateNsxtPasswordOptions) (*runtime.Poller[PrivateCloudsClientRotateNsxtPasswordResponse], error)

BeginRotateNsxtPassword - Rotate the NSX-T Manager password If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PrivateCloudsClientBeginRotateNsxtPasswordOptions contains the optional parameters for the PrivateCloudsClient.BeginRotateNsxtPassword method.

Example ¶

Generated from example definition: 2026-03-01/PrivateClouds_RotateNsxtPassword.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginRotateNsxtPassword(ctx, "group1", "cloud1", 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 poll the result: %v", err)
	}
}

Output:

func (*PrivateCloudsClient) BeginRotateVcenterPassword ¶

func (client *PrivateCloudsClient) BeginRotateVcenterPassword(ctx context.Context, resourceGroupName string, privateCloudName string, options *PrivateCloudsClientBeginRotateVcenterPasswordOptions) (*runtime.Poller[PrivateCloudsClientRotateVcenterPasswordResponse], error)

BeginRotateVcenterPassword - Rotate the vCenter password If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PrivateCloudsClientBeginRotateVcenterPasswordOptions contains the optional parameters for the PrivateCloudsClient.BeginRotateVcenterPassword method.

Example ¶

Generated from example definition: 2026-03-01/PrivateClouds_RotateVcenterPassword.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginRotateVcenterPassword(ctx, "group1", "cloud1", 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 poll the result: %v", err)
	}
}

Output:

func (*PrivateCloudsClient) BeginUpdate ¶

func (client *PrivateCloudsClient) BeginUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate, options *PrivateCloudsClientBeginUpdateOptions) (*runtime.Poller[PrivateCloudsClientUpdateResponse], error)

BeginUpdate - Update a PrivateCloud If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
privateCloudUpdate - The resource properties to be updated.
options - PrivateCloudsClientBeginUpdateOptions contains the optional parameters for the PrivateCloudsClient.BeginUpdate method.

Example (PrivateCloudsUpdate) ¶

Generated from example definition: 2026-03-01/PrivateClouds_Update.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginUpdate(ctx, "group1", "cloud1", armavs.PrivateCloudUpdate{
		Identity: &armavs.PrivateCloudIdentity{
			Type: to.Ptr(armavs.ResourceIdentityTypeNone),
		},
		Properties: &armavs.PrivateCloudUpdateProperties{
			ManagementCluster: &armavs.ManagementCluster{
				ClusterSize: to.Ptr[int32](4),
			},
			Encryption: &armavs.Encryption{
				Status: to.Ptr(armavs.EncryptionStateEnabled),
				KeyVaultProperties: &armavs.EncryptionKeyVaultProperties{
					KeyName:     to.Ptr("keyname1"),
					KeyVersion:  to.Ptr("ver1.0"),
					KeyVaultURL: to.Ptr("https://keyvault1-kmip-kvault.vault.azure.net/"),
				},
			},
		},
	}, 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 poll 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 = armavs.PrivateCloudsClientUpdateResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
	// 				Zone: to.Ptr[int32](1),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Encryption: &armavs.Encryption{
	// 				Status: to.Ptr(armavs.EncryptionStateEnabled),
	// 				KeyVaultProperties: &armavs.EncryptionKeyVaultProperties{
	// 					KeyName: to.Ptr("keyname1"),
	// 					KeyVersion: to.Ptr("ver1.0"),
	// 					KeyVaultURL: to.Ptr("https://keyvault1-kmip-kvault.vault.azure.net/"),
	// 					VersionType: to.Ptr(armavs.EncryptionVersionTypeFixed),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 				VcenterIP: to.Ptr("192.168.50.2"),
	// 				HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

Example (PrivateCloudsUpdateStretched) ¶

Generated from example definition: 2026-03-01/PrivateClouds_Update_Stretched.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateCloudsClient().BeginUpdate(ctx, "group1", "cloud1", armavs.PrivateCloudUpdate{
		Properties: &armavs.PrivateCloudUpdateProperties{
			ManagementCluster: &armavs.ManagementCluster{
				ClusterSize: to.Ptr[int32](4),
			},
		},
	}, 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 poll 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 = armavs.PrivateCloudsClientUpdateResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
	// 				Zone: to.Ptr[int32](1),
	// 				SecondaryZone: to.Ptr[int32](2),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
	// 			},
	// 			SecondaryCircuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect2"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er2/peerings/AzurePrivatePeering"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 				VcenterIP: to.Ptr("192.168.50.2"),
	// 				HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

func (*PrivateCloudsClient) Get ¶

func (client *PrivateCloudsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, options *PrivateCloudsClientGetOptions) (PrivateCloudsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PrivateCloudsClientGetOptions contains the optional parameters for the PrivateCloudsClient.Get method.

Example (PrivateCloudsGet) ¶

Generated from example definition: 2026-03-01/PrivateClouds_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateCloudsClient().Get(ctx, "group1", "cloud1", 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 = armavs.PrivateCloudsClientGetResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Identity: &armavs.PrivateCloudIdentity{
	// 			PrincipalID: to.Ptr("881e5573-063f-49e4-8c08-79d7df0169d8"),
	// 			TenantID: to.Ptr("881e5573-063f-49e4-8c08-79d7df0169d8"),
	// 			Type: to.Ptr(armavs.ResourceIdentityTypeSystemAssigned),
	// 		},
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
	// 				Zone: to.Ptr[int32](1),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				VsanDatastoreName: to.Ptr("vsanDatastore1"),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Encryption: &armavs.Encryption{
	// 				Status: to.Ptr(armavs.EncryptionStateEnabled),
	// 				KeyVaultProperties: &armavs.EncryptionKeyVaultProperties{
	// 					KeyName: to.Ptr("keyname1"),
	// 					KeyVersion: to.Ptr("ver1.0"),
	// 					KeyVaultURL: to.Ptr("https://keyvault1-kmip-kvault.vault.azure.net/"),
	// 					KeyState: to.Ptr(armavs.EncryptionKeyStatusConnected),
	// 					VersionType: to.Ptr(armavs.EncryptionVersionTypeFixed),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 				VcenterIP: to.Ptr("192.168.50.2"),
	// 				HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			VcfLicense: &armavs.Vcf5License{
	// 				Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 				EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 				Cores: to.Ptr[int32](16),
	// 				BroadcomSiteID: to.Ptr("123456"),
	// 				BroadcomContractNumber: to.Ptr("123456"),
	// 				ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

Example (PrivateCloudsGetStretched) ¶

Generated from example definition: 2026-03-01/PrivateClouds_Get_Stretched.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateCloudsClient().Get(ctx, "group1", "cloud1", 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 = armavs.PrivateCloudsClientGetResponse{
	// 	PrivateCloud: armavs.PrivateCloud{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("cloud1"),
	// 		SKU: &armavs.SKU{
	// 			Name: to.Ptr("AV36"),
	// 		},
	// 		Properties: &armavs.PrivateCloudProperties{
	// 			Availability: &armavs.AvailabilityProperties{
	// 				Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
	// 				Zone: to.Ptr[int32](1),
	// 				SecondaryZone: to.Ptr[int32](2),
	// 			},
	// 			NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 			Circuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
	// 			},
	// 			SecondaryCircuit: &armavs.Circuit{
	// 				ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
	// 				PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 				SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er2/peerings/AzurePrivatePeering"),
	// 			},
	// 			ManagementCluster: &armavs.ManagementCluster{
	// 				ClusterID: to.Ptr[int32](1),
	// 				ClusterSize: to.Ptr[int32](4),
	// 				VsanDatastoreName: to.Ptr("vsanDatastore1"),
	// 				Hosts: []*string{
	// 					to.Ptr("fakehost18.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost19.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost20.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost21.nyc1.kubernetes.center"),
	// 				},
	// 			},
	// 			Endpoints: &armavs.Endpoints{
	// 				NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 				VcenterIP: to.Ptr("192.168.50.2"),
	// 				HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 			},
	// 			ExternalCloudLinks: []*string{
	// 				to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
	// 			},
	// 			IdentitySources: []*armavs.IdentitySource{
	// 				{
	// 					Alias: to.Ptr("groupAlias"),
	// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 					BaseUserDN: to.Ptr("ou=baseUser"),
	// 					Domain: to.Ptr("domain1"),
	// 					Name: to.Ptr("group1"),
	// 					PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
	// 					SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
	// 					SSL: to.Ptr(armavs.SSLEnumEnabled),
	// 				},
	// 			},
	// 			Internet: to.Ptr(armavs.InternetEnumDisabled),
	// 			VcfLicense: &armavs.Vcf5License{
	// 				Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 				EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 				Cores: to.Ptr[int32](16),
	// 				BroadcomSiteID: to.Ptr("123456"),
	// 				BroadcomContractNumber: to.Ptr("123456"),
	// 				ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 			},
	// 			ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 	},
	// }
}

Output:

func (*PrivateCloudsClient) GetVcfLicense ¶ added in v2.2.0

func (client *PrivateCloudsClient) GetVcfLicense(ctx context.Context, resourceGroupName string, privateCloudName string, options *PrivateCloudsClientGetVcfLicenseOptions) (PrivateCloudsClientGetVcfLicenseResponse, error)

GetVcfLicense - Get the license for the private cloud If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PrivateCloudsClientGetVcfLicenseOptions contains the optional parameters for the PrivateCloudsClient.GetVcfLicense method.

Example ¶

Generated from example definition: 2026-03-01/PrivateClouds_GetVcfLicense.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateCloudsClient().GetVcfLicense(ctx, "group1", "cloud1", 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 = armavs.PrivateCloudsClientGetVcfLicenseResponse{
	// 	VcfLicenseClassification: &armavs.Vcf5License{
	// 		Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
	// 		LicenseKey: to.Ptr("12345-12345-12345-12345-12345"),
	// 		EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 		Cores: to.Ptr[int32](16),
	// 		BroadcomSiteID: to.Ptr("123456"),
	// 		BroadcomContractNumber: to.Ptr("123456"),
	// 		ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*PrivateCloudsClient) ListAdminCredentials ¶

func (client *PrivateCloudsClient) ListAdminCredentials(ctx context.Context, resourceGroupName string, privateCloudName string, options *PrivateCloudsClientListAdminCredentialsOptions) (PrivateCloudsClientListAdminCredentialsResponse, error)

ListAdminCredentials - List the admin credentials for the private cloud If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PrivateCloudsClientListAdminCredentialsOptions contains the optional parameters for the PrivateCloudsClient.ListAdminCredentials method.

Example ¶

Generated from example definition: 2026-03-01/PrivateClouds_ListAdminCredentials.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateCloudsClient().ListAdminCredentials(ctx, "group1", "cloud1", 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 = armavs.PrivateCloudsClientListAdminCredentialsResponse{
	// 	AdminCredentials: armavs.AdminCredentials{
	// 		NsxtPassword: to.Ptr("$(1X4Dkk"),
	// 		NsxtUsername: to.Ptr("admin"),
	// 		VcenterPassword: to.Ptr(""),
	// 		VcenterUsername: to.Ptr("cloudadmin@vsphere.local"),
	// 	},
	// }
}

Output:

func (*PrivateCloudsClient) NewListInSubscriptionPager ¶

func (client *PrivateCloudsClient) NewListInSubscriptionPager(options *PrivateCloudsClientListInSubscriptionOptions) *runtime.Pager[PrivateCloudsClientListInSubscriptionResponse]

NewListInSubscriptionPager - List PrivateCloud resources by subscription ID

options - PrivateCloudsClientListInSubscriptionOptions contains the optional parameters for the PrivateCloudsClient.NewListInSubscriptionPager method.

Example (PrivateCloudsListInSubscription) ¶

Generated from example definition: 2026-03-01/PrivateClouds_ListInSubscription.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateCloudsClient().NewListInSubscriptionPager(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 = armavs.PrivateCloudsClientListInSubscriptionResponse{
		// 	PrivateCloudList: armavs.PrivateCloudList{
		// 		Value: []*armavs.PrivateCloud{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
		// 				Location: to.Ptr("eastus2"),
		// 				Name: to.Ptr("cloud1"),
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("AV36"),
		// 				},
		// 				Properties: &armavs.PrivateCloudProperties{
		// 					Availability: &armavs.AvailabilityProperties{
		// 						Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
		// 						Zone: to.Ptr[int32](1),
		// 					},
		// 					NetworkBlock: to.Ptr("192.168.48.0/22"),
		// 					Circuit: &armavs.Circuit{
		// 						ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
		// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
		// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
		// 						ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
		// 					},
		// 					ManagementCluster: &armavs.ManagementCluster{
		// 						ClusterID: to.Ptr[int32](1),
		// 						ClusterSize: to.Ptr[int32](4),
		// 						VsanDatastoreName: to.Ptr("vsanDatastore1"),
		// 						Hosts: []*string{
		// 							to.Ptr("fakehost18.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost19.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost20.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost21.nyc1.kubernetes.center"),
		// 						},
		// 					},
		// 					Endpoints: &armavs.Endpoints{
		// 						NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						NsxtManagerIP: to.Ptr("192.168.50.3"),
		// 						VcenterIP: to.Ptr("192.168.50.2"),
		// 						HcxCloudManagerIP: to.Ptr("192.168.50.4"),
		// 					},
		// 					IdentitySources: []*armavs.IdentitySource{
		// 						{
		// 							Alias: to.Ptr("groupAlias"),
		// 							BaseGroupDN: to.Ptr("ou=baseGroup"),
		// 							BaseUserDN: to.Ptr("ou=baseUser"),
		// 							Domain: to.Ptr("domain1"),
		// 							Name: to.Ptr("group1"),
		// 							PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
		// 							SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
		// 							SSL: to.Ptr(armavs.SSLEnumEnabled),
		// 						},
		// 					},
		// 					Internet: to.Ptr(armavs.InternetEnumDisabled),
		// 					VcfLicense: &armavs.Vcf5License{
		// 						Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
		// 						EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
		// 						Cores: to.Ptr[int32](16),
		// 						BroadcomSiteID: to.Ptr("123456"),
		// 						BroadcomContractNumber: to.Ptr("123456"),
		// 						ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Example (PrivateCloudsListInSubscriptionStretched) ¶

Generated from example definition: 2026-03-01/PrivateClouds_ListInSubscription_Stretched.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateCloudsClient().NewListInSubscriptionPager(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 = armavs.PrivateCloudsClientListInSubscriptionResponse{
		// 	PrivateCloudList: armavs.PrivateCloudList{
		// 		Value: []*armavs.PrivateCloud{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
		// 				Location: to.Ptr("eastus2"),
		// 				Name: to.Ptr("cloud1"),
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("AV36"),
		// 				},
		// 				Properties: &armavs.PrivateCloudProperties{
		// 					Availability: &armavs.AvailabilityProperties{
		// 						Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
		// 						Zone: to.Ptr[int32](1),
		// 						SecondaryZone: to.Ptr[int32](2),
		// 					},
		// 					NetworkBlock: to.Ptr("192.168.48.0/22"),
		// 					Circuit: &armavs.Circuit{
		// 						ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
		// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
		// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
		// 						ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
		// 					},
		// 					SecondaryCircuit: &armavs.Circuit{
		// 						ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect2"),
		// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
		// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
		// 						ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er2/peerings/AzurePrivatePeering"),
		// 					},
		// 					ManagementCluster: &armavs.ManagementCluster{
		// 						ClusterID: to.Ptr[int32](1),
		// 						ClusterSize: to.Ptr[int32](4),
		// 						VsanDatastoreName: to.Ptr("vsanDatastore1"),
		// 						Hosts: []*string{
		// 							to.Ptr("fakehost18.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost19.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost20.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost21.nyc1.kubernetes.center"),
		// 						},
		// 					},
		// 					Endpoints: &armavs.Endpoints{
		// 						NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						NsxtManagerIP: to.Ptr("192.168.50.3"),
		// 						VcenterIP: to.Ptr("192.168.50.2"),
		// 						HcxCloudManagerIP: to.Ptr("192.168.50.4"),
		// 					},
		// 					IdentitySources: []*armavs.IdentitySource{
		// 						{
		// 							Alias: to.Ptr("groupAlias"),
		// 							BaseGroupDN: to.Ptr("ou=baseGroup"),
		// 							BaseUserDN: to.Ptr("ou=baseUser"),
		// 							Domain: to.Ptr("domain1"),
		// 							Name: to.Ptr("group1"),
		// 							PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
		// 							SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
		// 							SSL: to.Ptr(armavs.SSLEnumEnabled),
		// 						},
		// 					},
		// 					Internet: to.Ptr(armavs.InternetEnumDisabled),
		// 					VcfLicense: &armavs.Vcf5License{
		// 						Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
		// 						EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
		// 						Cores: to.Ptr[int32](16),
		// 						BroadcomSiteID: to.Ptr("123456"),
		// 						BroadcomContractNumber: to.Ptr("123456"),
		// 						ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*PrivateCloudsClient) NewListPager ¶

func (client *PrivateCloudsClient) NewListPager(resourceGroupName string, options *PrivateCloudsClientListOptions) *runtime.Pager[PrivateCloudsClientListResponse]

NewListPager - List PrivateCloud resources by resource group

resourceGroupName - The name of the resource group. The name is case insensitive.
options - PrivateCloudsClientListOptions contains the optional parameters for the PrivateCloudsClient.NewListPager method.

Example (PrivateCloudsList) ¶

Generated from example definition: 2026-03-01/PrivateClouds_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateCloudsClient().NewListPager("group1", 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 = armavs.PrivateCloudsClientListResponse{
		// 	PrivateCloudList: armavs.PrivateCloudList{
		// 		Value: []*armavs.PrivateCloud{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
		// 				Location: to.Ptr("eastus2"),
		// 				Name: to.Ptr("cloud1"),
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("AV36"),
		// 				},
		// 				Properties: &armavs.PrivateCloudProperties{
		// 					Availability: &armavs.AvailabilityProperties{
		// 						Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
		// 						Zone: to.Ptr[int32](1),
		// 					},
		// 					NetworkBlock: to.Ptr("192.168.48.0/22"),
		// 					Circuit: &armavs.Circuit{
		// 						ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
		// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
		// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
		// 						ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
		// 					},
		// 					ManagementCluster: &armavs.ManagementCluster{
		// 						ClusterID: to.Ptr[int32](1),
		// 						ClusterSize: to.Ptr[int32](4),
		// 						VsanDatastoreName: to.Ptr("vsanDatastore1"),
		// 						Hosts: []*string{
		// 							to.Ptr("fakehost18.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost19.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost20.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost21.nyc1.kubernetes.center"),
		// 						},
		// 					},
		// 					Endpoints: &armavs.Endpoints{
		// 						NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						NsxtManagerIP: to.Ptr("192.168.50.3"),
		// 						VcenterIP: to.Ptr("192.168.50.2"),
		// 						HcxCloudManagerIP: to.Ptr("192.168.50.4"),
		// 					},
		// 					ExternalCloudLinks: []*string{
		// 						to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
		// 					},
		// 					IdentitySources: []*armavs.IdentitySource{
		// 						{
		// 							Alias: to.Ptr("groupAlias"),
		// 							BaseGroupDN: to.Ptr("ou=baseGroup"),
		// 							BaseUserDN: to.Ptr("ou=baseUser"),
		// 							Domain: to.Ptr("domain1"),
		// 							Name: to.Ptr("group1"),
		// 							PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
		// 							SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
		// 							SSL: to.Ptr(armavs.SSLEnumEnabled),
		// 						},
		// 					},
		// 					Internet: to.Ptr(armavs.InternetEnumDisabled),
		// 					VcfLicense: &armavs.Vcf5License{
		// 						Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
		// 						EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
		// 						Cores: to.Ptr[int32](16),
		// 						BroadcomSiteID: to.Ptr("123456"),
		// 						BroadcomContractNumber: to.Ptr("123456"),
		// 						ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

Example (PrivateCloudsListStretched) ¶

Generated from example definition: 2026-03-01/PrivateClouds_List_Stretched.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateCloudsClient().NewListPager("group1", 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 = armavs.PrivateCloudsClientListResponse{
		// 	PrivateCloudList: armavs.PrivateCloudList{
		// 		Value: []*armavs.PrivateCloud{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
		// 				Location: to.Ptr("eastus2"),
		// 				Name: to.Ptr("cloud1"),
		// 				SKU: &armavs.SKU{
		// 					Name: to.Ptr("AV36"),
		// 				},
		// 				Properties: &armavs.PrivateCloudProperties{
		// 					Availability: &armavs.AvailabilityProperties{
		// 						Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
		// 						Zone: to.Ptr[int32](1),
		// 						SecondaryZone: to.Ptr[int32](2),
		// 					},
		// 					NetworkBlock: to.Ptr("192.168.48.0/22"),
		// 					Circuit: &armavs.Circuit{
		// 						ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect"),
		// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
		// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
		// 						ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er/peerings/AzurePrivatePeering"),
		// 					},
		// 					SecondaryCircuit: &armavs.Circuit{
		// 						ExpressRouteID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2/providers/Microsoft.Network/expressroutecircuits/tnt13-41a90db2-9d5e-4bd5-a77a-5ce7b58213d6-eastus2-xconnect2"),
		// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
		// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
		// 						ExpressRoutePrivatePeeringID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/tnt42-cust-p01-dmo01/providers/Microsoft.Network/expressroutecircuits/tnt42-cust-p01-dmo01-er2/peerings/AzurePrivatePeering"),
		// 					},
		// 					ManagementCluster: &armavs.ManagementCluster{
		// 						ClusterID: to.Ptr[int32](1),
		// 						ClusterSize: to.Ptr[int32](4),
		// 						Hosts: []*string{
		// 							to.Ptr("fakehost18.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost19.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost20.nyc1.kubernetes.center"),
		// 							to.Ptr("fakehost21.nyc1.kubernetes.center"),
		// 						},
		// 					},
		// 					Endpoints: &armavs.Endpoints{
		// 						NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
		// 						NsxtManagerIP: to.Ptr("192.168.50.3"),
		// 						VcenterIP: to.Ptr("192.168.50.2"),
		// 						HcxCloudManagerIP: to.Ptr("192.168.50.4"),
		// 					},
		// 					ExternalCloudLinks: []*string{
		// 						to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
		// 					},
		// 					IdentitySources: []*armavs.IdentitySource{
		// 						{
		// 							Alias: to.Ptr("groupAlias"),
		// 							BaseGroupDN: to.Ptr("ou=baseGroup"),
		// 							BaseUserDN: to.Ptr("ou=baseUser"),
		// 							Domain: to.Ptr("domain1"),
		// 							Name: to.Ptr("group1"),
		// 							PrimaryServer: to.Ptr("ldaps://1.1.1.1:636/"),
		// 							SecondaryServer: to.Ptr("ldaps://1.1.1.2:636/"),
		// 							SSL: to.Ptr(armavs.SSLEnumEnabled),
		// 						},
		// 					},
		// 					Internet: to.Ptr(armavs.InternetEnumDisabled),
		// 					VcfLicense: &armavs.Vcf5License{
		// 						Kind: to.Ptr(armavs.VcfLicenseKindVcf5),
		// 						EndDate: to.Ptr(time.Date(2025, time.December, 31, 23, 59, 59, 0, time.UTC)),
		// 						Cores: to.Ptr[int32](16),
		// 						BroadcomSiteID: to.Ptr("123456"),
		// 						BroadcomContractNumber: to.Ptr("123456"),
		// 						ProvisioningState: to.Ptr(armavs.LicenseProvisioningStateSucceeded),
		// 					},
		// 					ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type PrivateCloudsClientBeginCreateOrUpdateOptions ¶

type PrivateCloudsClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PrivateCloudsClientBeginCreateOrUpdateOptions contains the optional parameters for the PrivateCloudsClient.BeginCreateOrUpdate method.

type PrivateCloudsClientBeginDeleteOptions ¶

type PrivateCloudsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PrivateCloudsClientBeginDeleteOptions contains the optional parameters for the PrivateCloudsClient.BeginDelete method.

type PrivateCloudsClientBeginRotateNsxtPasswordOptions ¶

type PrivateCloudsClientBeginRotateNsxtPasswordOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PrivateCloudsClientBeginRotateNsxtPasswordOptions contains the optional parameters for the PrivateCloudsClient.BeginRotateNsxtPassword method.

type PrivateCloudsClientBeginRotateVcenterPasswordOptions ¶

type PrivateCloudsClientBeginRotateVcenterPasswordOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PrivateCloudsClientBeginRotateVcenterPasswordOptions contains the optional parameters for the PrivateCloudsClient.BeginRotateVcenterPassword method.

type PrivateCloudsClientBeginUpdateOptions ¶

type PrivateCloudsClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PrivateCloudsClientBeginUpdateOptions contains the optional parameters for the PrivateCloudsClient.BeginUpdate method.

type PrivateCloudsClientCreateOrUpdateResponse ¶

type PrivateCloudsClientCreateOrUpdateResponse struct {
	// A private cloud resource
	PrivateCloud
}

PrivateCloudsClientCreateOrUpdateResponse contains the response from method PrivateCloudsClient.BeginCreateOrUpdate.

type PrivateCloudsClientDeleteResponse ¶

type PrivateCloudsClientDeleteResponse struct {
}

PrivateCloudsClientDeleteResponse contains the response from method PrivateCloudsClient.BeginDelete.

type PrivateCloudsClientGetOptions ¶

type PrivateCloudsClientGetOptions struct {
}

PrivateCloudsClientGetOptions contains the optional parameters for the PrivateCloudsClient.Get method.

type PrivateCloudsClientGetResponse ¶

type PrivateCloudsClientGetResponse struct {
	// A private cloud resource
	PrivateCloud
}

PrivateCloudsClientGetResponse contains the response from method PrivateCloudsClient.Get.

type PrivateCloudsClientGetVcfLicenseOptions ¶ added in v2.2.0

type PrivateCloudsClientGetVcfLicenseOptions struct {
}

PrivateCloudsClientGetVcfLicenseOptions contains the optional parameters for the PrivateCloudsClient.GetVcfLicense method.

type PrivateCloudsClientGetVcfLicenseResponse ¶ added in v2.2.0

type PrivateCloudsClientGetVcfLicenseResponse struct {
	// A VMware Cloud Foundation license
	VcfLicenseClassification
}

PrivateCloudsClientGetVcfLicenseResponse contains the response from method PrivateCloudsClient.GetVcfLicense.

func (*PrivateCloudsClientGetVcfLicenseResponse) UnmarshalJSON ¶ added in v2.2.0

func (p *PrivateCloudsClientGetVcfLicenseResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateCloudsClientGetVcfLicenseResponse.

type PrivateCloudsClientListAdminCredentialsOptions ¶

type PrivateCloudsClientListAdminCredentialsOptions struct {
}

PrivateCloudsClientListAdminCredentialsOptions contains the optional parameters for the PrivateCloudsClient.ListAdminCredentials method.

type PrivateCloudsClientListAdminCredentialsResponse ¶

type PrivateCloudsClientListAdminCredentialsResponse struct {
	// Administrative credentials for accessing vCenter and NSX-T
	AdminCredentials
}

PrivateCloudsClientListAdminCredentialsResponse contains the response from method PrivateCloudsClient.ListAdminCredentials.

type PrivateCloudsClientListInSubscriptionOptions ¶

type PrivateCloudsClientListInSubscriptionOptions struct {
}

PrivateCloudsClientListInSubscriptionOptions contains the optional parameters for the PrivateCloudsClient.NewListInSubscriptionPager method.

type PrivateCloudsClientListInSubscriptionResponse ¶

type PrivateCloudsClientListInSubscriptionResponse struct {
	// The response of a PrivateCloud list operation.
	PrivateCloudList
}

PrivateCloudsClientListInSubscriptionResponse contains the response from method PrivateCloudsClient.NewListInSubscriptionPager.

type PrivateCloudsClientListOptions ¶

type PrivateCloudsClientListOptions struct {
}

PrivateCloudsClientListOptions contains the optional parameters for the PrivateCloudsClient.NewListPager method.

type PrivateCloudsClientListResponse ¶

type PrivateCloudsClientListResponse struct {
	// The response of a PrivateCloud list operation.
	PrivateCloudList
}

PrivateCloudsClientListResponse contains the response from method PrivateCloudsClient.NewListPager.

type PrivateCloudsClientRotateNsxtPasswordResponse ¶

type PrivateCloudsClientRotateNsxtPasswordResponse struct {
}

PrivateCloudsClientRotateNsxtPasswordResponse contains the response from method PrivateCloudsClient.BeginRotateNsxtPassword.

type PrivateCloudsClientRotateVcenterPasswordResponse ¶

type PrivateCloudsClientRotateVcenterPasswordResponse struct {
}

PrivateCloudsClientRotateVcenterPasswordResponse contains the response from method PrivateCloudsClient.BeginRotateVcenterPassword.

type PrivateCloudsClientUpdateResponse ¶

type PrivateCloudsClientUpdateResponse struct {
	// A private cloud resource
	PrivateCloud
}

PrivateCloudsClientUpdateResponse contains the response from method PrivateCloudsClient.BeginUpdate.

type ProvisionedNetwork ¶ added in v2.1.0

type ProvisionedNetwork struct {
	// The resource-specific properties for this resource.
	Properties *ProvisionedNetworkProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

ProvisionedNetwork - A provisioned network resource

func (ProvisionedNetwork) MarshalJSON ¶ added in v2.1.0

func (p ProvisionedNetwork) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProvisionedNetwork.

func (*ProvisionedNetwork) UnmarshalJSON ¶ added in v2.1.0

func (p *ProvisionedNetwork) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProvisionedNetwork.

type ProvisionedNetworkListResult ¶ added in v2.1.0

type ProvisionedNetworkListResult struct {
	// REQUIRED; The ProvisionedNetwork items on this page
	Value []*ProvisionedNetwork

	// The link to the next page of items
	NextLink *string
}

ProvisionedNetworkListResult - The response of a ProvisionedNetwork list operation.

func (ProvisionedNetworkListResult) MarshalJSON ¶ added in v2.1.0

func (p ProvisionedNetworkListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProvisionedNetworkListResult.

func (*ProvisionedNetworkListResult) UnmarshalJSON ¶ added in v2.1.0

func (p *ProvisionedNetworkListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProvisionedNetworkListResult.

type ProvisionedNetworkProperties ¶ added in v2.1.0

type ProvisionedNetworkProperties struct {
	// READ-ONLY; The address prefixes of the provisioned network in CIDR notation.
	AddressPrefix *string

	// READ-ONLY; The type of network provisioned.
	NetworkType *ProvisionedNetworkTypes

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

ProvisionedNetworkProperties - The properties of a provisioned network.

func (ProvisionedNetworkProperties) MarshalJSON ¶ added in v2.1.0

func (p ProvisionedNetworkProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProvisionedNetworkProperties.

func (*ProvisionedNetworkProperties) UnmarshalJSON ¶ added in v2.1.0

func (p *ProvisionedNetworkProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProvisionedNetworkProperties.

type ProvisionedNetworkProvisioningState ¶ added in v2.1.0

type ProvisionedNetworkProvisioningState string

ProvisionedNetworkProvisioningState - provisioned network provisioning state

const (
	// ProvisionedNetworkProvisioningStateCanceled - Resource creation was canceled.
	ProvisionedNetworkProvisioningStateCanceled ProvisionedNetworkProvisioningState = "Canceled"
	// ProvisionedNetworkProvisioningStateFailed - Resource creation failed.
	ProvisionedNetworkProvisioningStateFailed ProvisionedNetworkProvisioningState = "Failed"
	// ProvisionedNetworkProvisioningStateSucceeded - Resource has been created.
	ProvisionedNetworkProvisioningStateSucceeded ProvisionedNetworkProvisioningState = "Succeeded"
)

func PossibleProvisionedNetworkProvisioningStateValues ¶ added in v2.1.0

func PossibleProvisionedNetworkProvisioningStateValues() []ProvisionedNetworkProvisioningState

PossibleProvisionedNetworkProvisioningStateValues returns the possible values for the ProvisionedNetworkProvisioningState const type.

type ProvisionedNetworkTypes ¶ added in v2.1.0

type ProvisionedNetworkTypes string

ProvisionedNetworkTypes - The type of network provisioned.

const (
	// ProvisionedNetworkTypesEsxManagement - network for ESX management
	ProvisionedNetworkTypesEsxManagement ProvisionedNetworkTypes = "esxManagement"
	// ProvisionedNetworkTypesEsxReplication - network for ESX replication
	ProvisionedNetworkTypesEsxReplication ProvisionedNetworkTypes = "esxReplication"
	// ProvisionedNetworkTypesHcxManagement - network for HCX management
	ProvisionedNetworkTypesHcxManagement ProvisionedNetworkTypes = "hcxManagement"
	// ProvisionedNetworkTypesHcxUplink - network for HCX uplink
	ProvisionedNetworkTypesHcxUplink ProvisionedNetworkTypes = "hcxUplink"
	// ProvisionedNetworkTypesVcenterManagement - network for vCenter management
	ProvisionedNetworkTypesVcenterManagement ProvisionedNetworkTypes = "vcenterManagement"
	// ProvisionedNetworkTypesVmotion - network for vmotion
	ProvisionedNetworkTypesVmotion ProvisionedNetworkTypes = "vmotion"
	// ProvisionedNetworkTypesVsan - network for vsan
	ProvisionedNetworkTypesVsan ProvisionedNetworkTypes = "vsan"
)

func PossibleProvisionedNetworkTypesValues ¶ added in v2.1.0

func PossibleProvisionedNetworkTypesValues() []ProvisionedNetworkTypes

PossibleProvisionedNetworkTypesValues returns the possible values for the ProvisionedNetworkTypes const type.

type ProvisionedNetworksClient ¶ added in v2.1.0

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

ProvisionedNetworksClient contains the methods for the ProvisionedNetworks group. Don't use this type directly, use NewProvisionedNetworksClient() instead.

Generated from API version 2026-03-01

func NewProvisionedNetworksClient ¶ added in v2.1.0

func NewProvisionedNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ProvisionedNetworksClient, error)

NewProvisionedNetworksClient creates a new instance of ProvisionedNetworksClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*ProvisionedNetworksClient) Get ¶ added in v2.1.0

func (client *ProvisionedNetworksClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, provisionedNetworkName string, options *ProvisionedNetworksClientGetOptions) (ProvisionedNetworksClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
provisionedNetworkName - Name of the cloud link.
options - ProvisionedNetworksClientGetOptions contains the optional parameters for the ProvisionedNetworksClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/ProvisionedNetworks_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewProvisionedNetworksClient().Get(ctx, "group1", "cloud1", "vsan", 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 = armavs.ProvisionedNetworksClientGetResponse{
	// 	ProvisionedNetwork: armavs.ProvisionedNetwork{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/provisionedNetworks/vsan"),
	// 		Name: to.Ptr("vsan"),
	// 		Properties: &armavs.ProvisionedNetworkProperties{
	// 			AddressPrefix: to.Ptr("10.0.2.128/25"),
	// 			NetworkType: to.Ptr(armavs.ProvisionedNetworkTypesVsan),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/provisionedNetworks"),
	// 	},
	// }
}

Output:

func (*ProvisionedNetworksClient) NewListPager ¶ added in v2.1.0

func (client *ProvisionedNetworksClient) NewListPager(resourceGroupName string, privateCloudName string, options *ProvisionedNetworksClientListOptions) *runtime.Pager[ProvisionedNetworksClientListResponse]

NewListPager - List ProvisionedNetwork resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - ProvisionedNetworksClientListOptions contains the optional parameters for the ProvisionedNetworksClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/ProvisionedNetworks_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewProvisionedNetworksClient().NewListPager("group1", "cloud1", 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 = armavs.ProvisionedNetworksClientListResponse{
		// 	ProvisionedNetworkListResult: armavs.ProvisionedNetworkListResult{
		// 		Value: []*armavs.ProvisionedNetwork{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/provisionedNetworks/vsan"),
		// 				Name: to.Ptr("vsan"),
		// 				Properties: &armavs.ProvisionedNetworkProperties{
		// 					AddressPrefix: to.Ptr("10.0.2.128/25"),
		// 					NetworkType: to.Ptr(armavs.ProvisionedNetworkTypesVsan),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/provisionedNetworks"),
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/provisionedNetworks/esxvmot"),
		// 				Name: to.Ptr("esxvmot"),
		// 				Properties: &armavs.ProvisionedNetworkProperties{
		// 					AddressPrefix: to.Ptr("10.0.1.128/25"),
		// 					NetworkType: to.Ptr(armavs.ProvisionedNetworkTypes("esxvmot")),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/provisionedNetworks"),
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/provisionedNetworks/mgmtvnet"),
		// 				Name: to.Ptr("mgmtvnet"),
		// 				Properties: &armavs.ProvisionedNetworkProperties{
		// 					AddressPrefix: to.Ptr("10.0.3.128/26"),
		// 					NetworkType: to.Ptr(armavs.ProvisionedNetworkTypes("mgmtvnet")),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/provisionedNetworks"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type ProvisionedNetworksClientGetOptions ¶ added in v2.1.0

type ProvisionedNetworksClientGetOptions struct {
}

ProvisionedNetworksClientGetOptions contains the optional parameters for the ProvisionedNetworksClient.Get method.

type ProvisionedNetworksClientGetResponse ¶ added in v2.1.0

type ProvisionedNetworksClientGetResponse struct {
	// A provisioned network resource
	ProvisionedNetwork
}

ProvisionedNetworksClientGetResponse contains the response from method ProvisionedNetworksClient.Get.

type ProvisionedNetworksClientListOptions ¶ added in v2.1.0

type ProvisionedNetworksClientListOptions struct {
}

ProvisionedNetworksClientListOptions contains the optional parameters for the ProvisionedNetworksClient.NewListPager method.

type ProvisionedNetworksClientListResponse ¶ added in v2.1.0

type ProvisionedNetworksClientListResponse struct {
	// The response of a ProvisionedNetwork list operation.
	ProvisionedNetworkListResult
}

ProvisionedNetworksClientListResponse contains the response from method ProvisionedNetworksClient.NewListPager.

type PureStoragePoliciesClient ¶ added in v2.1.0

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

PureStoragePoliciesClient contains the methods for the PureStoragePolicies group. Don't use this type directly, use NewPureStoragePoliciesClient() instead.

Generated from API version 2026-03-01

func NewPureStoragePoliciesClient ¶ added in v2.1.0

func NewPureStoragePoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PureStoragePoliciesClient, error)

NewPureStoragePoliciesClient creates a new instance of PureStoragePoliciesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*PureStoragePoliciesClient) BeginCreateOrUpdate ¶ added in v2.1.0

func (client *PureStoragePoliciesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, storagePolicyName string, resource PureStoragePolicy, options *PureStoragePoliciesClientBeginCreateOrUpdateOptions) (*runtime.Poller[PureStoragePoliciesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a PureStoragePolicy If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
storagePolicyName - Name of the storage policy.
resource - Resource create parameters.
options - PureStoragePoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PureStoragePoliciesClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/PureStoragePolicies_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPureStoragePoliciesClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "storagePolicy1", armavs.PureStoragePolicy{
		Properties: &armavs.PureStoragePolicyProperties{
			StoragePolicyDefinition: to.Ptr("storagePolicyDefinition1"),
			StoragePoolID:           to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/PureStorage.Block/storagePools/storagePool1"),
		},
	}, 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 poll 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 = armavs.PureStoragePoliciesClientCreateOrUpdateResponse{
	// 	PureStoragePolicy: armavs.PureStoragePolicy{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/pureStoragePolicies/storagePolicy1"),
	// 		Name: to.Ptr("storagePolicy1"),
	// 		Properties: &armavs.PureStoragePolicyProperties{
	// 			StoragePolicyDefinition: to.Ptr("storagePolicyDefinition1"),
	// 			StoragePoolID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/PureStorage.Block/storagePools/storagePool1"),
	// 			ProvisioningState: to.Ptr(armavs.PureStoragePolicyProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/pureStoragePolicies"),
	// 	},
	// }
}

Output:

func (*PureStoragePoliciesClient) BeginDelete ¶ added in v2.1.0

func (client *PureStoragePoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, storagePolicyName string, options *PureStoragePoliciesClientBeginDeleteOptions) (*runtime.Poller[PureStoragePoliciesClientDeleteResponse], error)

BeginDelete - Delete a PureStoragePolicy If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
storagePolicyName - Name of the storage policy.
options - PureStoragePoliciesClientBeginDeleteOptions contains the optional parameters for the PureStoragePoliciesClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/PureStoragePolicies_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPureStoragePoliciesClient().BeginDelete(ctx, "group1", "cloud1", "storagePolicy1", 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 poll the result: %v", err)
	}
}

Output:

func (*PureStoragePoliciesClient) Get ¶ added in v2.1.0

func (client *PureStoragePoliciesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, storagePolicyName string, options *PureStoragePoliciesClientGetOptions) (PureStoragePoliciesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
storagePolicyName - Name of the storage policy.
options - PureStoragePoliciesClientGetOptions contains the optional parameters for the PureStoragePoliciesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/PureStoragePolicies_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPureStoragePoliciesClient().Get(ctx, "group1", "cloud1", "storagePolicy1", 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 = armavs.PureStoragePoliciesClientGetResponse{
	// 	PureStoragePolicy: armavs.PureStoragePolicy{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/pureStoragePolicies/storagePolicy1"),
	// 		Name: to.Ptr("storagePolicy1"),
	// 		Properties: &armavs.PureStoragePolicyProperties{
	// 			StoragePolicyDefinition: to.Ptr("storagePolicyDefinition1"),
	// 			StoragePoolID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/PureStorage.Block/storagePools/storagePool1"),
	// 			ProvisioningState: to.Ptr(armavs.PureStoragePolicyProvisioningStateSucceeded),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/pureStoragePolicies"),
	// 	},
	// }
}

Output:

func (*PureStoragePoliciesClient) NewListPager ¶ added in v2.1.0

func (client *PureStoragePoliciesClient) NewListPager(resourceGroupName string, privateCloudName string, options *PureStoragePoliciesClientListOptions) *runtime.Pager[PureStoragePoliciesClientListResponse]

NewListPager - List PureStoragePolicy resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - PureStoragePoliciesClientListOptions contains the optional parameters for the PureStoragePoliciesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/PureStoragePolicies_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPureStoragePoliciesClient().NewListPager("group1", "cloud1", 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 = armavs.PureStoragePoliciesClientListResponse{
		// 	PureStoragePolicyListResult: armavs.PureStoragePolicyListResult{
		// 		Value: []*armavs.PureStoragePolicy{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/pureStoragePolicies/storagePolicy1"),
		// 				Name: to.Ptr("storagePolicy1"),
		// 				Properties: &armavs.PureStoragePolicyProperties{
		// 					StoragePolicyDefinition: to.Ptr("storagePolicyDefinition1"),
		// 					StoragePoolID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/PureStorage.Block/storagePools/storagePool1"),
		// 					ProvisioningState: to.Ptr(armavs.PureStoragePolicyProvisioningStateSucceeded),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/pureStoragePolicies"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type PureStoragePoliciesClientBeginCreateOrUpdateOptions ¶ added in v2.1.0

type PureStoragePoliciesClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PureStoragePoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PureStoragePoliciesClient.BeginCreateOrUpdate method.

type PureStoragePoliciesClientBeginDeleteOptions ¶ added in v2.1.0

type PureStoragePoliciesClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PureStoragePoliciesClientBeginDeleteOptions contains the optional parameters for the PureStoragePoliciesClient.BeginDelete method.

type PureStoragePoliciesClientCreateOrUpdateResponse ¶ added in v2.1.0

type PureStoragePoliciesClientCreateOrUpdateResponse struct {
	// An instance describing a Pure Storage Policy Based Management policy
	PureStoragePolicy
}

PureStoragePoliciesClientCreateOrUpdateResponse contains the response from method PureStoragePoliciesClient.BeginCreateOrUpdate.

type PureStoragePoliciesClientDeleteResponse ¶ added in v2.1.0

type PureStoragePoliciesClientDeleteResponse struct {
}

PureStoragePoliciesClientDeleteResponse contains the response from method PureStoragePoliciesClient.BeginDelete.

type PureStoragePoliciesClientGetOptions ¶ added in v2.1.0

type PureStoragePoliciesClientGetOptions struct {
}

PureStoragePoliciesClientGetOptions contains the optional parameters for the PureStoragePoliciesClient.Get method.

type PureStoragePoliciesClientGetResponse ¶ added in v2.1.0

type PureStoragePoliciesClientGetResponse struct {
	// An instance describing a Pure Storage Policy Based Management policy
	PureStoragePolicy
}

PureStoragePoliciesClientGetResponse contains the response from method PureStoragePoliciesClient.Get.

type PureStoragePoliciesClientListOptions ¶ added in v2.1.0

type PureStoragePoliciesClientListOptions struct {
}

PureStoragePoliciesClientListOptions contains the optional parameters for the PureStoragePoliciesClient.NewListPager method.

type PureStoragePoliciesClientListResponse ¶ added in v2.1.0

type PureStoragePoliciesClientListResponse struct {
	// The response of a PureStoragePolicy list operation.
	PureStoragePolicyListResult
}

PureStoragePoliciesClientListResponse contains the response from method PureStoragePoliciesClient.NewListPager.

type PureStoragePolicy ¶ added in v2.1.0

type PureStoragePolicy struct {
	// The resource-specific properties for this resource.
	Properties *PureStoragePolicyProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

PureStoragePolicy - An instance describing a Pure Storage Policy Based Management policy

func (PureStoragePolicy) MarshalJSON ¶ added in v2.1.0

func (p PureStoragePolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PureStoragePolicy.

func (*PureStoragePolicy) UnmarshalJSON ¶ added in v2.1.0

func (p *PureStoragePolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PureStoragePolicy.

type PureStoragePolicyListResult ¶ added in v2.1.0

type PureStoragePolicyListResult struct {
	// REQUIRED; The PureStoragePolicy items on this page
	Value []*PureStoragePolicy

	// The link to the next page of items
	NextLink *string
}

PureStoragePolicyListResult - The response of a PureStoragePolicy list operation.

func (PureStoragePolicyListResult) MarshalJSON ¶ added in v2.1.0

func (p PureStoragePolicyListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PureStoragePolicyListResult.

func (*PureStoragePolicyListResult) UnmarshalJSON ¶ added in v2.1.0

func (p *PureStoragePolicyListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PureStoragePolicyListResult.

type PureStoragePolicyProperties ¶ added in v2.1.0

type PureStoragePolicyProperties struct {
	// REQUIRED; Definition of a Pure Storage Policy Based Management policy
	StoragePolicyDefinition *string

	// REQUIRED; Azure resource ID of the Pure Storage Pool associated with the storage policy
	StoragePoolID *string

	// READ-ONLY; The state of the Pure Storage Policy Based Management policy provisioning
	ProvisioningState *PureStoragePolicyProvisioningState
}

PureStoragePolicyProperties - Properties of a Pure Storage Policy Based Management policy

func (PureStoragePolicyProperties) MarshalJSON ¶ added in v2.1.0

func (p PureStoragePolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PureStoragePolicyProperties.

func (*PureStoragePolicyProperties) UnmarshalJSON ¶ added in v2.1.0

func (p *PureStoragePolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PureStoragePolicyProperties.

type PureStoragePolicyProvisioningState ¶ added in v2.1.0

type PureStoragePolicyProvisioningState string

PureStoragePolicyProvisioningState - Pure Storage Policy Based Management policy provisioning state

const (
	// PureStoragePolicyProvisioningStateCanceled - Resource creation was canceled.
	PureStoragePolicyProvisioningStateCanceled PureStoragePolicyProvisioningState = "Canceled"
	// PureStoragePolicyProvisioningStateDeleting - is deleting
	PureStoragePolicyProvisioningStateDeleting PureStoragePolicyProvisioningState = "Deleting"
	// PureStoragePolicyProvisioningStateFailed - Resource creation failed.
	PureStoragePolicyProvisioningStateFailed PureStoragePolicyProvisioningState = "Failed"
	// PureStoragePolicyProvisioningStateSucceeded - Resource has been created.
	PureStoragePolicyProvisioningStateSucceeded PureStoragePolicyProvisioningState = "Succeeded"
	// PureStoragePolicyProvisioningStateUpdating - is updating
	PureStoragePolicyProvisioningStateUpdating PureStoragePolicyProvisioningState = "Updating"
)

func PossiblePureStoragePolicyProvisioningStateValues ¶ added in v2.1.0

func PossiblePureStoragePolicyProvisioningStateValues() []PureStoragePolicyProvisioningState

PossiblePureStoragePolicyProvisioningStateValues returns the possible values for the PureStoragePolicyProvisioningState const type.

type PureStorageVolume ¶ added in v2.1.0

type PureStorageVolume struct {
	// REQUIRED; Volume size to be used to create a Virtual Volumes (vVols) datastore
	SizeGb *int32

	// REQUIRED; Azure resource ID of the Pure Storage Pool
	StoragePoolID *string
}

PureStorageVolume - A Pure Storage volume from PureStorage.Block provider

func (PureStorageVolume) MarshalJSON ¶ added in v2.1.0

func (p PureStorageVolume) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PureStorageVolume.

func (*PureStorageVolume) UnmarshalJSON ¶ added in v2.1.0

func (p *PureStorageVolume) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PureStorageVolume.

type Quota ¶

type Quota struct {
	// READ-ONLY; Remaining hosts quota by sku type
	HostsRemaining map[string]*int32

	// READ-ONLY; Host quota is active for current subscription
	QuotaEnabled *QuotaEnabled
}

Quota - Subscription quotas

func (Quota) MarshalJSON ¶

func (q Quota) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Quota.

func (*Quota) UnmarshalJSON ¶

func (q *Quota) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Quota.

type QuotaEnabled ¶

type QuotaEnabled string

QuotaEnabled - quota enabled

const (
	// QuotaEnabledDisabled - is disabled
	QuotaEnabledDisabled QuotaEnabled = "Disabled"
	// QuotaEnabledEnabled - is enabled
	QuotaEnabledEnabled QuotaEnabled = "Enabled"
)

func PossibleQuotaEnabledValues ¶

func PossibleQuotaEnabledValues() []QuotaEnabled

PossibleQuotaEnabledValues returns the possible values for the QuotaEnabled const type.

type RescheduleOperation ¶ added in v2.2.0

type RescheduleOperation struct {
	// REQUIRED; The kind of operation
	Kind *MaintenanceManagementOperationKind

	// READ-ONLY; Constraints for rescheduling maintenance
	Constraints []RescheduleOperationConstraintClassification

	// READ-ONLY; Reason for reschedule disabled
	DisabledReason *string

	// READ-ONLY; If rescheduling is disabled
	IsDisabled *bool

	// READ-ONLY; Recommendations for rescheduling maintenance
	Recommendation *MaintenanceRecommendation
}

RescheduleOperation - Constraints for rescheduling maintenance

func (*RescheduleOperation) GetMaintenanceManagementOperation ¶ added in v2.2.0

func (r *RescheduleOperation) GetMaintenanceManagementOperation() *MaintenanceManagementOperation

GetMaintenanceManagementOperation implements the MaintenanceManagementOperationClassification interface for type RescheduleOperation.

func (RescheduleOperation) MarshalJSON ¶ added in v2.2.0

func (r RescheduleOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RescheduleOperation.

func (*RescheduleOperation) UnmarshalJSON ¶ added in v2.2.0

func (r *RescheduleOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RescheduleOperation.

type RescheduleOperationConstraint ¶ added in v2.2.0

type RescheduleOperationConstraint struct {
	// READ-ONLY; The kind of operation
	Kind *RescheduleOperationConstraintKind
}

RescheduleOperationConstraint - Defines constraints for reschedule operation on maintenance

func (*RescheduleOperationConstraint) GetRescheduleOperationConstraint ¶ added in v2.2.0

func (r *RescheduleOperationConstraint) GetRescheduleOperationConstraint() *RescheduleOperationConstraint

GetRescheduleOperationConstraint implements the RescheduleOperationConstraintClassification interface for type RescheduleOperationConstraint.

func (RescheduleOperationConstraint) MarshalJSON ¶ added in v2.2.0

func (r RescheduleOperationConstraint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RescheduleOperationConstraint.

func (*RescheduleOperationConstraint) UnmarshalJSON ¶ added in v2.2.0

func (r *RescheduleOperationConstraint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RescheduleOperationConstraint.

type RescheduleOperationConstraintClassification ¶ added in v2.2.0

type RescheduleOperationConstraintClassification interface {
	// GetRescheduleOperationConstraint returns the RescheduleOperationConstraint content of the underlying type.
	GetRescheduleOperationConstraint() *RescheduleOperationConstraint
}

RescheduleOperationConstraintClassification provides polymorphic access to related types. Call the interface's GetRescheduleOperationConstraint() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AvailableWindowForMaintenanceWhileRescheduleOperation, *BlockedWhileRescheduleOperation, *RescheduleOperationConstraint, - *ReschedulingWindowConstraint, *WeekendReschedulingConstraint

type RescheduleOperationConstraintKind ¶ added in v2.2.0

type RescheduleOperationConstraintKind string

RescheduleOperationConstraintKind - Constraints for rescheduling of maintenance

const (
	// RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation - Time window in which maintenance
	// can be rescheduled
	RescheduleOperationConstraintKindAvailableWindowForMaintenanceWhileRescheduleOperation RescheduleOperationConstraintKind = "AvailableWindowForMaintenance"
	// RescheduleOperationConstraintKindBlockedWhileRescheduleOperation - Blocked time range constraint
	RescheduleOperationConstraintKindBlockedWhileRescheduleOperation RescheduleOperationConstraintKind = "Blocked"
	// RescheduleOperationConstraintKindReschedulingWindow - Defines allowed window for rescheduling
	RescheduleOperationConstraintKindReschedulingWindow RescheduleOperationConstraintKind = "ReschedulingWindow"
	// RescheduleOperationConstraintKindWeekendRescheduling - Defines weekend rescheduling restriction
	RescheduleOperationConstraintKindWeekendRescheduling RescheduleOperationConstraintKind = "WeekendRescheduling"
)

func PossibleRescheduleOperationConstraintKindValues ¶ added in v2.2.0

func PossibleRescheduleOperationConstraintKindValues() []RescheduleOperationConstraintKind

PossibleRescheduleOperationConstraintKindValues returns the possible values for the RescheduleOperationConstraintKind const type.

type ReschedulingWindowConstraint ¶

type ReschedulingWindowConstraint struct {
	// REQUIRED
	Kind *RescheduleOperationConstraintKind

	// READ-ONLY; End date Time
	EndsAt *time.Time

	// READ-ONLY; Start date time
	StartsAt *time.Time
}

ReschedulingWindowConstraint - Constraint defining allowed time window for rescheduling

func (*ReschedulingWindowConstraint) GetRescheduleOperationConstraint ¶

func (r *ReschedulingWindowConstraint) GetRescheduleOperationConstraint() *RescheduleOperationConstraint

GetRescheduleOperationConstraint implements the RescheduleOperationConstraintClassification interface for type ReschedulingWindowConstraint.

func (ReschedulingWindowConstraint) MarshalJSON ¶

func (r ReschedulingWindowConstraint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ReschedulingWindowConstraint.

func (*ReschedulingWindowConstraint) UnmarshalJSON ¶

func (r *ReschedulingWindowConstraint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ReschedulingWindowConstraint.

type ResourceIdentityType ¶

type ResourceIdentityType string

ResourceIdentityType - Type of managed service identity (either system assigned, or none).

const (
	// ResourceIdentityTypeNone - No managed system identity.
	ResourceIdentityTypeNone ResourceIdentityType = "None"
	// ResourceIdentityTypeSystemAssigned - System assigned managed system identity.
	ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
)

func PossibleResourceIdentityTypeValues ¶

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type ResourceSKU ¶ added in v2.1.0

type ResourceSKU struct {
	// REQUIRED; A list of locations and availability zones in those locations where the SKU is available
	LocationInfo []*ResourceSKULocationInfo

	// REQUIRED; The set of locations that the SKU is available.
	Locations []*string

	// REQUIRED; The name of the SKU.
	Name *string

	// REQUIRED; The type of resource the SKU applies to.
	ResourceType *ResourceSKUResourceType

	// REQUIRED; The restrictions of the SKU.
	Restrictions []*ResourceSKURestrictions

	// Name value pairs to describe the capability.
	Capabilities []*ResourceSKUCapabilities

	// The family of the SKU.
	Family *string

	// The size of the SKU.
	Size *string

	// The tier of virtual machines in a scale set
	Tier *string
}

ResourceSKU - A SKU for a resource.

func (ResourceSKU) MarshalJSON ¶ added in v2.1.0

func (r ResourceSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKU.

func (*ResourceSKU) UnmarshalJSON ¶ added in v2.1.0

func (r *ResourceSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKU.

type ResourceSKUCapabilities ¶ added in v2.1.0

type ResourceSKUCapabilities struct {
	// REQUIRED; The name of the SKU capability.
	Name *string

	// REQUIRED; The value of the SKU capability.
	Value *string
}

ResourceSKUCapabilities - Describes The SKU capabilities object.

func (ResourceSKUCapabilities) MarshalJSON ¶ added in v2.1.0

func (r ResourceSKUCapabilities) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKUCapabilities.

func (*ResourceSKUCapabilities) UnmarshalJSON ¶ added in v2.1.0

func (r *ResourceSKUCapabilities) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKUCapabilities.

type ResourceSKULocationInfo ¶ added in v2.1.0

type ResourceSKULocationInfo struct {
	// REQUIRED; Location of the SKU
	Location *string

	// REQUIRED; Gets details of capabilities available to a SKU in specific zones.
	ZoneDetails []*ResourceSKUZoneDetails

	// REQUIRED; List of availability zones where the SKU is supported.
	Zones []*string
}

ResourceSKULocationInfo - Describes an available Compute SKU Location Information.

func (ResourceSKULocationInfo) MarshalJSON ¶ added in v2.1.0

func (r ResourceSKULocationInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKULocationInfo.

func (*ResourceSKULocationInfo) UnmarshalJSON ¶ added in v2.1.0

func (r *ResourceSKULocationInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKULocationInfo.

type ResourceSKUResourceType ¶ added in v2.1.0

type ResourceSKUResourceType string

ResourceSKUResourceType - Describes the type of resource the SKU applies to.

const (
	// ResourceSKUResourceTypePrivateClouds - The SKU is for a private cloud.
	ResourceSKUResourceTypePrivateClouds ResourceSKUResourceType = "privateClouds"
	// ResourceSKUResourceTypePrivateCloudsClusters - The SKU is for a private cloud cluster.
	ResourceSKUResourceTypePrivateCloudsClusters ResourceSKUResourceType = "privateClouds/clusters"
)

func PossibleResourceSKUResourceTypeValues ¶ added in v2.1.0

func PossibleResourceSKUResourceTypeValues() []ResourceSKUResourceType

PossibleResourceSKUResourceTypeValues returns the possible values for the ResourceSKUResourceType const type.

type ResourceSKURestrictionInfo ¶ added in v2.1.0

type ResourceSKURestrictionInfo struct {
	// Locations where the SKU is restricted
	Locations []*string

	// List of availability zones where the SKU is restricted.
	Zones []*string
}

ResourceSKURestrictionInfo - Describes an available Compute SKU Restriction Information.

func (ResourceSKURestrictionInfo) MarshalJSON ¶ added in v2.1.0

func (r ResourceSKURestrictionInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKURestrictionInfo.

func (*ResourceSKURestrictionInfo) UnmarshalJSON ¶ added in v2.1.0

func (r *ResourceSKURestrictionInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKURestrictionInfo.

type ResourceSKURestrictions ¶ added in v2.1.0

type ResourceSKURestrictions struct {
	// REQUIRED; The information about the restriction where the SKU cannot be used.
	RestrictionInfo *ResourceSKURestrictionInfo

	// REQUIRED; The value of restrictions. If the restriction type is set to location. This would be different locations where
	// the SKU is restricted.
	Values []*string

	// the reason for restriction.
	ReasonCode *ResourceSKURestrictionsReasonCode

	// the type of restrictions.
	Type *ResourceSKURestrictionsType
}

ResourceSKURestrictions - The restrictions of the SKU.

func (ResourceSKURestrictions) MarshalJSON ¶ added in v2.1.0

func (r ResourceSKURestrictions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKURestrictions.

func (*ResourceSKURestrictions) UnmarshalJSON ¶ added in v2.1.0

func (r *ResourceSKURestrictions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKURestrictions.

type ResourceSKURestrictionsReasonCode ¶ added in v2.1.0

type ResourceSKURestrictionsReasonCode string

ResourceSKURestrictionsReasonCode - Describes the reason for SKU restriction.

const (
	// ResourceSKURestrictionsReasonCodeNotAvailableForSubscription - The restriction is not available for this subscription.
	ResourceSKURestrictionsReasonCodeNotAvailableForSubscription ResourceSKURestrictionsReasonCode = "NotAvailableForSubscription"
	// ResourceSKURestrictionsReasonCodeQuotaID - The restriction is due to exceeding a quota limitation.
	ResourceSKURestrictionsReasonCodeQuotaID ResourceSKURestrictionsReasonCode = "QuotaId"
)

func PossibleResourceSKURestrictionsReasonCodeValues ¶ added in v2.1.0

func PossibleResourceSKURestrictionsReasonCodeValues() []ResourceSKURestrictionsReasonCode

PossibleResourceSKURestrictionsReasonCodeValues returns the possible values for the ResourceSKURestrictionsReasonCode const type.

type ResourceSKURestrictionsType ¶ added in v2.1.0

type ResourceSKURestrictionsType string

ResourceSKURestrictionsType - Describes the kind of SKU restrictions that can exist

const (
	// ResourceSKURestrictionsTypeLocation - SKU restricted by location.
	ResourceSKURestrictionsTypeLocation ResourceSKURestrictionsType = "Location"
	// ResourceSKURestrictionsTypeZone - SKU restricted by availability zone.
	ResourceSKURestrictionsTypeZone ResourceSKURestrictionsType = "Zone"
)

func PossibleResourceSKURestrictionsTypeValues ¶ added in v2.1.0

func PossibleResourceSKURestrictionsTypeValues() []ResourceSKURestrictionsType

PossibleResourceSKURestrictionsTypeValues returns the possible values for the ResourceSKURestrictionsType const type.

type ResourceSKUZoneDetails ¶ added in v2.1.0

type ResourceSKUZoneDetails struct {
	// REQUIRED; A list of capabilities that are available for the SKU in the specified list of zones.
	Capabilities []*ResourceSKUCapabilities

	// REQUIRED; Gets the set of zones that the SKU is available in with the specified capabilities.
	Name []*string
}

ResourceSKUZoneDetails - Describes The zonal capabilities of a SKU.

func (ResourceSKUZoneDetails) MarshalJSON ¶ added in v2.1.0

func (r ResourceSKUZoneDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKUZoneDetails.

func (*ResourceSKUZoneDetails) UnmarshalJSON ¶ added in v2.1.0

func (r *ResourceSKUZoneDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKUZoneDetails.

type SKU ¶

type SKU struct {
	// REQUIRED; The name of the SKU. Ex - P3. It is typically a letter+number code
	Name *string

	// If the SKU supports scale out/in then the capacity integer should be included. If scale out/in is not possible for the
	// resource this may be omitted.
	Capacity *int32

	// If the service has different generations of hardware, for the same SKU, then that can be captured here.
	Family *string

	// The SKU size. When the name field is the combination of tier and some other value, this would be the standalone code.
	Size *string

	// This field is required to be implemented by the Resource Provider if the service has more than one tier, but is not required
	// on a PUT.
	Tier *SKUTier
}

SKU - The resource model definition representing SKU

func (SKU) MarshalJSON ¶

func (s SKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON ¶

func (s *SKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SKUTier ¶

type SKUTier string

SKUTier - This field is required to be implemented by the Resource Provider if the service has more than one tier, but is not required on a PUT.

const (
	// SKUTierBasic - The Basic service tier.
	SKUTierBasic SKUTier = "Basic"
	// SKUTierFree - The Free service tier.
	SKUTierFree SKUTier = "Free"
	// SKUTierPremium - The Premium service tier.
	SKUTierPremium SKUTier = "Premium"
	// SKUTierStandard - The Standard service tier.
	SKUTierStandard SKUTier = "Standard"
)

func PossibleSKUTierValues ¶

func PossibleSKUTierValues() []SKUTier

PossibleSKUTierValues returns the possible values for the SKUTier const type.

type SKUsClient ¶ added in v2.1.0

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

SKUsClient contains the methods for the SKUs group. Don't use this type directly, use NewSKUsClient() instead.

Generated from API version 2026-03-01

func NewSKUsClient ¶ added in v2.1.0

func NewSKUsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SKUsClient, error)

NewSKUsClient creates a new instance of SKUsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*SKUsClient) NewListPager ¶ added in v2.1.0

func (client *SKUsClient) NewListPager(options *SKUsClientListOptions) *runtime.Pager[SKUsClientListResponse]

NewListPager - A list of SKUs.

options - SKUsClientListOptions contains the optional parameters for the SKUsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/Skus_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSKUsClient().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 = armavs.SKUsClientListResponse{
		// 	PagedResourceSKU: armavs.PagedResourceSKU{
		// 		Value: []*armavs.ResourceSKU{
		// 			{
		// 				Capabilities: []*armavs.ResourceSKUCapabilities{
		// 					{
		// 						Name: to.Ptr("CpuCoreCount"),
		// 						Value: to.Ptr("36"),
		// 					},
		// 					{
		// 						Name: to.Ptr("RamGB"),
		// 						Value: to.Ptr("576"),
		// 					},
		// 					{
		// 						Name: to.Ptr("StorageCacheTB"),
		// 						Value: to.Ptr("3.2"),
		// 					},
		// 					{
		// 						Name: to.Ptr("StorageTB"),
		// 						Value: to.Ptr("15.2"),
		// 					},
		// 					{
		// 						Name: to.Ptr("HostType"),
		// 						Value: to.Ptr("he"),
		// 					},
		// 				},
		// 				LocationInfo: []*armavs.ResourceSKULocationInfo{
		// 					{
		// 						Location: to.Ptr("australiaeast"),
		// 						ZoneDetails: []*armavs.ResourceSKUZoneDetails{
		// 						},
		// 						Zones: []*string{
		// 							to.Ptr("1"),
		// 						},
		// 					},
		// 				},
		// 				Locations: []*string{
		// 					to.Ptr("australiaeast"),
		// 				},
		// 				Name: to.Ptr("av36"),
		// 				ResourceType: to.Ptr(armavs.ResourceSKUResourceTypePrivateClouds),
		// 				Restrictions: []*armavs.ResourceSKURestrictions{
		// 				},
		// 			},
		// 			{
		// 				Capabilities: []*armavs.ResourceSKUCapabilities{
		// 					{
		// 						Name: to.Ptr("CpuCoreCount"),
		// 						Value: to.Ptr("36"),
		// 					},
		// 					{
		// 						Name: to.Ptr("RamGB"),
		// 						Value: to.Ptr("768"),
		// 					},
		// 					{
		// 						Name: to.Ptr("StorageCacheTB"),
		// 						Value: to.Ptr("1.5"),
		// 					},
		// 					{
		// 						Name: to.Ptr("StorageTB"),
		// 						Value: to.Ptr("19.2"),
		// 					},
		// 					{
		// 						Name: to.Ptr("HostType"),
		// 						Value: to.Ptr("he2"),
		// 					},
		// 				},
		// 				LocationInfo: []*armavs.ResourceSKULocationInfo{
		// 					{
		// 						Location: to.Ptr("centralindia"),
		// 						ZoneDetails: []*armavs.ResourceSKUZoneDetails{
		// 						},
		// 						Zones: []*string{
		// 							to.Ptr("3"),
		// 						},
		// 					},
		// 				},
		// 				Locations: []*string{
		// 					to.Ptr("centralindia"),
		// 				},
		// 				Name: to.Ptr("av36p"),
		// 				ResourceType: to.Ptr(armavs.ResourceSKUResourceTypePrivateClouds),
		// 				Restrictions: []*armavs.ResourceSKURestrictions{
		// 				},
		// 			},
		// 			{
		// 				Capabilities: []*armavs.ResourceSKUCapabilities{
		// 					{
		// 						Name: to.Ptr("CpuCoreCount"),
		// 						Value: to.Ptr("36"),
		// 					},
		// 					{
		// 						Name: to.Ptr("RamGB"),
		// 						Value: to.Ptr("768"),
		// 					},
		// 					{
		// 						Name: to.Ptr("StorageCacheTB"),
		// 						Value: to.Ptr("1.5"),
		// 					},
		// 					{
		// 						Name: to.Ptr("StorageTB"),
		// 						Value: to.Ptr("19.2"),
		// 					},
		// 					{
		// 						Name: to.Ptr("HostType"),
		// 						Value: to.Ptr("he2"),
		// 					},
		// 				},
		// 				LocationInfo: []*armavs.ResourceSKULocationInfo{
		// 					{
		// 						Location: to.Ptr("westeurope"),
		// 						ZoneDetails: []*armavs.ResourceSKUZoneDetails{
		// 						},
		// 						Zones: []*string{
		// 							to.Ptr("2"),
		// 							to.Ptr("3"),
		// 						},
		// 					},
		// 				},
		// 				Locations: []*string{
		// 					to.Ptr("westeurope"),
		// 				},
		// 				Name: to.Ptr("av36pt"),
		// 				ResourceType: to.Ptr(armavs.ResourceSKUResourceTypePrivateClouds),
		// 				Restrictions: []*armavs.ResourceSKURestrictions{
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type SKUsClientListOptions ¶ added in v2.1.0

type SKUsClientListOptions struct {
}

SKUsClientListOptions contains the optional parameters for the SKUsClient.NewListPager method.

type SKUsClientListResponse ¶ added in v2.1.0

type SKUsClientListResponse struct {
	// Paged collection of ResourceSku items
	PagedResourceSKU
}

SKUsClientListResponse contains the response from method SKUsClient.NewListPager.

type SSLEnum ¶

type SSLEnum string

SSLEnum - Whether SSL is enabled or disabled

const (
	// SSLEnumDisabled - is disabled
	SSLEnumDisabled SSLEnum = "Disabled"
	// SSLEnumEnabled - is enabled
	SSLEnumEnabled SSLEnum = "Enabled"
)

func PossibleSSLEnumValues ¶

func PossibleSSLEnumValues() []SSLEnum

PossibleSSLEnumValues returns the possible values for the SSLEnum const type.

type ScheduleOperation ¶ added in v2.2.0

type ScheduleOperation struct {
	// REQUIRED; The kind of operation
	Kind *MaintenanceManagementOperationKind

	// READ-ONLY; Constraints for scheduling maintenance
	Constraints []ScheduleOperationConstraintClassification

	// READ-ONLY; Reason for schedule disabled
	DisabledReason *string

	// READ-ONLY; If scheduling is disabled
	IsDisabled *bool

	// READ-ONLY; Recommendations for scheduling maintenance
	Recommendation *MaintenanceRecommendation
}

ScheduleOperation - Scheduling window constraint

func (*ScheduleOperation) GetMaintenanceManagementOperation ¶ added in v2.2.0

func (s *ScheduleOperation) GetMaintenanceManagementOperation() *MaintenanceManagementOperation

GetMaintenanceManagementOperation implements the MaintenanceManagementOperationClassification interface for type ScheduleOperation.

func (ScheduleOperation) MarshalJSON ¶ added in v2.2.0

func (s ScheduleOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScheduleOperation.

func (*ScheduleOperation) UnmarshalJSON ¶ added in v2.2.0

func (s *ScheduleOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScheduleOperation.

type ScheduleOperationConstraint ¶ added in v2.2.0

type ScheduleOperationConstraint struct {
	// READ-ONLY; The kind of operation
	Kind *ScheduleOperationConstraintKind
}

ScheduleOperationConstraint - Defines constraints for schedule operation on maintenance

func (*ScheduleOperationConstraint) GetScheduleOperationConstraint ¶ added in v2.2.0

func (s *ScheduleOperationConstraint) GetScheduleOperationConstraint() *ScheduleOperationConstraint

GetScheduleOperationConstraint implements the ScheduleOperationConstraintClassification interface for type ScheduleOperationConstraint.

func (ScheduleOperationConstraint) MarshalJSON ¶ added in v2.2.0

func (s ScheduleOperationConstraint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScheduleOperationConstraint.

func (*ScheduleOperationConstraint) UnmarshalJSON ¶ added in v2.2.0

func (s *ScheduleOperationConstraint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScheduleOperationConstraint.

type ScheduleOperationConstraintClassification ¶ added in v2.2.0

type ScheduleOperationConstraintClassification interface {
	// GetScheduleOperationConstraint returns the ScheduleOperationConstraint content of the underlying type.
	GetScheduleOperationConstraint() *ScheduleOperationConstraint
}

ScheduleOperationConstraintClassification provides polymorphic access to related types. Call the interface's GetScheduleOperationConstraint() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AvailableWindowForMaintenanceWhileScheduleOperation, *BlockedWhileScheduleOperation, *ScheduleOperationConstraint, *SchedulingWindow, - *WeekendSchedulingConstraint

type ScheduleOperationConstraintKind ¶ added in v2.2.0

type ScheduleOperationConstraintKind string

ScheduleOperationConstraintKind - Constraints for scheduling of maintenance

const (
	// ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation - Time window in which maintenance can
	// be scheduled
	ScheduleOperationConstraintKindAvailableWindowForMaintenanceWhileScheduleOperation ScheduleOperationConstraintKind = "AvailableWindowForMaintenance"
	// ScheduleOperationConstraintKindBlockedWhileScheduleOperation - Blocked time range constraint
	ScheduleOperationConstraintKindBlockedWhileScheduleOperation ScheduleOperationConstraintKind = "Blocked"
	// ScheduleOperationConstraintKindSchedulingWindow - Time window in which Customer has option to schedule maintenance
	ScheduleOperationConstraintKindSchedulingWindow ScheduleOperationConstraintKind = "SchedulingWindow"
	// ScheduleOperationConstraintKindWeekendScheduling - Defines weekend scheduling restriction
	ScheduleOperationConstraintKindWeekendScheduling ScheduleOperationConstraintKind = "WeekendScheduling"
)

func PossibleScheduleOperationConstraintKindValues ¶ added in v2.2.0

func PossibleScheduleOperationConstraintKindValues() []ScheduleOperationConstraintKind

PossibleScheduleOperationConstraintKindValues returns the possible values for the ScheduleOperationConstraintKind const type.

type SchedulingWindow ¶ added in v2.2.0

type SchedulingWindow struct {
	// REQUIRED; The kind of constraint
	Kind *ScheduleOperationConstraintKind

	// READ-ONLY; End date Time
	EndsAt *time.Time

	// READ-ONLY; Start date time
	StartsAt *time.Time
}

SchedulingWindow - Time window in which Customer has option to schedule maintenance

func (*SchedulingWindow) GetScheduleOperationConstraint ¶ added in v2.2.0

func (s *SchedulingWindow) GetScheduleOperationConstraint() *ScheduleOperationConstraint

GetScheduleOperationConstraint implements the ScheduleOperationConstraintClassification interface for type SchedulingWindow.

func (SchedulingWindow) MarshalJSON ¶ added in v2.2.0

func (s SchedulingWindow) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SchedulingWindow.

func (*SchedulingWindow) UnmarshalJSON ¶ added in v2.2.0

func (s *SchedulingWindow) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SchedulingWindow.

type ScriptCmdlet ¶

type ScriptCmdlet struct {
	// The resource-specific properties for this resource.
	Properties *ScriptCmdletProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

ScriptCmdlet - A cmdlet available for script execution

func (ScriptCmdlet) MarshalJSON ¶

func (s ScriptCmdlet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptCmdlet.

func (*ScriptCmdlet) UnmarshalJSON ¶

func (s *ScriptCmdlet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptCmdlet.

type ScriptCmdletAudience ¶

type ScriptCmdletAudience string

ScriptCmdletAudience - Specifies whether a script cmdlet is intended to be invoked only through automation or visible to customers

const (
	// ScriptCmdletAudienceAny - is any
	ScriptCmdletAudienceAny ScriptCmdletAudience = "Any"
	// ScriptCmdletAudienceAutomation - is automation
	ScriptCmdletAudienceAutomation ScriptCmdletAudience = "Automation"
)

func PossibleScriptCmdletAudienceValues ¶

func PossibleScriptCmdletAudienceValues() []ScriptCmdletAudience

PossibleScriptCmdletAudienceValues returns the possible values for the ScriptCmdletAudience const type.

type ScriptCmdletProperties ¶

type ScriptCmdletProperties struct {
	// READ-ONLY; Specifies whether a script cmdlet is intended to be invoked only through automation or visible to customers
	Audience *ScriptCmdletAudience

	// READ-ONLY; Description of the scripts functionality
	Description *string

	// READ-ONLY; Parameters the script will accept
	Parameters []*ScriptParameter

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

	// READ-ONLY; Recommended time limit for execution
	Timeout *string
}

ScriptCmdletProperties - Properties of a pre-canned script

func (ScriptCmdletProperties) MarshalJSON ¶

func (s ScriptCmdletProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptCmdletProperties.

func (*ScriptCmdletProperties) UnmarshalJSON ¶

func (s *ScriptCmdletProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptCmdletProperties.

type ScriptCmdletProvisioningState ¶

type ScriptCmdletProvisioningState string

ScriptCmdletProvisioningState - A script cmdlet provisioning state

const (
	// ScriptCmdletProvisioningStateCanceled - Resource creation was canceled.
	ScriptCmdletProvisioningStateCanceled ScriptCmdletProvisioningState = "Canceled"
	// ScriptCmdletProvisioningStateFailed - Resource creation failed.
	ScriptCmdletProvisioningStateFailed ScriptCmdletProvisioningState = "Failed"
	// ScriptCmdletProvisioningStateSucceeded - Resource has been created.
	ScriptCmdletProvisioningStateSucceeded ScriptCmdletProvisioningState = "Succeeded"
)

func PossibleScriptCmdletProvisioningStateValues ¶

func PossibleScriptCmdletProvisioningStateValues() []ScriptCmdletProvisioningState

PossibleScriptCmdletProvisioningStateValues returns the possible values for the ScriptCmdletProvisioningState const type.

type ScriptCmdletsClient ¶

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

ScriptCmdletsClient contains the methods for the ScriptCmdlets group. Don't use this type directly, use NewScriptCmdletsClient() instead.

Generated from API version 2026-03-01

func NewScriptCmdletsClient ¶

func NewScriptCmdletsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ScriptCmdletsClient, error)

NewScriptCmdletsClient creates a new instance of ScriptCmdletsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*ScriptCmdletsClient) Get ¶

func (client *ScriptCmdletsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, scriptPackageName string, scriptCmdletName string, options *ScriptCmdletsClientGetOptions) (ScriptCmdletsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptPackageName - Name of the script package.
scriptCmdletName - Name of the script cmdlet.
options - ScriptCmdletsClientGetOptions contains the optional parameters for the ScriptCmdletsClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/ScriptCmdlets_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewScriptCmdletsClient().Get(ctx, "group1", "cloud1", "package@1.0.2", "New-ExternalSsoDomain", 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 = armavs.ScriptCmdletsClientGetResponse{
	// 	ScriptCmdlet: armavs.ScriptCmdlet{
	// 		Name: to.Ptr("New-ExternalSsoDomain"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/{privateCloudName}/scriptPackages/package@1.0.2/scriptCmdlets/New-ExternalSsoDomain"),
	// 		Properties: &armavs.ScriptCmdletProperties{
	// 			Description: to.Ptr("Add an external Sso domain to their vCenter"),
	// 			Timeout: to.Ptr("P0Y0M0DT0H60M0S"),
	// 			Audience: to.Ptr(armavs.ScriptCmdletAudienceAny),
	// 			Parameters: []*armavs.ScriptParameter{
	// 				{
	// 					Name: to.Ptr("DomainName"),
	// 					Description: to.Ptr("Domain name of the Server"),
	// 					Type: to.Ptr(armavs.ScriptParameterTypesString),
	// 					Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
	// 					Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 				},
	// 				{
	// 					Name: to.Ptr("BaseUserDN"),
	// 					Description: to.Ptr("Base User DN of the Server"),
	// 					Type: to.Ptr(armavs.ScriptParameterTypesString),
	// 					Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
	// 					Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 				},
	// 				{
	// 					Name: to.Ptr("Password"),
	// 					Description: to.Ptr("Password for authenticating to the server"),
	// 					Type: to.Ptr(armavs.ScriptParameterTypesSecureString),
	// 					Visibility: to.Ptr(armavs.VisibilityParameterEnumHidden),
	// 					Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 				},
	// 			},
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages/scriptCmdlets"),
	// 	},
	// }
}

Output:

func (*ScriptCmdletsClient) NewListPager ¶

func (client *ScriptCmdletsClient) NewListPager(resourceGroupName string, privateCloudName string, scriptPackageName string, options *ScriptCmdletsClientListOptions) *runtime.Pager[ScriptCmdletsClientListResponse]

NewListPager - List ScriptCmdlet resources by ScriptPackage

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptPackageName - Name of the script package.
options - ScriptCmdletsClientListOptions contains the optional parameters for the ScriptCmdletsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/ScriptCmdlets_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewScriptCmdletsClient().NewListPager("group1", "cloud1", "package@1.0.2", 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 = armavs.ScriptCmdletsClientListResponse{
		// 	ScriptCmdletsList: armavs.ScriptCmdletsList{
		// 		Value: []*armavs.ScriptCmdlet{
		// 			{
		// 				Name: to.Ptr("Set-AvsStoragePolicy"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/package@1.0.2/scriptCmdlets/Set-AvsStoragePolicy"),
		// 				Properties: &armavs.ScriptCmdletProperties{
		// 					Description: to.Ptr("Allow user to set the storage policy of the specified VM"),
		// 					Timeout: to.Ptr("P0Y0M0DT0H60M0S"),
		// 					Audience: to.Ptr(armavs.ScriptCmdletAudienceAny),
		// 					Parameters: []*armavs.ScriptParameter{
		// 						{
		// 							Name: to.Ptr("VM"),
		// 							Description: to.Ptr("VM to set the storage policy on"),
		// 							Type: to.Ptr(armavs.ScriptParameterTypesString),
		// 							Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
		// 							Optional: to.Ptr(armavs.OptionalParamEnumRequired),
		// 						},
		// 						{
		// 							Name: to.Ptr("StoragePolicyName"),
		// 							Description: to.Ptr("Name of the storage policy to set"),
		// 							Type: to.Ptr(armavs.ScriptParameterTypesString),
		// 							Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
		// 							Optional: to.Ptr(armavs.OptionalParamEnumRequired),
		// 						},
		// 					},
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages/scriptCmdlets"),
		// 			},
		// 			{
		// 				Name: to.Ptr("New-ExternalSsoDomain"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/package@1.0.2/scriptCmdlets/New-ExternalSsoDomain"),
		// 				Properties: &armavs.ScriptCmdletProperties{
		// 					Description: to.Ptr("Add an external Sso domain to their vCenter"),
		// 					Timeout: to.Ptr("P0Y0M0DT0H60M0S"),
		// 					Audience: to.Ptr(armavs.ScriptCmdletAudienceAny),
		// 					Parameters: []*armavs.ScriptParameter{
		// 						{
		// 							Name: to.Ptr("DomainName"),
		// 							Description: to.Ptr("Domain name of the Server"),
		// 							Type: to.Ptr(armavs.ScriptParameterTypesString),
		// 							Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
		// 							Optional: to.Ptr(armavs.OptionalParamEnumRequired),
		// 						},
		// 						{
		// 							Name: to.Ptr("BaseUserDN"),
		// 							Description: to.Ptr("Base User DN of the Server"),
		// 							Type: to.Ptr(armavs.ScriptParameterTypesString),
		// 							Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
		// 							Optional: to.Ptr(armavs.OptionalParamEnumRequired),
		// 						},
		// 						{
		// 							Name: to.Ptr("Password"),
		// 							Description: to.Ptr("Password for authenticating to the server"),
		// 							Type: to.Ptr(armavs.ScriptParameterTypesSecureString),
		// 							Visibility: to.Ptr(armavs.VisibilityParameterEnumHidden),
		// 							Optional: to.Ptr(armavs.OptionalParamEnumRequired),
		// 						},
		// 					},
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages/scriptCmdlets"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type ScriptCmdletsClientGetOptions ¶

type ScriptCmdletsClientGetOptions struct {
}

ScriptCmdletsClientGetOptions contains the optional parameters for the ScriptCmdletsClient.Get method.

type ScriptCmdletsClientGetResponse ¶

type ScriptCmdletsClientGetResponse struct {
	// A cmdlet available for script execution
	ScriptCmdlet
}

ScriptCmdletsClientGetResponse contains the response from method ScriptCmdletsClient.Get.

type ScriptCmdletsClientListOptions ¶

type ScriptCmdletsClientListOptions struct {
}

ScriptCmdletsClientListOptions contains the optional parameters for the ScriptCmdletsClient.NewListPager method.

type ScriptCmdletsClientListResponse ¶

type ScriptCmdletsClientListResponse struct {
	// The response of a ScriptCmdlet list operation.
	ScriptCmdletsList
}

ScriptCmdletsClientListResponse contains the response from method ScriptCmdletsClient.NewListPager.

type ScriptCmdletsList ¶

type ScriptCmdletsList struct {
	// REQUIRED; The ScriptCmdlet items on this page
	Value []*ScriptCmdlet

	// The link to the next page of items
	NextLink *string
}

ScriptCmdletsList - The response of a ScriptCmdlet list operation.

func (ScriptCmdletsList) MarshalJSON ¶

func (s ScriptCmdletsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptCmdletsList.

func (*ScriptCmdletsList) UnmarshalJSON ¶

func (s *ScriptCmdletsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptCmdletsList.

type ScriptExecution ¶

type ScriptExecution struct {
	// The resource-specific properties for this resource.
	Properties *ScriptExecutionProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

ScriptExecution - An instance of a script executed by a user - custom or AVS

func (ScriptExecution) MarshalJSON ¶

func (s ScriptExecution) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptExecution.

func (*ScriptExecution) UnmarshalJSON ¶

func (s *ScriptExecution) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptExecution.

type ScriptExecutionParameter ¶

type ScriptExecutionParameter struct {
	// REQUIRED; The parameter name
	Name *string

	// REQUIRED; script execution parameter type
	Type *ScriptExecutionParameterType
}

ScriptExecutionParameter - The arguments passed in to the execution

func (*ScriptExecutionParameter) GetScriptExecutionParameter ¶

func (s *ScriptExecutionParameter) GetScriptExecutionParameter() *ScriptExecutionParameter

GetScriptExecutionParameter implements the ScriptExecutionParameterClassification interface for type ScriptExecutionParameter.

func (ScriptExecutionParameter) MarshalJSON ¶

func (s ScriptExecutionParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptExecutionParameter.

func (*ScriptExecutionParameter) UnmarshalJSON ¶

func (s *ScriptExecutionParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptExecutionParameter.

type ScriptExecutionParameterClassification ¶

type ScriptExecutionParameterClassification interface {
	// GetScriptExecutionParameter returns the ScriptExecutionParameter content of the underlying type.
	GetScriptExecutionParameter() *ScriptExecutionParameter
}

ScriptExecutionParameterClassification provides polymorphic access to related types. Call the interface's GetScriptExecutionParameter() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *PSCredentialExecutionParameter, *ScriptExecutionParameter, *ScriptSecureStringExecutionParameter, *ScriptStringExecutionParameter

type ScriptExecutionParameterType ¶

type ScriptExecutionParameterType string

ScriptExecutionParameterType - script execution parameter type

const (
	ScriptExecutionParameterTypeCredential  ScriptExecutionParameterType = "Credential"
	ScriptExecutionParameterTypeSecureValue ScriptExecutionParameterType = "SecureValue"
	ScriptExecutionParameterTypeValue       ScriptExecutionParameterType = "Value"
)

func PossibleScriptExecutionParameterTypeValues ¶

func PossibleScriptExecutionParameterTypeValues() []ScriptExecutionParameterType

PossibleScriptExecutionParameterTypeValues returns the possible values for the ScriptExecutionParameterType const type.

type ScriptExecutionProperties ¶

type ScriptExecutionProperties struct {
	// REQUIRED; Time limit for execution
	Timeout *string

	// Error message if the script was able to run, but if the script itself had
	// errors or powershell threw an exception
	FailureReason *string

	// Parameters that will be hidden/not visible to ARM, such as passwords and
	// credentials
	HiddenParameters []ScriptExecutionParameterClassification

	// User-defined dictionary.
	NamedOutputs map[string]any

	// Standard output stream from the powershell execution
	Output []*string

	// Parameters the script will accept
	Parameters []ScriptExecutionParameterClassification

	// Time to live for the resource. If not provided, will be available for 60 days
	Retention *string

	// A reference to the script cmdlet resource if user is running a AVS script
	ScriptCmdletID *string

	// READ-ONLY; Standard error output stream from the powershell execution
	Errors []*string

	// READ-ONLY; Time the script execution was finished
	FinishedAt *time.Time

	// READ-ONLY; Standard information out stream from the powershell execution
	Information []*string

	// READ-ONLY; The state of the script execution resource
	ProvisioningState *ScriptExecutionProvisioningState

	// READ-ONLY; Time the script execution was started
	StartedAt *time.Time

	// READ-ONLY; Time the script execution was submitted
	SubmittedAt *time.Time

	// READ-ONLY; Standard warning out stream from the powershell execution
	Warnings []*string
}

ScriptExecutionProperties - Properties of a user-invoked script

func (ScriptExecutionProperties) MarshalJSON ¶

func (s ScriptExecutionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptExecutionProperties.

func (*ScriptExecutionProperties) UnmarshalJSON ¶

func (s *ScriptExecutionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptExecutionProperties.

type ScriptExecutionProvisioningState ¶

type ScriptExecutionProvisioningState string

ScriptExecutionProvisioningState - Script Execution provisioning state

const (
	// ScriptExecutionProvisioningStateCanceled - Resource creation was canceled.
	ScriptExecutionProvisioningStateCanceled ScriptExecutionProvisioningState = "Canceled"
	// ScriptExecutionProvisioningStateCancelled - is cancelled
	ScriptExecutionProvisioningStateCancelled ScriptExecutionProvisioningState = "Cancelled"
	// ScriptExecutionProvisioningStateCancelling - is cancelling
	ScriptExecutionProvisioningStateCancelling ScriptExecutionProvisioningState = "Cancelling"
	// ScriptExecutionProvisioningStateDeleting - is deleting
	ScriptExecutionProvisioningStateDeleting ScriptExecutionProvisioningState = "Deleting"
	// ScriptExecutionProvisioningStateFailed - Resource creation failed.
	ScriptExecutionProvisioningStateFailed ScriptExecutionProvisioningState = "Failed"
	// ScriptExecutionProvisioningStatePending - is pending
	ScriptExecutionProvisioningStatePending ScriptExecutionProvisioningState = "Pending"
	// ScriptExecutionProvisioningStateRunning - is running
	ScriptExecutionProvisioningStateRunning ScriptExecutionProvisioningState = "Running"
	// ScriptExecutionProvisioningStateSucceeded - Resource has been created.
	ScriptExecutionProvisioningStateSucceeded ScriptExecutionProvisioningState = "Succeeded"
)

func PossibleScriptExecutionProvisioningStateValues ¶

func PossibleScriptExecutionProvisioningStateValues() []ScriptExecutionProvisioningState

PossibleScriptExecutionProvisioningStateValues returns the possible values for the ScriptExecutionProvisioningState const type.

type ScriptExecutionsClient ¶

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

ScriptExecutionsClient contains the methods for the ScriptExecutions group. Don't use this type directly, use NewScriptExecutionsClient() instead.

Generated from API version 2026-03-01

func NewScriptExecutionsClient ¶

func NewScriptExecutionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ScriptExecutionsClient, error)

NewScriptExecutionsClient creates a new instance of ScriptExecutionsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*ScriptExecutionsClient) BeginCreateOrUpdate ¶

func (client *ScriptExecutionsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, scriptExecutionName string, scriptExecution ScriptExecution, options *ScriptExecutionsClientBeginCreateOrUpdateOptions) (*runtime.Poller[ScriptExecutionsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a ScriptExecution If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptExecutionName - Name of the script cmdlet.
scriptExecution - Resource create parameters.
options - ScriptExecutionsClientBeginCreateOrUpdateOptions contains the optional parameters for the ScriptExecutionsClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: 2026-03-01/ScriptExecutions_CreateOrUpdate.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewScriptExecutionsClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "addSsoServer", armavs.ScriptExecution{
		Properties: &armavs.ScriptExecutionProperties{
			ScriptCmdletID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/AVS.PowerCommands@1.0.0/scriptCmdlets/New-SsoExternalIdentitySource"),
			Timeout:        to.Ptr("P0Y0M0DT0H60M60S"),
			Retention:      to.Ptr("P0Y0M60DT0H60M60S"),
			Parameters: []armavs.ScriptExecutionParameterClassification{
				&armavs.ScriptStringExecutionParameter{
					Name:  to.Ptr("DomainName"),
					Type:  to.Ptr(armavs.ScriptExecutionParameterTypeValue),
					Value: to.Ptr("placeholderDomain.local"),
				},
				&armavs.ScriptStringExecutionParameter{
					Name:  to.Ptr("BaseUserDN"),
					Type:  to.Ptr(armavs.ScriptExecutionParameterTypeValue),
					Value: to.Ptr("DC=placeholder, DC=placeholder"),
				},
			},
			HiddenParameters: []armavs.ScriptExecutionParameterClassification{
				&armavs.ScriptSecureStringExecutionParameter{
					Name:        to.Ptr("Password"),
					Type:        to.Ptr(armavs.ScriptExecutionParameterTypeSecureValue),
					SecureValue: to.Ptr("PlaceholderPassword"),
				},
			},
		},
	}, 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 poll 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 = armavs.ScriptExecutionsClientCreateOrUpdateResponse{
	// 	ScriptExecution: armavs.ScriptExecution{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
	// 		Name: to.Ptr("addSsoServer"),
	// 		Properties: &armavs.ScriptExecutionProperties{
	// 			ScriptCmdletID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/AVS.PowerCommands@1.0.0/scriptCmdlets/New-SsoExternalIdentitySource"),
	// 			Timeout: to.Ptr("P0Y0M0DT0H60M60S"),
	// 			Retention: to.Ptr("P0Y0M60DT0H60M60S"),
	// 			ProvisioningState: to.Ptr(armavs.ScriptExecutionProvisioningStateSucceeded),
	// 			FailureReason: to.Ptr("vCenter failed to connect to the external server"),
	// 			Parameters: []armavs.ScriptExecutionParameterClassification{
	// 				&armavs.ScriptStringExecutionParameter{
	// 					Name: to.Ptr("DomainName"),
	// 					Type: to.Ptr(armavs.ScriptExecutionParameterTypeValue),
	// 					Value: to.Ptr("placeholderDomain.local"),
	// 				},
	// 				&armavs.ScriptStringExecutionParameter{
	// 					Name: to.Ptr("BaseUserDN"),
	// 					Type: to.Ptr(armavs.ScriptExecutionParameterTypeValue),
	// 					Value: to.Ptr("DC=placeholder, DC=placeholder"),
	// 				},
	// 			},

Output:

func (*ScriptExecutionsClient) BeginDelete ¶

func (client *ScriptExecutionsClient) BeginDelete(ctx context.Context, resourceGroupName string, privateCloudName string, scriptExecutionName string, options *ScriptExecutionsClientBeginDeleteOptions) (*runtime.Poller[ScriptExecutionsClientDeleteResponse], error)

BeginDelete - Delete a ScriptExecution If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptExecutionName - Name of the script cmdlet.
options - ScriptExecutionsClientBeginDeleteOptions contains the optional parameters for the ScriptExecutionsClient.BeginDelete method.

Example ¶

Generated from example definition: 2026-03-01/ScriptExecutions_Delete.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewScriptExecutionsClient().BeginDelete(ctx, "group1", "cloud1", "addSsoServer", 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 poll 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 = armavs.ScriptExecutionsClientDeleteResponse{
	// }
}

Output:

func (*ScriptExecutionsClient) Get ¶

func (client *ScriptExecutionsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, scriptExecutionName string, options *ScriptExecutionsClientGetOptions) (ScriptExecutionsClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptExecutionName - Name of the script cmdlet.
options - ScriptExecutionsClientGetOptions contains the optional parameters for the ScriptExecutionsClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/ScriptExecutions_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewScriptExecutionsClient().Get(ctx, "group1", "cloud1", "addSsoServer", 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 = armavs.ScriptExecutionsClientGetResponse{
	// 	ScriptExecution: armavs.ScriptExecution{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
	// 		Name: to.Ptr("addSsoServer"),
	// 		Properties: &armavs.ScriptExecutionProperties{
	// 			ScriptCmdletID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/AVS.PowerCommands@1.0.0/scriptCmdlets/New-SsoExternalIdentitySource"),
	// 			Timeout: to.Ptr("P0Y0M0DT0H60M60S"),
	// 			Retention: to.Ptr("P0Y0M60DT0H60M60S"),
	// 			SubmittedAt: to.Ptr(time.Date(2021, time.March, 21, 17, 31, 28, 0, time.UTC)),
	// 			StartedAt: to.Ptr(time.Date(2021, time.March, 21, 17, 32, 28, 0, time.UTC)),
	// 			FinishedAt: to.Ptr(time.Date(2021, time.March, 21, 18, 32, 28, 0, time.UTC)),
	// 			ProvisioningState: to.Ptr(armavs.ScriptExecutionProvisioningStateSucceeded),
	// 			FailureReason: to.Ptr("vCenter failed to connect to the external server"),
	// 			Parameters: []armavs.ScriptExecutionParameterClassification{
	// 				&armavs.ScriptStringExecutionParameter{
	// 					Name: to.Ptr("DomainName"),
	// 					Type: to.Ptr(armavs.ScriptExecutionParameterTypeValue),
	// 					Value: to.Ptr("placeholderDomain.local"),
	// 				},
	// 				&armavs.ScriptStringExecutionParameter{
	// 					Name: to.Ptr("BaseUserDN"),
	// 					Type: to.Ptr(armavs.ScriptExecutionParameterTypeValue),
	// 					Value: to.Ptr("DC=placeholder, DC=placeholder"),
	// 				},
	// 			},
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/scriptExecutions"),
	// 	},
	// }
}

Output:

func (*ScriptExecutionsClient) GetExecutionLogs ¶

func (client *ScriptExecutionsClient) GetExecutionLogs(ctx context.Context, resourceGroupName string, privateCloudName string, scriptExecutionName string, options *ScriptExecutionsClientGetExecutionLogsOptions) (ScriptExecutionsClientGetExecutionLogsResponse, error)

GetExecutionLogs - Return the logs for a script execution resource If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptExecutionName - Name of the script cmdlet.
options - ScriptExecutionsClientGetExecutionLogsOptions contains the optional parameters for the ScriptExecutionsClient.GetExecutionLogs method.

Example ¶

Generated from example definition: 2026-03-01/ScriptExecutions_GetExecutionLogs.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewScriptExecutionsClient().GetExecutionLogs(ctx, "group1", "cloud1", "addSsoServer", &armavs.ScriptExecutionsClientGetExecutionLogsOptions{
		ScriptOutputStreamType: []*armavs.ScriptOutputStreamType{
			to.Ptr(armavs.ScriptOutputStreamTypeInformation),
			to.Ptr(armavs.ScriptOutputStreamType("Warnings")),
			to.Ptr(armavs.ScriptOutputStreamType("Errors")),
			to.Ptr(armavs.ScriptOutputStreamTypeOutput),
		}})
	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 = armavs.ScriptExecutionsClientGetExecutionLogsResponse{
	// 	ScriptExecution: armavs.ScriptExecution{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
	// 		Name: to.Ptr("addSsoServer"),
	// 		Properties: &armavs.ScriptExecutionProperties{
	// 			Timeout: to.Ptr("P0Y0M0D0H060M0S"),

Output:

func (*ScriptExecutionsClient) NewListPager ¶

func (client *ScriptExecutionsClient) NewListPager(resourceGroupName string, privateCloudName string, options *ScriptExecutionsClientListOptions) *runtime.Pager[ScriptExecutionsClientListResponse]

NewListPager - List ScriptExecution resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - ScriptExecutionsClientListOptions contains the optional parameters for the ScriptExecutionsClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/ScriptExecutions_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewScriptExecutionsClient().NewListPager("group1", "cloud1", 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 = armavs.ScriptExecutionsClientListResponse{
		// 	ScriptExecutionsList: armavs.ScriptExecutionsList{
		// 		Value: []*armavs.ScriptExecution{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
		// 				Name: to.Ptr("addSsoServer"),
		// 				Properties: &armavs.ScriptExecutionProperties{
		// 					ScriptCmdletID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/AVS:1.0.0/scriptCmdlets/New-SsoExternalIdentitySource"),
		// 					Timeout: to.Ptr("P0Y0M0DT0H60M60S"),
		// 					Retention: to.Ptr("P0Y0M60DT0H60M60S"),
		// 					SubmittedAt: to.Ptr(time.Date(2021, time.March, 21, 17, 31, 28, 0, time.UTC)),
		// 					StartedAt: to.Ptr(time.Date(2021, time.March, 21, 17, 32, 28, 0, time.UTC)),
		// 					FinishedAt: to.Ptr(time.Date(2021, time.March, 21, 18, 32, 28, 0, time.UTC)),
		// 					ProvisioningState: to.Ptr(armavs.ScriptExecutionProvisioningStateFailed),
		// 					FailureReason: to.Ptr("vCenter failed to connect to the external server"),
		// 					Parameters: []armavs.ScriptExecutionParameterClassification{
		// 						&armavs.ScriptStringExecutionParameter{
		// 							Name: to.Ptr("DomainName"),
		// 							Type: to.Ptr(armavs.ScriptExecutionParameterTypeValue),
		// 							Value: to.Ptr("placeholderDomain.local"),
		// 						},
		// 						&armavs.ScriptStringExecutionParameter{
		// 							Name: to.Ptr("BaseUserDN"),
		// 							Type: to.Ptr(armavs.ScriptExecutionParameterTypeValue),
		// 							Value: to.Ptr("DC=placeholder, DC=placeholder"),
		// 						},
		// 					},
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/scriptExecutions"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type ScriptExecutionsClientBeginCreateOrUpdateOptions ¶

type ScriptExecutionsClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ScriptExecutionsClientBeginCreateOrUpdateOptions contains the optional parameters for the ScriptExecutionsClient.BeginCreateOrUpdate method.

type ScriptExecutionsClientBeginDeleteOptions ¶

type ScriptExecutionsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ScriptExecutionsClientBeginDeleteOptions contains the optional parameters for the ScriptExecutionsClient.BeginDelete method.

type ScriptExecutionsClientCreateOrUpdateResponse ¶

type ScriptExecutionsClientCreateOrUpdateResponse struct {
	// An instance of a script executed by a user - custom or AVS
	ScriptExecution
}

ScriptExecutionsClientCreateOrUpdateResponse contains the response from method ScriptExecutionsClient.BeginCreateOrUpdate.

type ScriptExecutionsClientDeleteResponse ¶

type ScriptExecutionsClientDeleteResponse struct {
}

ScriptExecutionsClientDeleteResponse contains the response from method ScriptExecutionsClient.BeginDelete.

type ScriptExecutionsClientGetExecutionLogsOptions ¶

type ScriptExecutionsClientGetExecutionLogsOptions struct {
	// Name of the desired output stream to return. If not provided, will return all. An empty array will return nothing.
	ScriptOutputStreamType []*ScriptOutputStreamType
}

ScriptExecutionsClientGetExecutionLogsOptions contains the optional parameters for the ScriptExecutionsClient.GetExecutionLogs method.

type ScriptExecutionsClientGetExecutionLogsResponse ¶

type ScriptExecutionsClientGetExecutionLogsResponse struct {
	// An instance of a script executed by a user - custom or AVS
	ScriptExecution
}

ScriptExecutionsClientGetExecutionLogsResponse contains the response from method ScriptExecutionsClient.GetExecutionLogs.

type ScriptExecutionsClientGetOptions ¶

type ScriptExecutionsClientGetOptions struct {
}

ScriptExecutionsClientGetOptions contains the optional parameters for the ScriptExecutionsClient.Get method.

type ScriptExecutionsClientGetResponse ¶

type ScriptExecutionsClientGetResponse struct {
	// An instance of a script executed by a user - custom or AVS
	ScriptExecution
}

ScriptExecutionsClientGetResponse contains the response from method ScriptExecutionsClient.Get.

type ScriptExecutionsClientListOptions ¶

type ScriptExecutionsClientListOptions struct {
}

ScriptExecutionsClientListOptions contains the optional parameters for the ScriptExecutionsClient.NewListPager method.

type ScriptExecutionsClientListResponse ¶

type ScriptExecutionsClientListResponse struct {
	// The response of a ScriptExecution list operation.
	ScriptExecutionsList
}

ScriptExecutionsClientListResponse contains the response from method ScriptExecutionsClient.NewListPager.

type ScriptExecutionsList ¶

type ScriptExecutionsList struct {
	// REQUIRED; The ScriptExecution items on this page
	Value []*ScriptExecution

	// The link to the next page of items
	NextLink *string
}

ScriptExecutionsList - The response of a ScriptExecution list operation.

func (ScriptExecutionsList) MarshalJSON ¶

func (s ScriptExecutionsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptExecutionsList.

func (*ScriptExecutionsList) UnmarshalJSON ¶

func (s *ScriptExecutionsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptExecutionsList.

type ScriptOutputStreamType ¶

type ScriptOutputStreamType string

ScriptOutputStreamType - Script Output Stream type

const (
	// ScriptOutputStreamTypeError - is error
	ScriptOutputStreamTypeError ScriptOutputStreamType = "Error"
	// ScriptOutputStreamTypeInformation - is information
	ScriptOutputStreamTypeInformation ScriptOutputStreamType = "Information"
	// ScriptOutputStreamTypeOutput - is output
	ScriptOutputStreamTypeOutput ScriptOutputStreamType = "Output"
	// ScriptOutputStreamTypeWarning - is warning
	ScriptOutputStreamTypeWarning ScriptOutputStreamType = "Warning"
)

func PossibleScriptOutputStreamTypeValues ¶

func PossibleScriptOutputStreamTypeValues() []ScriptOutputStreamType

PossibleScriptOutputStreamTypeValues returns the possible values for the ScriptOutputStreamType const type.

type ScriptPackage ¶

type ScriptPackage struct {
	// The resource-specific properties for this resource.
	Properties *ScriptPackageProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

ScriptPackage - Script Package resources available for execution

func (ScriptPackage) MarshalJSON ¶

func (s ScriptPackage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptPackage.

func (*ScriptPackage) UnmarshalJSON ¶

func (s *ScriptPackage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptPackage.

type ScriptPackageProperties ¶

type ScriptPackageProperties struct {
	// READ-ONLY; Company that created and supports the package
	Company *string

	// READ-ONLY; User friendly description of the package
	Description *string

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

	// READ-ONLY; Link to support by the package vendor
	URI *string

	// READ-ONLY; Module version
	Version *string
}

ScriptPackageProperties - Properties of a Script Package subresource

func (ScriptPackageProperties) MarshalJSON ¶

func (s ScriptPackageProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptPackageProperties.

func (*ScriptPackageProperties) UnmarshalJSON ¶

func (s *ScriptPackageProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptPackageProperties.

type ScriptPackageProvisioningState ¶

type ScriptPackageProvisioningState string

ScriptPackageProvisioningState - Script Package provisioning state

const (
	// ScriptPackageProvisioningStateCanceled - Resource creation was canceled.
	ScriptPackageProvisioningStateCanceled ScriptPackageProvisioningState = "Canceled"
	// ScriptPackageProvisioningStateFailed - Resource creation failed.
	ScriptPackageProvisioningStateFailed ScriptPackageProvisioningState = "Failed"
	// ScriptPackageProvisioningStateSucceeded - Resource has been created.
	ScriptPackageProvisioningStateSucceeded ScriptPackageProvisioningState = "Succeeded"
)

func PossibleScriptPackageProvisioningStateValues ¶

func PossibleScriptPackageProvisioningStateValues() []ScriptPackageProvisioningState

PossibleScriptPackageProvisioningStateValues returns the possible values for the ScriptPackageProvisioningState const type.

type ScriptPackagesClient ¶

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

ScriptPackagesClient contains the methods for the ScriptPackages group. Don't use this type directly, use NewScriptPackagesClient() instead.

Generated from API version 2026-03-01

func NewScriptPackagesClient ¶

func NewScriptPackagesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ScriptPackagesClient, error)

NewScriptPackagesClient creates a new instance of ScriptPackagesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*ScriptPackagesClient) Get ¶

func (client *ScriptPackagesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, scriptPackageName string, options *ScriptPackagesClientGetOptions) (ScriptPackagesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
scriptPackageName - Name of the script package.
options - ScriptPackagesClientGetOptions contains the optional parameters for the ScriptPackagesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/ScriptPackages_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewScriptPackagesClient().Get(ctx, "group1", "cloud1", "Microsoft.AVS.Management@3.0.48", 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 = armavs.ScriptPackagesClientGetResponse{
	// 	ScriptPackage: armavs.ScriptPackage{
	// 		Name: to.Ptr("Microsoft.AVS.Management@3.0.48"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/Microsoft.AVS.Management@3.0.48"),
	// 		Properties: &armavs.ScriptPackageProperties{
	// 			Description: to.Ptr("Various cmdlets for elevated access to Private Cloud administrative functions"),
	// 			Version: to.Ptr("3.0.48"),
	// 			Company: to.Ptr("Microsoft"),
	// 			URI: to.Ptr("https://microsoft.com"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages"),
	// 	},
	// }
}

Output:

func (*ScriptPackagesClient) NewListPager ¶

func (client *ScriptPackagesClient) NewListPager(resourceGroupName string, privateCloudName string, options *ScriptPackagesClientListOptions) *runtime.Pager[ScriptPackagesClientListResponse]

NewListPager - List ScriptPackage resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - ScriptPackagesClientListOptions contains the optional parameters for the ScriptPackagesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/ScriptPackages_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewScriptPackagesClient().NewListPager("group1", "cloud1", 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 = armavs.ScriptPackagesClientListResponse{
		// 	ScriptPackagesList: armavs.ScriptPackagesList{
		// 		Value: []*armavs.ScriptPackage{
		// 			{
		// 				Name: to.Ptr("Microsoft.AVS.Management@3.0.48"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/Microsoft.AVS.Management@3.0.48"),
		// 				Properties: &armavs.ScriptPackageProperties{
		// 					Description: to.Ptr("Various cmdlets for elevated access to Private Cloud administrative functions"),
		// 					Version: to.Ptr("3.0.48"),
		// 					Company: to.Ptr("Microsoft"),
		// 					URI: to.Ptr("https://microsoft.com"),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages"),
		// 			},
		// 			{
		// 				Name: to.Ptr("JSDR.Configuration@1.0.0"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/JSDR.Configuration@1.0.0"),
		// 				Properties: &armavs.ScriptPackageProperties{
		// 					Description: to.Ptr("Various cmdlets by Jetstream for Private Cloud administration"),
		// 					Version: to.Ptr("1.0.0"),
		// 					Company: to.Ptr("Jetstream Software"),
		// 					URI: to.Ptr("https://www.jetstreamsoft.com/about/support/"),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type ScriptPackagesClientGetOptions ¶

type ScriptPackagesClientGetOptions struct {
}

ScriptPackagesClientGetOptions contains the optional parameters for the ScriptPackagesClient.Get method.

type ScriptPackagesClientGetResponse ¶

type ScriptPackagesClientGetResponse struct {
	// Script Package resources available for execution
	ScriptPackage
}

ScriptPackagesClientGetResponse contains the response from method ScriptPackagesClient.Get.

type ScriptPackagesClientListOptions ¶

type ScriptPackagesClientListOptions struct {
}

ScriptPackagesClientListOptions contains the optional parameters for the ScriptPackagesClient.NewListPager method.

type ScriptPackagesClientListResponse ¶

type ScriptPackagesClientListResponse struct {
	// The response of a ScriptPackage list operation.
	ScriptPackagesList
}

ScriptPackagesClientListResponse contains the response from method ScriptPackagesClient.NewListPager.

type ScriptPackagesList ¶

type ScriptPackagesList struct {
	// REQUIRED; The ScriptPackage items on this page
	Value []*ScriptPackage

	// The link to the next page of items
	NextLink *string
}

ScriptPackagesList - The response of a ScriptPackage list operation.

func (ScriptPackagesList) MarshalJSON ¶

func (s ScriptPackagesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptPackagesList.

func (*ScriptPackagesList) UnmarshalJSON ¶

func (s *ScriptPackagesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptPackagesList.

type ScriptParameter ¶

type ScriptParameter struct {
	// The parameter name that the script will expect a parameter value for
	Name *string

	// READ-ONLY; User friendly description of the parameter
	Description *string

	// READ-ONLY; Is this parameter required or optional
	Optional *OptionalParamEnum

	// READ-ONLY; The type of parameter the script is expecting. psCredential is a
	// PSCredentialObject
	Type *ScriptParameterTypes

	// READ-ONLY; Should this parameter be visible to arm and passed in the parameters argument
	// when executing
	Visibility *VisibilityParameterEnum
}

ScriptParameter - An parameter that the script will accept

func (ScriptParameter) MarshalJSON ¶

func (s ScriptParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptParameter.

func (*ScriptParameter) UnmarshalJSON ¶

func (s *ScriptParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptParameter.

type ScriptParameterTypes ¶

type ScriptParameterTypes string

ScriptParameterTypes - Script Parameter types

const (
	// ScriptParameterTypesBool - is bool
	ScriptParameterTypesBool ScriptParameterTypes = "Bool"
	// ScriptParameterTypesCredential - is credential
	ScriptParameterTypesCredential ScriptParameterTypes = "Credential"
	// ScriptParameterTypesFloat - is float
	ScriptParameterTypesFloat ScriptParameterTypes = "Float"
	// ScriptParameterTypesInt - is int
	ScriptParameterTypesInt ScriptParameterTypes = "Int"
	// ScriptParameterTypesSecureString - is secure string
	ScriptParameterTypesSecureString ScriptParameterTypes = "SecureString"
	// ScriptParameterTypesString - is string
	ScriptParameterTypesString ScriptParameterTypes = "String"
)

func PossibleScriptParameterTypesValues ¶

func PossibleScriptParameterTypesValues() []ScriptParameterTypes

PossibleScriptParameterTypesValues returns the possible values for the ScriptParameterTypes const type.

type ScriptSecureStringExecutionParameter ¶

type ScriptSecureStringExecutionParameter struct {
	// REQUIRED; The parameter name
	Name *string

	// CONSTANT; The type of execution parameter
	// Field has constant value ScriptExecutionParameterTypeSecureValue, any specified value is ignored.
	Type *ScriptExecutionParameterType

	// A secure value for the passed parameter, not to be stored in logs
	SecureValue *string
}

ScriptSecureStringExecutionParameter - a plain text value execution parameter

func (*ScriptSecureStringExecutionParameter) GetScriptExecutionParameter ¶

func (s *ScriptSecureStringExecutionParameter) GetScriptExecutionParameter() *ScriptExecutionParameter

GetScriptExecutionParameter implements the ScriptExecutionParameterClassification interface for type ScriptSecureStringExecutionParameter.

func (ScriptSecureStringExecutionParameter) MarshalJSON ¶

func (s ScriptSecureStringExecutionParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptSecureStringExecutionParameter.

func (*ScriptSecureStringExecutionParameter) UnmarshalJSON ¶

func (s *ScriptSecureStringExecutionParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptSecureStringExecutionParameter.

type ScriptStringExecutionParameter ¶

type ScriptStringExecutionParameter struct {
	// REQUIRED; The parameter name
	Name *string

	// CONSTANT; The type of execution parameter
	// Field has constant value ScriptExecutionParameterTypeValue, any specified value is ignored.
	Type *ScriptExecutionParameterType

	// The value for the passed parameter
	Value *string
}

ScriptStringExecutionParameter - a plain text value execution parameter

func (*ScriptStringExecutionParameter) GetScriptExecutionParameter ¶

func (s *ScriptStringExecutionParameter) GetScriptExecutionParameter() *ScriptExecutionParameter

GetScriptExecutionParameter implements the ScriptExecutionParameterClassification interface for type ScriptStringExecutionParameter.

func (ScriptStringExecutionParameter) MarshalJSON ¶

func (s ScriptStringExecutionParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ScriptStringExecutionParameter.

func (*ScriptStringExecutionParameter) UnmarshalJSON ¶

func (s *ScriptStringExecutionParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScriptStringExecutionParameter.

type SegmentStatusEnum ¶

type SegmentStatusEnum string

SegmentStatusEnum - Segment status

const (
	// SegmentStatusEnumFAILURE - is failure
	SegmentStatusEnumFAILURE SegmentStatusEnum = "FAILURE"
	// SegmentStatusEnumSUCCESS - is success
	SegmentStatusEnumSUCCESS SegmentStatusEnum = "SUCCESS"
)

func PossibleSegmentStatusEnumValues ¶

func PossibleSegmentStatusEnumValues() []SegmentStatusEnum

PossibleSegmentStatusEnumValues returns the possible values for the SegmentStatusEnum const type.

type SpecializedHostProperties ¶ added in v2.1.0

type SpecializedHostProperties struct {
	// REQUIRED; The kind of host is specialized.
	Kind *HostKind

	// Display name of the host in VMware vCenter.
	DisplayName *string

	// The licenses assigned to the host.
	Licenses []HostLicenseClassification

	// If provided, the host is in maintenance. The value is the reason for maintenance.
	Maintenance *HostMaintenance

	// READ-ONLY
	FaultDomain *string

	// READ-ONLY; Fully qualified domain name of the host.
	Fqdn *string

	// READ-ONLY; vCenter managed object reference ID of the host.
	MoRefID *string

	// READ-ONLY; The state of the host provisioning.
	ProvisioningState *HostProvisioningState
}

SpecializedHostProperties - The properties of a specialized host.

func (*SpecializedHostProperties) GetHostProperties ¶ added in v2.1.0

func (s *SpecializedHostProperties) GetHostProperties() *HostProperties

GetHostProperties implements the HostPropertiesClassification interface for type SpecializedHostProperties.

func (SpecializedHostProperties) MarshalJSON ¶ added in v2.1.0

func (s SpecializedHostProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SpecializedHostProperties.

func (*SpecializedHostProperties) UnmarshalJSON ¶ added in v2.1.0

func (s *SpecializedHostProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SpecializedHostProperties.

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 Trial ¶

type Trial struct {
	// READ-ONLY; Number of trial hosts available
	AvailableHosts *int32

	// READ-ONLY; Trial status
	Status *TrialStatus
}

Trial - Subscription trial availability

func (Trial) MarshalJSON ¶

func (t Trial) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Trial.

func (*Trial) UnmarshalJSON ¶

func (t *Trial) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Trial.

type TrialStatus ¶

type TrialStatus string

TrialStatus - trial status

const (
	// TrialStatusTrialAvailable - is available
	TrialStatusTrialAvailable TrialStatus = "TrialAvailable"
	// TrialStatusTrialDisabled - is disabled
	TrialStatusTrialDisabled TrialStatus = "TrialDisabled"
	// TrialStatusTrialUsed - is used
	TrialStatusTrialUsed TrialStatus = "TrialUsed"
)

func PossibleTrialStatusValues ¶

func PossibleTrialStatusValues() []TrialStatus

PossibleTrialStatusValues returns the possible values for the TrialStatus const type.

type VMGroupStatusEnum ¶

type VMGroupStatusEnum string

VMGroupStatusEnum - VM group status

const (
	// VMGroupStatusEnumFAILURE - is failure
	VMGroupStatusEnumFAILURE VMGroupStatusEnum = "FAILURE"
	// VMGroupStatusEnumSUCCESS - is success
	VMGroupStatusEnumSUCCESS VMGroupStatusEnum = "SUCCESS"
)

func PossibleVMGroupStatusEnumValues ¶

func PossibleVMGroupStatusEnumValues() []VMGroupStatusEnum

PossibleVMGroupStatusEnumValues returns the possible values for the VMGroupStatusEnum const type.

type VMHostPlacementPolicyProperties ¶

type VMHostPlacementPolicyProperties struct {
	// REQUIRED; placement policy affinity type
	AffinityType *AffinityType

	// REQUIRED; Host members list
	HostMembers []*string

	// CONSTANT; placement policy type
	// Field has constant value PlacementPolicyTypeVMHost, any specified value is ignored.
	Type *PlacementPolicyType

	// REQUIRED; Virtual machine members list
	VMMembers []*string

	// vm-host placement policy affinity strength (should/must)
	AffinityStrength *AffinityStrength

	// placement policy azure hybrid benefit opt-in type
	AzureHybridBenefitType *AzureHybridBenefitType

	// Display name of the placement policy
	DisplayName *string

	// Whether the placement policy is enabled or disabled
	State *PlacementPolicyState

	// READ-ONLY; The provisioning state
	ProvisioningState *PlacementPolicyProvisioningState
}

VMHostPlacementPolicyProperties - VM-Host placement policy properties

func (*VMHostPlacementPolicyProperties) GetPlacementPolicyProperties ¶

func (v *VMHostPlacementPolicyProperties) GetPlacementPolicyProperties() *PlacementPolicyProperties

GetPlacementPolicyProperties implements the PlacementPolicyPropertiesClassification interface for type VMHostPlacementPolicyProperties.

func (VMHostPlacementPolicyProperties) MarshalJSON ¶

func (v VMHostPlacementPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMHostPlacementPolicyProperties.

func (*VMHostPlacementPolicyProperties) UnmarshalJSON ¶

func (v *VMHostPlacementPolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMHostPlacementPolicyProperties.

type VMPlacementPolicyProperties ¶

type VMPlacementPolicyProperties struct {
	// REQUIRED; placement policy affinity type
	AffinityType *AffinityType

	// CONSTANT; placement policy type
	// Field has constant value PlacementPolicyTypeVMVM, any specified value is ignored.
	Type *PlacementPolicyType

	// REQUIRED; Virtual machine members list
	VMMembers []*string

	// Display name of the placement policy
	DisplayName *string

	// Whether the placement policy is enabled or disabled
	State *PlacementPolicyState

	// READ-ONLY; The provisioning state
	ProvisioningState *PlacementPolicyProvisioningState
}

VMPlacementPolicyProperties - VM-VM placement policy properties

func (*VMPlacementPolicyProperties) GetPlacementPolicyProperties ¶

func (v *VMPlacementPolicyProperties) GetPlacementPolicyProperties() *PlacementPolicyProperties

GetPlacementPolicyProperties implements the PlacementPolicyPropertiesClassification interface for type VMPlacementPolicyProperties.

func (VMPlacementPolicyProperties) MarshalJSON ¶

func (v VMPlacementPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMPlacementPolicyProperties.

func (*VMPlacementPolicyProperties) UnmarshalJSON ¶

func (v *VMPlacementPolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMPlacementPolicyProperties.

type VMTypeEnum ¶

type VMTypeEnum string

VMTypeEnum - VM type

const (
	// VMTypeEnumEDGE - is edge
	VMTypeEnumEDGE VMTypeEnum = "EDGE"
	// VMTypeEnumREGULAR - is regular
	VMTypeEnumREGULAR VMTypeEnum = "REGULAR"
	// VMTypeEnumSERVICE - is service
	VMTypeEnumSERVICE VMTypeEnum = "SERVICE"
)

func PossibleVMTypeEnumValues ¶

func PossibleVMTypeEnumValues() []VMTypeEnum

PossibleVMTypeEnumValues returns the possible values for the VMTypeEnum const type.

type Vcf5License ¶ added in v2.2.0

type Vcf5License struct {
	// REQUIRED; Number of cores included in the license
	Cores *int32

	// REQUIRED; UTC datetime when the license expires
	EndDate *time.Time

	// CONSTANT; License kind
	// Field has constant value VcfLicenseKindVcf5, any specified value is ignored.
	Kind *VcfLicenseKind

	// The Broadcom contract number associated with the license.
	BroadcomContractNumber *string

	// The Broadcom site ID associated with the license.
	BroadcomSiteID *string

	// Additional labels passed through for license reporting.
	Labels []*Label

	// License key
	LicenseKey *string

	// READ-ONLY; The state of the license provisioning
	ProvisioningState *LicenseProvisioningState
}

Vcf5License - A VMware Cloud Foundation (VCF) 5.0 license

func (*Vcf5License) GetVcfLicense ¶ added in v2.2.0

func (v *Vcf5License) GetVcfLicense() *VcfLicense

GetVcfLicense implements the VcfLicenseClassification interface for type Vcf5License.

func (Vcf5License) MarshalJSON ¶ added in v2.2.0

func (v Vcf5License) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Vcf5License.

func (*Vcf5License) UnmarshalJSON ¶ added in v2.2.0

func (v *Vcf5License) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Vcf5License.

type VcfLicense ¶ added in v2.2.0

type VcfLicense struct {
	// REQUIRED; License kind
	Kind *VcfLicenseKind

	// READ-ONLY; The state of the license provisioning
	ProvisioningState *LicenseProvisioningState
}

VcfLicense - A VMware Cloud Foundation license

func (*VcfLicense) GetVcfLicense ¶ added in v2.2.0

func (v *VcfLicense) GetVcfLicense() *VcfLicense

GetVcfLicense implements the VcfLicenseClassification interface for type VcfLicense.

func (VcfLicense) MarshalJSON ¶ added in v2.2.0

func (v VcfLicense) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VcfLicense.

func (*VcfLicense) UnmarshalJSON ¶ added in v2.2.0

func (v *VcfLicense) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VcfLicense.

type VcfLicenseClassification ¶ added in v2.2.0

type VcfLicenseClassification interface {
	// GetVcfLicense returns the VcfLicense content of the underlying type.
	GetVcfLicense() *VcfLicense
}

VcfLicenseClassification provides polymorphic access to related types. Call the interface's GetVcfLicense() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *Vcf5License, *VcfLicense

type VcfLicenseKind ¶ added in v2.2.0

type VcfLicenseKind string

VcfLicenseKind - The kind of license.

const (
	// VcfLicenseKindVcf5 - A VMware Cloud Foundation (VCF) 5.0 license
	VcfLicenseKindVcf5 VcfLicenseKind = "vcf5"
)

func PossibleVcfLicenseKindValues ¶ added in v2.2.0

func PossibleVcfLicenseKindValues() []VcfLicenseKind

PossibleVcfLicenseKindValues returns the possible values for the VcfLicenseKind const type.

type VirtualMachine ¶

type VirtualMachine struct {
	// The resource-specific properties for this resource.
	Properties *VirtualMachineProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

VirtualMachine - Virtual Machine

func (VirtualMachine) MarshalJSON ¶

func (v VirtualMachine) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachine.

func (*VirtualMachine) UnmarshalJSON ¶

func (v *VirtualMachine) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachine.

type VirtualMachineProperties ¶

type VirtualMachineProperties struct {
	// READ-ONLY; Display name of the VM.
	DisplayName *string

	// READ-ONLY; Path to virtual machine's folder starting from datacenter virtual machine folder
	FolderPath *string

	// READ-ONLY; vCenter managed object reference ID of the virtual machine
	MoRefID *string

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

	// READ-ONLY; Whether VM DRS-driven movement is restricted (enabled) or not (disabled)
	RestrictMovement *VirtualMachineRestrictMovementState
}

VirtualMachineProperties - Virtual Machine Properties

func (VirtualMachineProperties) MarshalJSON ¶

func (v VirtualMachineProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineProperties.

func (*VirtualMachineProperties) UnmarshalJSON ¶

func (v *VirtualMachineProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineProperties.

type VirtualMachineProvisioningState ¶

type VirtualMachineProvisioningState string

VirtualMachineProvisioningState - Virtual Machine provisioning state

const (
	// VirtualMachineProvisioningStateCanceled - Resource creation was canceled.
	VirtualMachineProvisioningStateCanceled VirtualMachineProvisioningState = "Canceled"
	// VirtualMachineProvisioningStateFailed - Resource creation failed.
	VirtualMachineProvisioningStateFailed VirtualMachineProvisioningState = "Failed"
	// VirtualMachineProvisioningStateSucceeded - Resource has been created.
	VirtualMachineProvisioningStateSucceeded VirtualMachineProvisioningState = "Succeeded"
)

func PossibleVirtualMachineProvisioningStateValues ¶

func PossibleVirtualMachineProvisioningStateValues() []VirtualMachineProvisioningState

PossibleVirtualMachineProvisioningStateValues returns the possible values for the VirtualMachineProvisioningState const type.

type VirtualMachineRestrictMovement ¶

type VirtualMachineRestrictMovement struct {
	// Whether VM DRS-driven movement is restricted (enabled) or not (disabled)
	RestrictMovement *VirtualMachineRestrictMovementState
}

VirtualMachineRestrictMovement - Set VM DRS-driven movement to restricted (enabled) or not (disabled)

func (VirtualMachineRestrictMovement) MarshalJSON ¶

func (v VirtualMachineRestrictMovement) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineRestrictMovement.

func (*VirtualMachineRestrictMovement) UnmarshalJSON ¶

func (v *VirtualMachineRestrictMovement) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineRestrictMovement.

type VirtualMachineRestrictMovementState ¶

type VirtualMachineRestrictMovementState string

VirtualMachineRestrictMovementState - Virtual Machine Restrict Movement state

const (
	// VirtualMachineRestrictMovementStateDisabled - is disabled
	VirtualMachineRestrictMovementStateDisabled VirtualMachineRestrictMovementState = "Disabled"
	// VirtualMachineRestrictMovementStateEnabled - is enabled
	VirtualMachineRestrictMovementStateEnabled VirtualMachineRestrictMovementState = "Enabled"
)

func PossibleVirtualMachineRestrictMovementStateValues ¶

func PossibleVirtualMachineRestrictMovementStateValues() []VirtualMachineRestrictMovementState

PossibleVirtualMachineRestrictMovementStateValues returns the possible values for the VirtualMachineRestrictMovementState const type.

type VirtualMachinesClient ¶

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

VirtualMachinesClient contains the methods for the VirtualMachines group. Don't use this type directly, use NewVirtualMachinesClient() instead.

Generated from API version 2026-03-01

func NewVirtualMachinesClient ¶

func NewVirtualMachinesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VirtualMachinesClient, error)

NewVirtualMachinesClient creates a new instance of VirtualMachinesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*VirtualMachinesClient) BeginRestrictMovement ¶

func (client *VirtualMachinesClient) BeginRestrictMovement(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, virtualMachineID string, restrictMovement VirtualMachineRestrictMovement, options *VirtualMachinesClientBeginRestrictMovementOptions) (*runtime.Poller[VirtualMachinesClientRestrictMovementResponse], error)

BeginRestrictMovement - Enable or disable DRS-driven VM movement restriction If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
virtualMachineID - ID of the virtual machine.
restrictMovement - The content of the action request
options - VirtualMachinesClientBeginRestrictMovementOptions contains the optional parameters for the VirtualMachinesClient.BeginRestrictMovement method.

Example ¶

Generated from example definition: 2026-03-01/VirtualMachines_RestrictMovement.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVirtualMachinesClient().BeginRestrictMovement(ctx, "group1", "cloud1", "cluster1", "vm-209", armavs.VirtualMachineRestrictMovement{
		RestrictMovement: to.Ptr(armavs.VirtualMachineRestrictMovementStateEnabled),
	}, 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 poll the result: %v", err)
	}
}

Output:

func (*VirtualMachinesClient) Get ¶

func (client *VirtualMachinesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, virtualMachineID string, options *VirtualMachinesClientGetOptions) (VirtualMachinesClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
virtualMachineID - ID of the virtual machine.
options - VirtualMachinesClientGetOptions contains the optional parameters for the VirtualMachinesClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/VirtualMachines_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVirtualMachinesClient().Get(ctx, "group1", "cloud1", "cluster1", "vm-209", 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 = armavs.VirtualMachinesClientGetResponse{
	// 	VirtualMachine: armavs.VirtualMachine{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-209"),
	// 		Name: to.Ptr("vm-209"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/virtualMachines"),
	// 		Properties: &armavs.VirtualMachineProperties{
	// 			DisplayName: to.Ptr("contoso-vm"),
	// 			MoRefID: to.Ptr("vm-209"),
	// 			FolderPath: to.Ptr("vm/folder-1"),
	// 			RestrictMovement: to.Ptr(armavs.VirtualMachineRestrictMovementStateDisabled),
	// 		},
	// 	},
	// }
}

Output:

func (*VirtualMachinesClient) NewListPager ¶

func (client *VirtualMachinesClient) NewListPager(resourceGroupName string, privateCloudName string, clusterName string, options *VirtualMachinesClientListOptions) *runtime.Pager[VirtualMachinesClientListResponse]

NewListPager - List VirtualMachine resources by Cluster

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
clusterName - Name of the cluster
options - VirtualMachinesClientListOptions contains the optional parameters for the VirtualMachinesClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/VirtualMachines_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVirtualMachinesClient().NewListPager("group1", "cloud1", "cluster1", 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 = armavs.VirtualMachinesClientListResponse{
		// 	VirtualMachinesList: armavs.VirtualMachinesList{
		// 		Value: []*armavs.VirtualMachine{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-209"),
		// 				Name: to.Ptr("vm-209"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/virtualMachines"),
		// 				Properties: &armavs.VirtualMachineProperties{
		// 					DisplayName: to.Ptr("contoso-vm1"),
		// 					MoRefID: to.Ptr("vm-209"),
		// 					FolderPath: to.Ptr("vm/folder-1"),
		// 					RestrictMovement: to.Ptr(armavs.VirtualMachineRestrictMovementStateDisabled),
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
		// 				Name: to.Ptr("vm-128"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/virtualMachines"),
		// 				Properties: &armavs.VirtualMachineProperties{
		// 					DisplayName: to.Ptr("contoso-vm2"),
		// 					MoRefID: to.Ptr("vm-128"),
		// 					FolderPath: to.Ptr("vm"),
		// 					RestrictMovement: to.Ptr(armavs.VirtualMachineRestrictMovementStateEnabled),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type VirtualMachinesClientBeginRestrictMovementOptions ¶

type VirtualMachinesClientBeginRestrictMovementOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

VirtualMachinesClientBeginRestrictMovementOptions contains the optional parameters for the VirtualMachinesClient.BeginRestrictMovement method.

type VirtualMachinesClientGetOptions ¶

type VirtualMachinesClientGetOptions struct {
}

VirtualMachinesClientGetOptions contains the optional parameters for the VirtualMachinesClient.Get method.

type VirtualMachinesClientGetResponse ¶

type VirtualMachinesClientGetResponse struct {
	// Virtual Machine
	VirtualMachine
}

VirtualMachinesClientGetResponse contains the response from method VirtualMachinesClient.Get.

type VirtualMachinesClientListOptions ¶

type VirtualMachinesClientListOptions struct {
}

VirtualMachinesClientListOptions contains the optional parameters for the VirtualMachinesClient.NewListPager method.

type VirtualMachinesClientListResponse ¶

type VirtualMachinesClientListResponse struct {
	// The response of a VirtualMachine list operation.
	VirtualMachinesList
}

VirtualMachinesClientListResponse contains the response from method VirtualMachinesClient.NewListPager.

type VirtualMachinesClientRestrictMovementResponse ¶

type VirtualMachinesClientRestrictMovementResponse struct {
}

VirtualMachinesClientRestrictMovementResponse contains the response from method VirtualMachinesClient.BeginRestrictMovement.

type VirtualMachinesList ¶

type VirtualMachinesList struct {
	// REQUIRED; The VirtualMachine items on this page
	Value []*VirtualMachine

	// The link to the next page of items
	NextLink *string
}

VirtualMachinesList - The response of a VirtualMachine list operation.

func (VirtualMachinesList) MarshalJSON ¶

func (v VirtualMachinesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachinesList.

func (*VirtualMachinesList) UnmarshalJSON ¶

func (v *VirtualMachinesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachinesList.

type VisibilityParameterEnum ¶

type VisibilityParameterEnum string

VisibilityParameterEnum - Visibility Parameter

const (
	// VisibilityParameterEnumHidden - is hidden
	VisibilityParameterEnumHidden VisibilityParameterEnum = "Hidden"
	// VisibilityParameterEnumVisible - is visible
	VisibilityParameterEnumVisible VisibilityParameterEnum = "Visible"
)

func PossibleVisibilityParameterEnumValues ¶

func PossibleVisibilityParameterEnumValues() []VisibilityParameterEnum

PossibleVisibilityParameterEnumValues returns the possible values for the VisibilityParameterEnum const type.

type VmwareFirewallLicenseProperties ¶ added in v2.2.0

type VmwareFirewallLicenseProperties struct {
	// REQUIRED; Number of cores included in the license, measured per hour
	Cores *int32

	// REQUIRED; UTC datetime when the license expires
	EndDate *time.Time

	// CONSTANT; License kind
	// Field has constant value LicenseKindVmwareFirewall, any specified value is ignored.
	Kind *LicenseKind

	// The Broadcom contract number associated with the license.
	BroadcomContractNumber *string

	// The Broadcom site ID associated with the license.
	BroadcomSiteID *string

	// Additional labels passed through for license reporting.
	Labels []*Label

	// License key
	LicenseKey *string

	// READ-ONLY; The state of the license provisioning
	ProvisioningState *LicenseProvisioningState
}

VmwareFirewallLicenseProperties - The properties of a VMware Firewall license

func (*VmwareFirewallLicenseProperties) GetLicenseProperties ¶ added in v2.2.0

func (v *VmwareFirewallLicenseProperties) GetLicenseProperties() *LicenseProperties

GetLicenseProperties implements the LicensePropertiesClassification interface for type VmwareFirewallLicenseProperties.

func (VmwareFirewallLicenseProperties) MarshalJSON ¶ added in v2.2.0

func (v VmwareFirewallLicenseProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VmwareFirewallLicenseProperties.

func (*VmwareFirewallLicenseProperties) UnmarshalJSON ¶ added in v2.2.0

func (v *VmwareFirewallLicenseProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VmwareFirewallLicenseProperties.

type WeekendReschedulingConstraint ¶

type WeekendReschedulingConstraint struct {
	// REQUIRED
	Kind *RescheduleOperationConstraintKind

	// READ-ONLY; Reason why weekend rescheduling is disabled
	DisabledReason *string

	// READ-ONLY; Indicates if rescheduling is disabled on weekends
	IsDisabled *bool
}

WeekendReschedulingConstraint - Constraint defining weekend rescheduling restrictions

func (*WeekendReschedulingConstraint) GetRescheduleOperationConstraint ¶

func (w *WeekendReschedulingConstraint) GetRescheduleOperationConstraint() *RescheduleOperationConstraint

GetRescheduleOperationConstraint implements the RescheduleOperationConstraintClassification interface for type WeekendReschedulingConstraint.

func (WeekendReschedulingConstraint) MarshalJSON ¶

func (w WeekendReschedulingConstraint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WeekendReschedulingConstraint.

func (*WeekendReschedulingConstraint) UnmarshalJSON ¶

func (w *WeekendReschedulingConstraint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WeekendReschedulingConstraint.

type WeekendSchedulingConstraint ¶

type WeekendSchedulingConstraint struct {
	// REQUIRED
	Kind *ScheduleOperationConstraintKind

	// READ-ONLY; Reason why weekend scheduling is disabled
	DisabledReason *string

	// READ-ONLY; Indicates if scheduling is disabled on weekends
	IsDisabled *bool
}

WeekendSchedulingConstraint - Constraint defining weekend scheduling restrictions

func (*WeekendSchedulingConstraint) GetScheduleOperationConstraint ¶

func (w *WeekendSchedulingConstraint) GetScheduleOperationConstraint() *ScheduleOperationConstraint

GetScheduleOperationConstraint implements the ScheduleOperationConstraintClassification interface for type WeekendSchedulingConstraint.

func (WeekendSchedulingConstraint) MarshalJSON ¶

func (w WeekendSchedulingConstraint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WeekendSchedulingConstraint.

func (*WeekendSchedulingConstraint) UnmarshalJSON ¶

func (w *WeekendSchedulingConstraint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WeekendSchedulingConstraint.

type WindowsServerLicense ¶

type WindowsServerLicense struct {
	// CONSTANT; License kind
	// Field has constant value HostLicenseKindWindowsServer, any specified value is ignored.
	Kind *HostLicenseKind
}

WindowsServerLicense - The host is to be used with Azure Hybrid Benefit for Windows Server.

func (*WindowsServerLicense) GetHostLicense ¶

func (w *WindowsServerLicense) GetHostLicense() *HostLicense

GetHostLicense implements the HostLicenseClassification interface for type WindowsServerLicense.

func (WindowsServerLicense) MarshalJSON ¶

func (w WindowsServerLicense) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WindowsServerLicense.

func (*WindowsServerLicense) UnmarshalJSON ¶

func (w *WindowsServerLicense) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WindowsServerLicense.

type WorkloadNetwork ¶

type WorkloadNetwork struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetwork - Workload Network

func (WorkloadNetwork) MarshalJSON ¶

func (w WorkloadNetwork) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetwork.

func (*WorkloadNetwork) UnmarshalJSON ¶

func (w *WorkloadNetwork) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetwork.

type WorkloadNetworkDNSService ¶

type WorkloadNetworkDNSService struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkDNSServiceProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkDNSService - NSX DNS Service

func (WorkloadNetworkDNSService) MarshalJSON ¶

func (w WorkloadNetworkDNSService) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDNSService.

func (*WorkloadNetworkDNSService) UnmarshalJSON ¶

func (w *WorkloadNetworkDNSService) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDNSService.

type WorkloadNetworkDNSServiceProperties ¶

type WorkloadNetworkDNSServiceProperties struct {
	// DNS service IP of the DNS Service.
	DNSServiceIP *string

	// Default DNS zone of the DNS Service.
	DefaultDNSZone *string

	// Display name of the DNS Service.
	DisplayName *string

	// FQDN zones of the DNS Service.
	FqdnZones []*string

	// DNS Service log level.
	LogLevel *DNSServiceLogLevelEnum

	// NSX revision number.
	Revision *int64

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkDNSServiceProvisioningState

	// READ-ONLY; DNS Service status.
	Status *DNSServiceStatusEnum
}

WorkloadNetworkDNSServiceProperties - NSX DNS Service Properties

func (WorkloadNetworkDNSServiceProperties) MarshalJSON ¶

func (w WorkloadNetworkDNSServiceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDNSServiceProperties.

func (*WorkloadNetworkDNSServiceProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkDNSServiceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDNSServiceProperties.

type WorkloadNetworkDNSServiceProvisioningState ¶

type WorkloadNetworkDNSServiceProvisioningState string

WorkloadNetworkDNSServiceProvisioningState - Workload Network DNS Service provisioning state

const (
	// WorkloadNetworkDNSServiceProvisioningStateBuilding - is building
	WorkloadNetworkDNSServiceProvisioningStateBuilding WorkloadNetworkDNSServiceProvisioningState = "Building"
	// WorkloadNetworkDNSServiceProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkDNSServiceProvisioningStateCanceled WorkloadNetworkDNSServiceProvisioningState = "Canceled"
	// WorkloadNetworkDNSServiceProvisioningStateDeleting - is deleting
	WorkloadNetworkDNSServiceProvisioningStateDeleting WorkloadNetworkDNSServiceProvisioningState = "Deleting"
	// WorkloadNetworkDNSServiceProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkDNSServiceProvisioningStateFailed WorkloadNetworkDNSServiceProvisioningState = "Failed"
	// WorkloadNetworkDNSServiceProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkDNSServiceProvisioningStateSucceeded WorkloadNetworkDNSServiceProvisioningState = "Succeeded"
	// WorkloadNetworkDNSServiceProvisioningStateUpdating - is updating
	WorkloadNetworkDNSServiceProvisioningStateUpdating WorkloadNetworkDNSServiceProvisioningState = "Updating"
)

func PossibleWorkloadNetworkDNSServiceProvisioningStateValues ¶

func PossibleWorkloadNetworkDNSServiceProvisioningStateValues() []WorkloadNetworkDNSServiceProvisioningState

PossibleWorkloadNetworkDNSServiceProvisioningStateValues returns the possible values for the WorkloadNetworkDNSServiceProvisioningState const type.

type WorkloadNetworkDNSServicesList ¶

type WorkloadNetworkDNSServicesList struct {
	// REQUIRED; The WorkloadNetworkDnsService items on this page
	Value []*WorkloadNetworkDNSService

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkDNSServicesList - The response of a WorkloadNetworkDnsService list operation.

func (WorkloadNetworkDNSServicesList) MarshalJSON ¶

func (w WorkloadNetworkDNSServicesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDNSServicesList.

func (*WorkloadNetworkDNSServicesList) UnmarshalJSON ¶

func (w *WorkloadNetworkDNSServicesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDNSServicesList.

type WorkloadNetworkDNSZone ¶

type WorkloadNetworkDNSZone struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkDNSZoneProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkDNSZone - NSX DNS Zone

func (WorkloadNetworkDNSZone) MarshalJSON ¶

func (w WorkloadNetworkDNSZone) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDNSZone.

func (*WorkloadNetworkDNSZone) UnmarshalJSON ¶

func (w *WorkloadNetworkDNSZone) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDNSZone.

type WorkloadNetworkDNSZoneProperties ¶

type WorkloadNetworkDNSZoneProperties struct {
	// DNS Server IP array of the DNS Zone.
	DNSServerIPs []*string

	// Number of DNS Services using the DNS zone.
	DNSServices *int64

	// Display name of the DNS Zone.
	DisplayName *string

	// Domain names of the DNS Zone.
	Domain []*string

	// NSX revision number.
	Revision *int64

	// Source IP of the DNS Zone.
	SourceIP *string

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkDNSZoneProvisioningState
}

WorkloadNetworkDNSZoneProperties - NSX DNS Zone Properties

func (WorkloadNetworkDNSZoneProperties) MarshalJSON ¶

func (w WorkloadNetworkDNSZoneProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDNSZoneProperties.

func (*WorkloadNetworkDNSZoneProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkDNSZoneProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDNSZoneProperties.

type WorkloadNetworkDNSZoneProvisioningState ¶

type WorkloadNetworkDNSZoneProvisioningState string

WorkloadNetworkDNSZoneProvisioningState - Workload Network DNS Zone provisioning state

const (
	// WorkloadNetworkDNSZoneProvisioningStateBuilding - is building
	WorkloadNetworkDNSZoneProvisioningStateBuilding WorkloadNetworkDNSZoneProvisioningState = "Building"
	// WorkloadNetworkDNSZoneProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkDNSZoneProvisioningStateCanceled WorkloadNetworkDNSZoneProvisioningState = "Canceled"
	// WorkloadNetworkDNSZoneProvisioningStateDeleting - is deleting
	WorkloadNetworkDNSZoneProvisioningStateDeleting WorkloadNetworkDNSZoneProvisioningState = "Deleting"
	// WorkloadNetworkDNSZoneProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkDNSZoneProvisioningStateFailed WorkloadNetworkDNSZoneProvisioningState = "Failed"
	// WorkloadNetworkDNSZoneProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkDNSZoneProvisioningStateSucceeded WorkloadNetworkDNSZoneProvisioningState = "Succeeded"
	// WorkloadNetworkDNSZoneProvisioningStateUpdating - is updating
	WorkloadNetworkDNSZoneProvisioningStateUpdating WorkloadNetworkDNSZoneProvisioningState = "Updating"
)

func PossibleWorkloadNetworkDNSZoneProvisioningStateValues ¶

func PossibleWorkloadNetworkDNSZoneProvisioningStateValues() []WorkloadNetworkDNSZoneProvisioningState

PossibleWorkloadNetworkDNSZoneProvisioningStateValues returns the possible values for the WorkloadNetworkDNSZoneProvisioningState const type.

type WorkloadNetworkDNSZonesList ¶

type WorkloadNetworkDNSZonesList struct {
	// REQUIRED; The WorkloadNetworkDnsZone items on this page
	Value []*WorkloadNetworkDNSZone

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkDNSZonesList - The response of a WorkloadNetworkDnsZone list operation.

func (WorkloadNetworkDNSZonesList) MarshalJSON ¶

func (w WorkloadNetworkDNSZonesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDNSZonesList.

func (*WorkloadNetworkDNSZonesList) UnmarshalJSON ¶

func (w *WorkloadNetworkDNSZonesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDNSZonesList.

type WorkloadNetworkDhcp ¶

type WorkloadNetworkDhcp struct {
	// The resource-specific properties for this resource.
	Properties WorkloadNetworkDhcpEntityClassification

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkDhcp - NSX DHCP

func (WorkloadNetworkDhcp) MarshalJSON ¶

func (w WorkloadNetworkDhcp) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDhcp.

func (*WorkloadNetworkDhcp) UnmarshalJSON ¶

func (w *WorkloadNetworkDhcp) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDhcp.

type WorkloadNetworkDhcpEntity ¶

type WorkloadNetworkDhcpEntity struct {
	// REQUIRED; Type of DHCP: SERVER or RELAY.
	DhcpType *DhcpTypeEnum

	// Display name of the DHCP entity.
	DisplayName *string

	// NSX revision number.
	Revision *int64

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkDhcpProvisioningState

	// READ-ONLY; NSX Segments consuming DHCP.
	Segments []*string
}

WorkloadNetworkDhcpEntity - Base class for WorkloadNetworkDhcpServer and WorkloadNetworkDhcpRelay to inherit from

func (*WorkloadNetworkDhcpEntity) GetWorkloadNetworkDhcpEntity ¶

func (w *WorkloadNetworkDhcpEntity) GetWorkloadNetworkDhcpEntity() *WorkloadNetworkDhcpEntity

GetWorkloadNetworkDhcpEntity implements the WorkloadNetworkDhcpEntityClassification interface for type WorkloadNetworkDhcpEntity.

func (WorkloadNetworkDhcpEntity) MarshalJSON ¶

func (w WorkloadNetworkDhcpEntity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDhcpEntity.

func (*WorkloadNetworkDhcpEntity) UnmarshalJSON ¶

func (w *WorkloadNetworkDhcpEntity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDhcpEntity.

type WorkloadNetworkDhcpEntityClassification ¶

type WorkloadNetworkDhcpEntityClassification interface {
	// GetWorkloadNetworkDhcpEntity returns the WorkloadNetworkDhcpEntity content of the underlying type.
	GetWorkloadNetworkDhcpEntity() *WorkloadNetworkDhcpEntity
}

WorkloadNetworkDhcpEntityClassification provides polymorphic access to related types. Call the interface's GetWorkloadNetworkDhcpEntity() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *WorkloadNetworkDhcpEntity, *WorkloadNetworkDhcpRelay, *WorkloadNetworkDhcpServer

type WorkloadNetworkDhcpList ¶

type WorkloadNetworkDhcpList struct {
	// REQUIRED; The WorkloadNetworkDhcp items on this page
	Value []*WorkloadNetworkDhcp

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkDhcpList - The response of a WorkloadNetworkDhcp list operation.

func (WorkloadNetworkDhcpList) MarshalJSON ¶

func (w WorkloadNetworkDhcpList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDhcpList.

func (*WorkloadNetworkDhcpList) UnmarshalJSON ¶

func (w *WorkloadNetworkDhcpList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDhcpList.

type WorkloadNetworkDhcpProvisioningState ¶

type WorkloadNetworkDhcpProvisioningState string

WorkloadNetworkDhcpProvisioningState - Workload Network DHCP provisioning state

const (
	// WorkloadNetworkDhcpProvisioningStateBuilding - is building
	WorkloadNetworkDhcpProvisioningStateBuilding WorkloadNetworkDhcpProvisioningState = "Building"
	// WorkloadNetworkDhcpProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkDhcpProvisioningStateCanceled WorkloadNetworkDhcpProvisioningState = "Canceled"
	// WorkloadNetworkDhcpProvisioningStateDeleting - is deleting
	WorkloadNetworkDhcpProvisioningStateDeleting WorkloadNetworkDhcpProvisioningState = "Deleting"
	// WorkloadNetworkDhcpProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkDhcpProvisioningStateFailed WorkloadNetworkDhcpProvisioningState = "Failed"
	// WorkloadNetworkDhcpProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkDhcpProvisioningStateSucceeded WorkloadNetworkDhcpProvisioningState = "Succeeded"
	// WorkloadNetworkDhcpProvisioningStateUpdating - is updating
	WorkloadNetworkDhcpProvisioningStateUpdating WorkloadNetworkDhcpProvisioningState = "Updating"
)

func PossibleWorkloadNetworkDhcpProvisioningStateValues ¶

func PossibleWorkloadNetworkDhcpProvisioningStateValues() []WorkloadNetworkDhcpProvisioningState

PossibleWorkloadNetworkDhcpProvisioningStateValues returns the possible values for the WorkloadNetworkDhcpProvisioningState const type.

type WorkloadNetworkDhcpRelay ¶

type WorkloadNetworkDhcpRelay struct {
	// CONSTANT; Type of DHCP: SERVER or RELAY.
	// Field has constant value DhcpTypeEnumRELAY, any specified value is ignored.
	DhcpType *DhcpTypeEnum

	// Display name of the DHCP entity.
	DisplayName *string

	// NSX revision number.
	Revision *int64

	// DHCP Relay Addresses. Max 3.
	ServerAddresses []*string

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkDhcpProvisioningState

	// READ-ONLY; NSX Segments consuming DHCP.
	Segments []*string
}

WorkloadNetworkDhcpRelay - NSX DHCP Relay

func (*WorkloadNetworkDhcpRelay) GetWorkloadNetworkDhcpEntity ¶

func (w *WorkloadNetworkDhcpRelay) GetWorkloadNetworkDhcpEntity() *WorkloadNetworkDhcpEntity

GetWorkloadNetworkDhcpEntity implements the WorkloadNetworkDhcpEntityClassification interface for type WorkloadNetworkDhcpRelay.

func (WorkloadNetworkDhcpRelay) MarshalJSON ¶

func (w WorkloadNetworkDhcpRelay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDhcpRelay.

func (*WorkloadNetworkDhcpRelay) UnmarshalJSON ¶

func (w *WorkloadNetworkDhcpRelay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDhcpRelay.

type WorkloadNetworkDhcpServer ¶

type WorkloadNetworkDhcpServer struct {
	// CONSTANT; Type of DHCP: SERVER or RELAY.
	// Field has constant value DhcpTypeEnumSERVER, any specified value is ignored.
	DhcpType *DhcpTypeEnum

	// Display name of the DHCP entity.
	DisplayName *string

	// DHCP Server Lease Time.
	LeaseTime *int64

	// NSX revision number.
	Revision *int64

	// DHCP Server Address.
	ServerAddress *string

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkDhcpProvisioningState

	// READ-ONLY; NSX Segments consuming DHCP.
	Segments []*string
}

WorkloadNetworkDhcpServer - NSX DHCP Server

func (*WorkloadNetworkDhcpServer) GetWorkloadNetworkDhcpEntity ¶

func (w *WorkloadNetworkDhcpServer) GetWorkloadNetworkDhcpEntity() *WorkloadNetworkDhcpEntity

GetWorkloadNetworkDhcpEntity implements the WorkloadNetworkDhcpEntityClassification interface for type WorkloadNetworkDhcpServer.

func (WorkloadNetworkDhcpServer) MarshalJSON ¶

func (w WorkloadNetworkDhcpServer) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkDhcpServer.

func (*WorkloadNetworkDhcpServer) UnmarshalJSON ¶

func (w *WorkloadNetworkDhcpServer) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkDhcpServer.

type WorkloadNetworkGateway ¶

type WorkloadNetworkGateway struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkGatewayProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkGateway - NSX Gateway.

func (WorkloadNetworkGateway) MarshalJSON ¶

func (w WorkloadNetworkGateway) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkGateway.

func (*WorkloadNetworkGateway) UnmarshalJSON ¶

func (w *WorkloadNetworkGateway) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkGateway.

type WorkloadNetworkGatewayList ¶

type WorkloadNetworkGatewayList struct {
	// REQUIRED; The WorkloadNetworkGateway items on this page
	Value []*WorkloadNetworkGateway

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkGatewayList - The response of a WorkloadNetworkGateway list operation.

func (WorkloadNetworkGatewayList) MarshalJSON ¶

func (w WorkloadNetworkGatewayList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkGatewayList.

func (*WorkloadNetworkGatewayList) UnmarshalJSON ¶

func (w *WorkloadNetworkGatewayList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkGatewayList.

type WorkloadNetworkGatewayProperties ¶

type WorkloadNetworkGatewayProperties struct {
	// Display name of the DHCP entity.
	DisplayName *string

	// READ-ONLY; NSX Gateway Path.
	Path *string

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

WorkloadNetworkGatewayProperties - Properties of a NSX Gateway.

func (WorkloadNetworkGatewayProperties) MarshalJSON ¶

func (w WorkloadNetworkGatewayProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkGatewayProperties.

func (*WorkloadNetworkGatewayProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkGatewayProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkGatewayProperties.

type WorkloadNetworkList ¶

type WorkloadNetworkList struct {
	// REQUIRED; The WorkloadNetwork items on this page
	Value []*WorkloadNetwork

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkList - The response of a WorkloadNetwork list operation.

func (WorkloadNetworkList) MarshalJSON ¶

func (w WorkloadNetworkList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkList.

func (*WorkloadNetworkList) UnmarshalJSON ¶

func (w *WorkloadNetworkList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkList.

type WorkloadNetworkPortMirroring ¶

type WorkloadNetworkPortMirroring struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkPortMirroringProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkPortMirroring - NSX Port Mirroring

func (WorkloadNetworkPortMirroring) MarshalJSON ¶

func (w WorkloadNetworkPortMirroring) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkPortMirroring.

func (*WorkloadNetworkPortMirroring) UnmarshalJSON ¶

func (w *WorkloadNetworkPortMirroring) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkPortMirroring.

type WorkloadNetworkPortMirroringList ¶

type WorkloadNetworkPortMirroringList struct {
	// REQUIRED; The WorkloadNetworkPortMirroring items on this page
	Value []*WorkloadNetworkPortMirroring

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkPortMirroringList - The response of a WorkloadNetworkPortMirroring list operation.

func (WorkloadNetworkPortMirroringList) MarshalJSON ¶

func (w WorkloadNetworkPortMirroringList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkPortMirroringList.

func (*WorkloadNetworkPortMirroringList) UnmarshalJSON ¶

func (w *WorkloadNetworkPortMirroringList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkPortMirroringList.

type WorkloadNetworkPortMirroringProperties ¶

type WorkloadNetworkPortMirroringProperties struct {
	// Destination VM Group.
	Destination *string

	// Direction of port mirroring profile.
	Direction *PortMirroringDirectionEnum

	// Display name of the port mirroring profile.
	DisplayName *string

	// NSX revision number.
	Revision *int64

	// Source VM Group.
	Source *string

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkPortMirroringProvisioningState

	// READ-ONLY; Port Mirroring Status.
	Status *PortMirroringStatusEnum
}

WorkloadNetworkPortMirroringProperties - NSX Port Mirroring Properties

func (WorkloadNetworkPortMirroringProperties) MarshalJSON ¶

func (w WorkloadNetworkPortMirroringProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkPortMirroringProperties.

func (*WorkloadNetworkPortMirroringProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkPortMirroringProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkPortMirroringProperties.

type WorkloadNetworkPortMirroringProvisioningState ¶

type WorkloadNetworkPortMirroringProvisioningState string

WorkloadNetworkPortMirroringProvisioningState - Workload Network Port Mirroring provisioning state

const (
	// WorkloadNetworkPortMirroringProvisioningStateBuilding - is building
	WorkloadNetworkPortMirroringProvisioningStateBuilding WorkloadNetworkPortMirroringProvisioningState = "Building"
	// WorkloadNetworkPortMirroringProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkPortMirroringProvisioningStateCanceled WorkloadNetworkPortMirroringProvisioningState = "Canceled"
	// WorkloadNetworkPortMirroringProvisioningStateDeleting - is deleting
	WorkloadNetworkPortMirroringProvisioningStateDeleting WorkloadNetworkPortMirroringProvisioningState = "Deleting"
	// WorkloadNetworkPortMirroringProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkPortMirroringProvisioningStateFailed WorkloadNetworkPortMirroringProvisioningState = "Failed"
	// WorkloadNetworkPortMirroringProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkPortMirroringProvisioningStateSucceeded WorkloadNetworkPortMirroringProvisioningState = "Succeeded"
	// WorkloadNetworkPortMirroringProvisioningStateUpdating - is updating
	WorkloadNetworkPortMirroringProvisioningStateUpdating WorkloadNetworkPortMirroringProvisioningState = "Updating"
)

func PossibleWorkloadNetworkPortMirroringProvisioningStateValues ¶

func PossibleWorkloadNetworkPortMirroringProvisioningStateValues() []WorkloadNetworkPortMirroringProvisioningState

PossibleWorkloadNetworkPortMirroringProvisioningStateValues returns the possible values for the WorkloadNetworkPortMirroringProvisioningState const type.

type WorkloadNetworkProperties ¶

type WorkloadNetworkProperties struct {
	// READ-ONLY; The provisioning state of the resource.
	ProvisioningState *WorkloadNetworkProvisioningState
}

WorkloadNetworkProperties - The properties of a workload network

func (WorkloadNetworkProperties) MarshalJSON ¶

func (w WorkloadNetworkProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkProperties.

func (*WorkloadNetworkProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkProperties.

type WorkloadNetworkProvisioningState ¶

type WorkloadNetworkProvisioningState string

WorkloadNetworkProvisioningState - base Workload Network provisioning state

const (
	// WorkloadNetworkProvisioningStateBuilding - is building
	WorkloadNetworkProvisioningStateBuilding WorkloadNetworkProvisioningState = "Building"
	// WorkloadNetworkProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkProvisioningStateCanceled WorkloadNetworkProvisioningState = "Canceled"
	// WorkloadNetworkProvisioningStateDeleting - is deleting
	WorkloadNetworkProvisioningStateDeleting WorkloadNetworkProvisioningState = "Deleting"
	// WorkloadNetworkProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkProvisioningStateFailed WorkloadNetworkProvisioningState = "Failed"
	// WorkloadNetworkProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkProvisioningStateSucceeded WorkloadNetworkProvisioningState = "Succeeded"
	// WorkloadNetworkProvisioningStateUpdating - is updating
	WorkloadNetworkProvisioningStateUpdating WorkloadNetworkProvisioningState = "Updating"
)

func PossibleWorkloadNetworkProvisioningStateValues ¶

func PossibleWorkloadNetworkProvisioningStateValues() []WorkloadNetworkProvisioningState

PossibleWorkloadNetworkProvisioningStateValues returns the possible values for the WorkloadNetworkProvisioningState const type.

type WorkloadNetworkPublicIP ¶

type WorkloadNetworkPublicIP struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkPublicIPProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkPublicIP - NSX Public IP Block

func (WorkloadNetworkPublicIP) MarshalJSON ¶

func (w WorkloadNetworkPublicIP) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkPublicIP.

func (*WorkloadNetworkPublicIP) UnmarshalJSON ¶

func (w *WorkloadNetworkPublicIP) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkPublicIP.

type WorkloadNetworkPublicIPProperties ¶

type WorkloadNetworkPublicIPProperties struct {
	// Display name of the Public IP Block.
	DisplayName *string

	// Number of Public IPs requested.
	NumberOfPublicIPs *int64

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkPublicIPProvisioningState

	// READ-ONLY; CIDR Block of the Public IP Block.
	PublicIPBlock *string
}

WorkloadNetworkPublicIPProperties - NSX Public IP Block Properties

func (WorkloadNetworkPublicIPProperties) MarshalJSON ¶

func (w WorkloadNetworkPublicIPProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkPublicIPProperties.

func (*WorkloadNetworkPublicIPProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkPublicIPProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkPublicIPProperties.

type WorkloadNetworkPublicIPProvisioningState ¶

type WorkloadNetworkPublicIPProvisioningState string

WorkloadNetworkPublicIPProvisioningState - Workload Network Public IP provisioning state

const (
	// WorkloadNetworkPublicIPProvisioningStateBuilding - is building
	WorkloadNetworkPublicIPProvisioningStateBuilding WorkloadNetworkPublicIPProvisioningState = "Building"
	// WorkloadNetworkPublicIPProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkPublicIPProvisioningStateCanceled WorkloadNetworkPublicIPProvisioningState = "Canceled"
	// WorkloadNetworkPublicIPProvisioningStateDeleting - is deleting
	WorkloadNetworkPublicIPProvisioningStateDeleting WorkloadNetworkPublicIPProvisioningState = "Deleting"
	// WorkloadNetworkPublicIPProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkPublicIPProvisioningStateFailed WorkloadNetworkPublicIPProvisioningState = "Failed"
	// WorkloadNetworkPublicIPProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkPublicIPProvisioningStateSucceeded WorkloadNetworkPublicIPProvisioningState = "Succeeded"
	// WorkloadNetworkPublicIPProvisioningStateUpdating - is updating
	WorkloadNetworkPublicIPProvisioningStateUpdating WorkloadNetworkPublicIPProvisioningState = "Updating"
)

func PossibleWorkloadNetworkPublicIPProvisioningStateValues ¶

func PossibleWorkloadNetworkPublicIPProvisioningStateValues() []WorkloadNetworkPublicIPProvisioningState

PossibleWorkloadNetworkPublicIPProvisioningStateValues returns the possible values for the WorkloadNetworkPublicIPProvisioningState const type.

type WorkloadNetworkPublicIPsList ¶

type WorkloadNetworkPublicIPsList struct {
	// REQUIRED; The WorkloadNetworkPublicIP items on this page
	Value []*WorkloadNetworkPublicIP

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkPublicIPsList - The response of a WorkloadNetworkPublicIP list operation.

func (WorkloadNetworkPublicIPsList) MarshalJSON ¶

func (w WorkloadNetworkPublicIPsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkPublicIPsList.

func (*WorkloadNetworkPublicIPsList) UnmarshalJSON ¶

func (w *WorkloadNetworkPublicIPsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkPublicIPsList.

type WorkloadNetworkSegment ¶

type WorkloadNetworkSegment struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkSegmentProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkSegment - NSX Segment

func (WorkloadNetworkSegment) MarshalJSON ¶

func (w WorkloadNetworkSegment) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkSegment.

func (*WorkloadNetworkSegment) UnmarshalJSON ¶

func (w *WorkloadNetworkSegment) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkSegment.

type WorkloadNetworkSegmentPortVif ¶

type WorkloadNetworkSegmentPortVif struct {
	// Name of port or VIF attached to segment.
	PortName *string
}

WorkloadNetworkSegmentPortVif - Ports and any VIF attached to segment.

func (WorkloadNetworkSegmentPortVif) MarshalJSON ¶

func (w WorkloadNetworkSegmentPortVif) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkSegmentPortVif.

func (*WorkloadNetworkSegmentPortVif) UnmarshalJSON ¶

func (w *WorkloadNetworkSegmentPortVif) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkSegmentPortVif.

type WorkloadNetworkSegmentProperties ¶

type WorkloadNetworkSegmentProperties struct {
	// Gateway which to connect segment to.
	ConnectedGateway *string

	// Display name of the segment.
	DisplayName *string

	// NSX revision number.
	Revision *int64

	// Subnet which to connect segment to.
	Subnet *WorkloadNetworkSegmentSubnet

	// READ-ONLY; Port Vif which segment is associated with.
	PortVif []*WorkloadNetworkSegmentPortVif

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkSegmentProvisioningState

	// READ-ONLY; Segment status.
	Status *SegmentStatusEnum
}

WorkloadNetworkSegmentProperties - NSX Segment Properties

func (WorkloadNetworkSegmentProperties) MarshalJSON ¶

func (w WorkloadNetworkSegmentProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkSegmentProperties.

func (*WorkloadNetworkSegmentProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkSegmentProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkSegmentProperties.

type WorkloadNetworkSegmentProvisioningState ¶

type WorkloadNetworkSegmentProvisioningState string

WorkloadNetworkSegmentProvisioningState - Workload Network Segment provisioning state

const (
	// WorkloadNetworkSegmentProvisioningStateBuilding - is building
	WorkloadNetworkSegmentProvisioningStateBuilding WorkloadNetworkSegmentProvisioningState = "Building"
	// WorkloadNetworkSegmentProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkSegmentProvisioningStateCanceled WorkloadNetworkSegmentProvisioningState = "Canceled"
	// WorkloadNetworkSegmentProvisioningStateDeleting - is deleting
	WorkloadNetworkSegmentProvisioningStateDeleting WorkloadNetworkSegmentProvisioningState = "Deleting"
	// WorkloadNetworkSegmentProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkSegmentProvisioningStateFailed WorkloadNetworkSegmentProvisioningState = "Failed"
	// WorkloadNetworkSegmentProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkSegmentProvisioningStateSucceeded WorkloadNetworkSegmentProvisioningState = "Succeeded"
	// WorkloadNetworkSegmentProvisioningStateUpdating - is updating
	WorkloadNetworkSegmentProvisioningStateUpdating WorkloadNetworkSegmentProvisioningState = "Updating"
)

func PossibleWorkloadNetworkSegmentProvisioningStateValues ¶

func PossibleWorkloadNetworkSegmentProvisioningStateValues() []WorkloadNetworkSegmentProvisioningState

PossibleWorkloadNetworkSegmentProvisioningStateValues returns the possible values for the WorkloadNetworkSegmentProvisioningState const type.

type WorkloadNetworkSegmentSubnet ¶

type WorkloadNetworkSegmentSubnet struct {
	// DHCP Range assigned for subnet.
	DhcpRanges []*string

	// Gateway address.
	GatewayAddress *string
}

WorkloadNetworkSegmentSubnet - Subnet configuration for segment

func (WorkloadNetworkSegmentSubnet) MarshalJSON ¶

func (w WorkloadNetworkSegmentSubnet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkSegmentSubnet.

func (*WorkloadNetworkSegmentSubnet) UnmarshalJSON ¶

func (w *WorkloadNetworkSegmentSubnet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkSegmentSubnet.

type WorkloadNetworkSegmentsList ¶

type WorkloadNetworkSegmentsList struct {
	// REQUIRED; The WorkloadNetworkSegment items on this page
	Value []*WorkloadNetworkSegment

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkSegmentsList - The response of a WorkloadNetworkSegment list operation.

func (WorkloadNetworkSegmentsList) MarshalJSON ¶

func (w WorkloadNetworkSegmentsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkSegmentsList.

func (*WorkloadNetworkSegmentsList) UnmarshalJSON ¶

func (w *WorkloadNetworkSegmentsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkSegmentsList.

type WorkloadNetworkVMGroup ¶

type WorkloadNetworkVMGroup struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkVMGroupProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkVMGroup - NSX VM Group

func (WorkloadNetworkVMGroup) MarshalJSON ¶

func (w WorkloadNetworkVMGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkVMGroup.

func (*WorkloadNetworkVMGroup) UnmarshalJSON ¶

func (w *WorkloadNetworkVMGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkVMGroup.

type WorkloadNetworkVMGroupProperties ¶

type WorkloadNetworkVMGroupProperties struct {
	// Display name of the VM group.
	DisplayName *string

	// Virtual machine members of this group.
	Members []*string

	// NSX revision number.
	Revision *int64

	// READ-ONLY; The provisioning state
	ProvisioningState *WorkloadNetworkVMGroupProvisioningState

	// READ-ONLY; VM Group status.
	Status *VMGroupStatusEnum
}

WorkloadNetworkVMGroupProperties - NSX VM Group Properties

func (WorkloadNetworkVMGroupProperties) MarshalJSON ¶

func (w WorkloadNetworkVMGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkVMGroupProperties.

func (*WorkloadNetworkVMGroupProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkVMGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkVMGroupProperties.

type WorkloadNetworkVMGroupProvisioningState ¶

type WorkloadNetworkVMGroupProvisioningState string

WorkloadNetworkVMGroupProvisioningState - Workload Network VM Group provisioning state

const (
	// WorkloadNetworkVMGroupProvisioningStateBuilding - is building
	WorkloadNetworkVMGroupProvisioningStateBuilding WorkloadNetworkVMGroupProvisioningState = "Building"
	// WorkloadNetworkVMGroupProvisioningStateCanceled - Resource creation was canceled.
	WorkloadNetworkVMGroupProvisioningStateCanceled WorkloadNetworkVMGroupProvisioningState = "Canceled"
	// WorkloadNetworkVMGroupProvisioningStateDeleting - is deleting
	WorkloadNetworkVMGroupProvisioningStateDeleting WorkloadNetworkVMGroupProvisioningState = "Deleting"
	// WorkloadNetworkVMGroupProvisioningStateFailed - Resource creation failed.
	WorkloadNetworkVMGroupProvisioningStateFailed WorkloadNetworkVMGroupProvisioningState = "Failed"
	// WorkloadNetworkVMGroupProvisioningStateSucceeded - Resource has been created.
	WorkloadNetworkVMGroupProvisioningStateSucceeded WorkloadNetworkVMGroupProvisioningState = "Succeeded"
	// WorkloadNetworkVMGroupProvisioningStateUpdating - is updating
	WorkloadNetworkVMGroupProvisioningStateUpdating WorkloadNetworkVMGroupProvisioningState = "Updating"
)

func PossibleWorkloadNetworkVMGroupProvisioningStateValues ¶

func PossibleWorkloadNetworkVMGroupProvisioningStateValues() []WorkloadNetworkVMGroupProvisioningState

PossibleWorkloadNetworkVMGroupProvisioningStateValues returns the possible values for the WorkloadNetworkVMGroupProvisioningState const type.

type WorkloadNetworkVMGroupsList ¶

type WorkloadNetworkVMGroupsList struct {
	// REQUIRED; The WorkloadNetworkVMGroup items on this page
	Value []*WorkloadNetworkVMGroup

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkVMGroupsList - The response of a WorkloadNetworkVMGroup list operation.

func (WorkloadNetworkVMGroupsList) MarshalJSON ¶

func (w WorkloadNetworkVMGroupsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkVMGroupsList.

func (*WorkloadNetworkVMGroupsList) UnmarshalJSON ¶

func (w *WorkloadNetworkVMGroupsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkVMGroupsList.

type WorkloadNetworkVirtualMachine ¶

type WorkloadNetworkVirtualMachine struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkVirtualMachineProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /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
}

WorkloadNetworkVirtualMachine - NSX Virtual Machine

func (WorkloadNetworkVirtualMachine) MarshalJSON ¶

func (w WorkloadNetworkVirtualMachine) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkVirtualMachine.

func (*WorkloadNetworkVirtualMachine) UnmarshalJSON ¶

func (w *WorkloadNetworkVirtualMachine) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkVirtualMachine.

type WorkloadNetworkVirtualMachineProperties ¶

type WorkloadNetworkVirtualMachineProperties struct {
	// Display name of the VM.
	DisplayName *string

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

	// READ-ONLY; Virtual machine type.
	VMType *VMTypeEnum
}

WorkloadNetworkVirtualMachineProperties - NSX Virtual Machine Properties

func (WorkloadNetworkVirtualMachineProperties) MarshalJSON ¶

func (w WorkloadNetworkVirtualMachineProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkVirtualMachineProperties.

func (*WorkloadNetworkVirtualMachineProperties) UnmarshalJSON ¶

func (w *WorkloadNetworkVirtualMachineProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkVirtualMachineProperties.

type WorkloadNetworkVirtualMachinesList ¶

type WorkloadNetworkVirtualMachinesList struct {
	// REQUIRED; The WorkloadNetworkVirtualMachine items on this page
	Value []*WorkloadNetworkVirtualMachine

	// The link to the next page of items
	NextLink *string
}

WorkloadNetworkVirtualMachinesList - The response of a WorkloadNetworkVirtualMachine list operation.

func (WorkloadNetworkVirtualMachinesList) MarshalJSON ¶

func (w WorkloadNetworkVirtualMachinesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkloadNetworkVirtualMachinesList.

func (*WorkloadNetworkVirtualMachinesList) UnmarshalJSON ¶

func (w *WorkloadNetworkVirtualMachinesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkloadNetworkVirtualMachinesList.

type WorkloadNetworksClient ¶

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

WorkloadNetworksClient contains the methods for the WorkloadNetworks group. Don't use this type directly, use NewWorkloadNetworksClient() instead.

Generated from API version 2026-03-01

func NewWorkloadNetworksClient ¶

func NewWorkloadNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*WorkloadNetworksClient, error)

NewWorkloadNetworksClient creates a new instance of WorkloadNetworksClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*WorkloadNetworksClient) BeginCreateDNSService ¶

func (client *WorkloadNetworksClient) BeginCreateDNSService(ctx context.Context, resourceGroupName string, privateCloudName string, dnsServiceID string, workloadNetworkDNSService WorkloadNetworkDNSService, options *WorkloadNetworksClientBeginCreateDNSServiceOptions) (*runtime.Poller[WorkloadNetworksClientCreateDNSServiceResponse], error)

BeginCreateDNSService - Create a WorkloadNetworkDnsService If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dnsServiceID - ID of the DNS service.
workloadNetworkDNSService - Resource create parameters.
options - WorkloadNetworksClientBeginCreateDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDNSService method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreateDnsService.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreateDNSService(ctx, "group1", "cloud1", "dnsService1", armavs.WorkloadNetworkDNSService{
		Properties: &armavs.WorkloadNetworkDNSServiceProperties{
			DisplayName:    to.Ptr("dnsService1"),
			DNSServiceIP:   to.Ptr("5.5.5.5"),
			DefaultDNSZone: to.Ptr("defaultDnsZone1"),
			FqdnZones: []*string{
				to.Ptr("fqdnZone1"),
			},
			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreateDNSServiceResponse{
	// 	WorkloadNetworkDNSService: armavs.WorkloadNetworkDNSService{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
	// 		Name: to.Ptr("dnsService1"),
	// 		Properties: &armavs.WorkloadNetworkDNSServiceProperties{
	// 			DisplayName: to.Ptr("dnsService1"),
	// 			DNSServiceIP: to.Ptr("5.5.5.5"),
	// 			DefaultDNSZone: to.Ptr("defaultDnsZone1"),
	// 			FqdnZones: []*string{
	// 				to.Ptr("fqdnZone1"),
	// 			},
	// 			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
	// 			Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginCreateDNSZone ¶

func (client *WorkloadNetworksClient) BeginCreateDNSZone(ctx context.Context, resourceGroupName string, privateCloudName string, dnsZoneID string, workloadNetworkDNSZone WorkloadNetworkDNSZone, options *WorkloadNetworksClientBeginCreateDNSZoneOptions) (*runtime.Poller[WorkloadNetworksClientCreateDNSZoneResponse], error)

BeginCreateDNSZone - Create a WorkloadNetworkDnsZone If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dnsZoneID - ID of the DNS zone.
workloadNetworkDNSZone - Resource create parameters.
options - WorkloadNetworksClientBeginCreateDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDNSZone method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreateDnsZone.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreateDNSZone(ctx, "group1", "cloud1", "dnsZone1", armavs.WorkloadNetworkDNSZone{
		Properties: &armavs.WorkloadNetworkDNSZoneProperties{
			DisplayName: to.Ptr("dnsZone1"),
			Domain:      []*string{},
			DNSServerIPs: []*string{
				to.Ptr("1.1.1.1"),
			},
			SourceIP: to.Ptr("8.8.8.8"),
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreateDNSZoneResponse{
	// 	WorkloadNetworkDNSZone: armavs.WorkloadNetworkDNSZone{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
	// 		Name: to.Ptr("dnsZone1"),
	// 		Properties: &armavs.WorkloadNetworkDNSZoneProperties{
	// 			DisplayName: to.Ptr("dnsZone1"),
	// 			Domain: []*string{
	// 			},
	// 			DNSServerIPs: []*string{
	// 				to.Ptr("1.1.1.1"),
	// 			},
	// 			SourceIP: to.Ptr("8.8.8.8"),
	// 			DNSServices: to.Ptr[int64](0),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginCreateDhcp ¶

func (client *WorkloadNetworksClient) BeginCreateDhcp(ctx context.Context, resourceGroupName string, privateCloudName string, dhcpID string, workloadNetworkDhcp WorkloadNetworkDhcp, options *WorkloadNetworksClientBeginCreateDhcpOptions) (*runtime.Poller[WorkloadNetworksClientCreateDhcpResponse], error)

BeginCreateDhcp - Create a WorkloadNetworkDhcp If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dhcpID - The ID of the DHCP configuration
workloadNetworkDhcp - Resource create parameters.
options - WorkloadNetworksClientBeginCreateDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDhcp method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreateDhcp.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreateDhcp(ctx, "group1", "cloud1", "dhcp1", armavs.WorkloadNetworkDhcp{
		Properties: &armavs.WorkloadNetworkDhcpServer{
			DhcpType:      to.Ptr(armavs.DhcpTypeEnumSERVER),
			DisplayName:   to.Ptr("dhcpConfigurations1"),
			ServerAddress: to.Ptr("40.1.5.1/24"),
			LeaseTime:     to.Ptr[int64](86400),
			Revision:      to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreateDhcpResponse{
	// 	WorkloadNetworkDhcp: armavs.WorkloadNetworkDhcp{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
	// 		Name: to.Ptr("dhcp1"),
	// 		Properties: &armavs.WorkloadNetworkDhcpServer{
	// 			DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
	// 			DisplayName: to.Ptr("dhcpConfigurations1"),
	// 			Segments: []*string{
	// 				to.Ptr("segment1"),
	// 				to.Ptr("segment2"),
	// 			},
	// 			ServerAddress: to.Ptr("40.1.5.1/24"),
	// 			LeaseTime: to.Ptr[int64](86400),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginCreatePortMirroring ¶

func (client *WorkloadNetworksClient) BeginCreatePortMirroring(ctx context.Context, resourceGroupName string, privateCloudName string, portMirroringID string, workloadNetworkPortMirroring WorkloadNetworkPortMirroring, options *WorkloadNetworksClientBeginCreatePortMirroringOptions) (*runtime.Poller[WorkloadNetworksClientCreatePortMirroringResponse], error)

BeginCreatePortMirroring - Create a WorkloadNetworkPortMirroring If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
portMirroringID - ID of the NSX port mirroring profile.
workloadNetworkPortMirroring - Resource create parameters.
options - WorkloadNetworksClientBeginCreatePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreatePortMirroring method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreatePortMirroring.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreatePortMirroring(ctx, "group1", "cloud1", "portMirroring1", armavs.WorkloadNetworkPortMirroring{
		Properties: &armavs.WorkloadNetworkPortMirroringProperties{
			DisplayName: to.Ptr("portMirroring1"),
			Direction:   to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
			Source:      to.Ptr("vmGroup1"),
			Destination: to.Ptr("vmGroup2"),
			Revision:    to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreatePortMirroringResponse{
	// 	WorkloadNetworkPortMirroring: armavs.WorkloadNetworkPortMirroring{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
	// 		Name: to.Ptr("portMirroring1"),
	// 		Properties: &armavs.WorkloadNetworkPortMirroringProperties{
	// 			DisplayName: to.Ptr("portMirroring1"),
	// 			Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
	// 			Source: to.Ptr("vmGroup1"),
	// 			Destination: to.Ptr("vmGroup2"),
	// 			Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginCreatePublicIP ¶

func (client *WorkloadNetworksClient) BeginCreatePublicIP(ctx context.Context, resourceGroupName string, privateCloudName string, publicIPID string, workloadNetworkPublicIP WorkloadNetworkPublicIP, options *WorkloadNetworksClientBeginCreatePublicIPOptions) (*runtime.Poller[WorkloadNetworksClientCreatePublicIPResponse], error)

BeginCreatePublicIP - Create a WorkloadNetworkPublicIP If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
publicIPID - ID of the DNS zone.
workloadNetworkPublicIP - Resource create parameters.
options - WorkloadNetworksClientBeginCreatePublicIPOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreatePublicIP method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreatePublicIP.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreatePublicIP(ctx, "group1", "cloud1", "publicIP1", armavs.WorkloadNetworkPublicIP{
		Properties: &armavs.WorkloadNetworkPublicIPProperties{
			DisplayName:       to.Ptr("publicIP1"),
			NumberOfPublicIPs: to.Ptr[int64](32),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreatePublicIPResponse{
	// 	WorkloadNetworkPublicIP: armavs.WorkloadNetworkPublicIP{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/publicIPs/publicIP1"),
	// 		Name: to.Ptr("publicIP1"),
	// 		Properties: &armavs.WorkloadNetworkPublicIPProperties{
	// 			DisplayName: to.Ptr("publicIP1"),
	// 			PublicIPBlock: to.Ptr("20.20.40.50/32"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/publicIPs"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginCreateSegments ¶

func (client *WorkloadNetworksClient) BeginCreateSegments(ctx context.Context, resourceGroupName string, privateCloudName string, segmentID string, workloadNetworkSegment WorkloadNetworkSegment, options *WorkloadNetworksClientBeginCreateSegmentsOptions) (*runtime.Poller[WorkloadNetworksClientCreateSegmentsResponse], error)

BeginCreateSegments - Create a WorkloadNetworkSegment If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
segmentID - The ID of the NSX Segment
workloadNetworkSegment - Resource create parameters.
options - WorkloadNetworksClientBeginCreateSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateSegments method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreateSegments.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreateSegments(ctx, "group1", "cloud1", "segment1", armavs.WorkloadNetworkSegment{
		Properties: &armavs.WorkloadNetworkSegmentProperties{
			DisplayName:      to.Ptr("segment1"),
			ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
			Subnet: &armavs.WorkloadNetworkSegmentSubnet{
				DhcpRanges: []*string{
					to.Ptr("40.20.0.0-40.20.0.1"),
				},
				GatewayAddress: to.Ptr("40.20.20.20/16"),
			},
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreateSegmentsResponse{
	// 	WorkloadNetworkSegment: armavs.WorkloadNetworkSegment{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
	// 		Name: to.Ptr("segment1"),
	// 		Properties: &armavs.WorkloadNetworkSegmentProperties{
	// 			DisplayName: to.Ptr("segment1"),
	// 			ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
	// 			Subnet: &armavs.WorkloadNetworkSegmentSubnet{
	// 				DhcpRanges: []*string{
	// 					to.Ptr("40.20.0.0-40.20.0.1"),
	// 				},
	// 				GatewayAddress: to.Ptr("40.20.20.20/16"),
	// 			},
	// 			PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
	// 			},
	// 			Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginCreateVMGroup ¶

func (client *WorkloadNetworksClient) BeginCreateVMGroup(ctx context.Context, resourceGroupName string, privateCloudName string, vmGroupID string, workloadNetworkVMGroup WorkloadNetworkVMGroup, options *WorkloadNetworksClientBeginCreateVMGroupOptions) (*runtime.Poller[WorkloadNetworksClientCreateVMGroupResponse], error)

BeginCreateVMGroup - Create a WorkloadNetworkVMGroup If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
vmGroupID - ID of the VM group.
workloadNetworkVMGroup - Resource create parameters.
options - WorkloadNetworksClientBeginCreateVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateVMGroup method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_CreateVMGroup.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginCreateVMGroup(ctx, "group1", "cloud1", "vmGroup1", armavs.WorkloadNetworkVMGroup{
		Properties: &armavs.WorkloadNetworkVMGroupProperties{
			DisplayName: to.Ptr("vmGroup1"),
			Members: []*string{
				to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50"),
			},
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientCreateVMGroupResponse{
	// 	WorkloadNetworkVMGroup: armavs.WorkloadNetworkVMGroup{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
	// 		Name: to.Ptr("vmGroup1"),
	// 		Properties: &armavs.WorkloadNetworkVMGroupProperties{
	// 			DisplayName: to.Ptr("vmGroup1"),
	// 			Members: []*string{
	// 				to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50"),
	// 			},
	// 			Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeleteDNSService ¶

func (client *WorkloadNetworksClient) BeginDeleteDNSService(ctx context.Context, resourceGroupName string, dnsServiceID string, privateCloudName string, options *WorkloadNetworksClientBeginDeleteDNSServiceOptions) (*runtime.Poller[WorkloadNetworksClientDeleteDNSServiceResponse], error)

BeginDeleteDNSService - Delete a WorkloadNetworkDnsService If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
dnsServiceID - ID of the DNS service.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientBeginDeleteDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDNSService method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeleteDnsService.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeleteDNSService(ctx, "group1", "dnsService1", "cloud1", 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 poll 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 = armavs.WorkloadNetworksClientDeleteDNSServiceResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeleteDNSZone ¶

func (client *WorkloadNetworksClient) BeginDeleteDNSZone(ctx context.Context, resourceGroupName string, dnsZoneID string, privateCloudName string, options *WorkloadNetworksClientBeginDeleteDNSZoneOptions) (*runtime.Poller[WorkloadNetworksClientDeleteDNSZoneResponse], error)

BeginDeleteDNSZone - Delete a WorkloadNetworkDnsZone If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
dnsZoneID - ID of the DNS zone.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientBeginDeleteDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDNSZone method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeleteDnsZone.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeleteDNSZone(ctx, "group1", "dnsZone1", "cloud1", 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 poll 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 = armavs.WorkloadNetworksClientDeleteDNSZoneResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeleteDhcp ¶

func (client *WorkloadNetworksClient) BeginDeleteDhcp(ctx context.Context, resourceGroupName string, privateCloudName string, dhcpID string, options *WorkloadNetworksClientBeginDeleteDhcpOptions) (*runtime.Poller[WorkloadNetworksClientDeleteDhcpResponse], error)

BeginDeleteDhcp - Delete a WorkloadNetworkDhcp If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dhcpID - The ID of the DHCP configuration
options - WorkloadNetworksClientBeginDeleteDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDhcp method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeleteDhcp.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeleteDhcp(ctx, "group1", "cloud1", "dhcp1", 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 poll 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 = armavs.WorkloadNetworksClientDeleteDhcpResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeletePortMirroring ¶

func (client *WorkloadNetworksClient) BeginDeletePortMirroring(ctx context.Context, resourceGroupName string, portMirroringID string, privateCloudName string, options *WorkloadNetworksClientBeginDeletePortMirroringOptions) (*runtime.Poller[WorkloadNetworksClientDeletePortMirroringResponse], error)

BeginDeletePortMirroring - Delete a WorkloadNetworkPortMirroring If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
portMirroringID - ID of the NSX port mirroring profile.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientBeginDeletePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeletePortMirroring method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeletePortMirroring.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeletePortMirroring(ctx, "group1", "portMirroring1", "cloud1", 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 poll 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 = armavs.WorkloadNetworksClientDeletePortMirroringResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeletePublicIP ¶

func (client *WorkloadNetworksClient) BeginDeletePublicIP(ctx context.Context, resourceGroupName string, publicIPID string, privateCloudName string, options *WorkloadNetworksClientBeginDeletePublicIPOptions) (*runtime.Poller[WorkloadNetworksClientDeletePublicIPResponse], error)

BeginDeletePublicIP - Delete a WorkloadNetworkPublicIP If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
publicIPID - ID of the DNS zone.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientBeginDeletePublicIPOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeletePublicIP method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeletePublicIP.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeletePublicIP(ctx, "group1", "publicIP1", "cloud1", 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 poll 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 = armavs.WorkloadNetworksClientDeletePublicIPResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeleteSegment ¶

func (client *WorkloadNetworksClient) BeginDeleteSegment(ctx context.Context, resourceGroupName string, privateCloudName string, segmentID string, options *WorkloadNetworksClientBeginDeleteSegmentOptions) (*runtime.Poller[WorkloadNetworksClientDeleteSegmentResponse], error)

BeginDeleteSegment - Delete a WorkloadNetworkSegment If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
segmentID - The ID of the NSX Segment
options - WorkloadNetworksClientBeginDeleteSegmentOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteSegment method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeleteSegment.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeleteSegment(ctx, "group1", "cloud1", "segment1", 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 poll 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 = armavs.WorkloadNetworksClientDeleteSegmentResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginDeleteVMGroup ¶

func (client *WorkloadNetworksClient) BeginDeleteVMGroup(ctx context.Context, resourceGroupName string, vmGroupID string, privateCloudName string, options *WorkloadNetworksClientBeginDeleteVMGroupOptions) (*runtime.Poller[WorkloadNetworksClientDeleteVMGroupResponse], error)

BeginDeleteVMGroup - Delete a WorkloadNetworkVMGroup If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
vmGroupID - ID of the VM group.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientBeginDeleteVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteVMGroup method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_DeleteVMGroup.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginDeleteVMGroup(ctx, "group1", "vmGroup1", "cloud1", 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 poll 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 = armavs.WorkloadNetworksClientDeleteVMGroupResponse{
	// }
}

Output:

func (*WorkloadNetworksClient) BeginUpdateDNSService ¶

func (client *WorkloadNetworksClient) BeginUpdateDNSService(ctx context.Context, resourceGroupName string, privateCloudName string, dnsServiceID string, workloadNetworkDNSService WorkloadNetworkDNSService, options *WorkloadNetworksClientBeginUpdateDNSServiceOptions) (*runtime.Poller[WorkloadNetworksClientUpdateDNSServiceResponse], error)

BeginUpdateDNSService - Update a WorkloadNetworkDnsService If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dnsServiceID - ID of the DNS service.
workloadNetworkDNSService - The resource properties to be updated.
options - WorkloadNetworksClientBeginUpdateDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDNSService method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_UpdateDnsService.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginUpdateDNSService(ctx, "group1", "cloud1", "dnsService1", armavs.WorkloadNetworkDNSService{
		Properties: &armavs.WorkloadNetworkDNSServiceProperties{
			DisplayName:    to.Ptr("dnsService1"),
			DNSServiceIP:   to.Ptr("5.5.5.5"),
			DefaultDNSZone: to.Ptr("defaultDnsZone1"),
			FqdnZones: []*string{
				to.Ptr("fqdnZone1"),
			},
			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientUpdateDNSServiceResponse{
	// 	WorkloadNetworkDNSService: armavs.WorkloadNetworkDNSService{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
	// 		Name: to.Ptr("dnsService1"),
	// 		Properties: &armavs.WorkloadNetworkDNSServiceProperties{
	// 			DisplayName: to.Ptr("dnsService1"),
	// 			DNSServiceIP: to.Ptr("5.5.5.5"),
	// 			DefaultDNSZone: to.Ptr("defaultDnsZone1"),
	// 			FqdnZones: []*string{
	// 				to.Ptr("fqdnZone1"),
	// 			},
	// 			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
	// 			Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginUpdateDNSZone ¶

func (client *WorkloadNetworksClient) BeginUpdateDNSZone(ctx context.Context, resourceGroupName string, privateCloudName string, dnsZoneID string, workloadNetworkDNSZone WorkloadNetworkDNSZone, options *WorkloadNetworksClientBeginUpdateDNSZoneOptions) (*runtime.Poller[WorkloadNetworksClientUpdateDNSZoneResponse], error)

BeginUpdateDNSZone - Update a WorkloadNetworkDnsZone If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dnsZoneID - ID of the DNS zone.
workloadNetworkDNSZone - The resource properties to be updated.
options - WorkloadNetworksClientBeginUpdateDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDNSZone method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_UpdateDnsZone.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginUpdateDNSZone(ctx, "group1", "cloud1", "dnsZone1", armavs.WorkloadNetworkDNSZone{
		Properties: &armavs.WorkloadNetworkDNSZoneProperties{
			DisplayName: to.Ptr("dnsZone1"),
			Domain:      []*string{},
			DNSServerIPs: []*string{
				to.Ptr("1.1.1.1"),
			},
			SourceIP: to.Ptr("8.8.8.8"),
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientUpdateDNSZoneResponse{
	// 	WorkloadNetworkDNSZone: armavs.WorkloadNetworkDNSZone{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
	// 		Name: to.Ptr("dnsZone1"),
	// 		Properties: &armavs.WorkloadNetworkDNSZoneProperties{
	// 			DisplayName: to.Ptr("dnsZone1"),
	// 			Domain: []*string{
	// 			},
	// 			DNSServerIPs: []*string{
	// 				to.Ptr("1.1.1.1"),
	// 			},
	// 			SourceIP: to.Ptr("8.8.8.8"),
	// 			DNSServices: to.Ptr[int64](0),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginUpdateDhcp ¶

func (client *WorkloadNetworksClient) BeginUpdateDhcp(ctx context.Context, resourceGroupName string, privateCloudName string, dhcpID string, workloadNetworkDhcp WorkloadNetworkDhcp, options *WorkloadNetworksClientBeginUpdateDhcpOptions) (*runtime.Poller[WorkloadNetworksClientUpdateDhcpResponse], error)

BeginUpdateDhcp - Update a WorkloadNetworkDhcp If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dhcpID - The ID of the DHCP configuration
workloadNetworkDhcp - The resource properties to be updated.
options - WorkloadNetworksClientBeginUpdateDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDhcp method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_UpdateDhcp.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginUpdateDhcp(ctx, "group1", "cloud1", "dhcp1", armavs.WorkloadNetworkDhcp{
		Properties: &armavs.WorkloadNetworkDhcpServer{
			DhcpType:      to.Ptr(armavs.DhcpTypeEnumSERVER),
			ServerAddress: to.Ptr("40.1.5.1/24"),
			LeaseTime:     to.Ptr[int64](86400),
			Revision:      to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientUpdateDhcpResponse{
	// 	WorkloadNetworkDhcp: armavs.WorkloadNetworkDhcp{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
	// 		Name: to.Ptr("dhcp1"),
	// 		Properties: &armavs.WorkloadNetworkDhcpServer{
	// 			DisplayName: to.Ptr("dhcpConfigurations1"),
	// 			DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
	// 			Segments: []*string{
	// 				to.Ptr("segment1"),
	// 				to.Ptr("segment2"),
	// 			},
	// 			ServerAddress: to.Ptr("40.1.5.1/24"),
	// 			LeaseTime: to.Ptr[int64](86400),
	// 			Revision: to.Ptr[int64](2),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginUpdatePortMirroring ¶

func (client *WorkloadNetworksClient) BeginUpdatePortMirroring(ctx context.Context, resourceGroupName string, privateCloudName string, portMirroringID string, workloadNetworkPortMirroring WorkloadNetworkPortMirroring, options *WorkloadNetworksClientBeginUpdatePortMirroringOptions) (*runtime.Poller[WorkloadNetworksClientUpdatePortMirroringResponse], error)

BeginUpdatePortMirroring - Update a WorkloadNetworkPortMirroring If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
portMirroringID - ID of the NSX port mirroring profile.
workloadNetworkPortMirroring - The resource properties to be updated.
options - WorkloadNetworksClientBeginUpdatePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdatePortMirroring method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_UpdatePortMirroring.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginUpdatePortMirroring(ctx, "group1", "cloud1", "portMirroring1", armavs.WorkloadNetworkPortMirroring{
		Properties: &armavs.WorkloadNetworkPortMirroringProperties{
			Direction:   to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
			Source:      to.Ptr("vmGroup1"),
			Destination: to.Ptr("vmGroup2"),
			Revision:    to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientUpdatePortMirroringResponse{
	// 	WorkloadNetworkPortMirroring: armavs.WorkloadNetworkPortMirroring{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
	// 		Name: to.Ptr("portMirroring1"),
	// 		Properties: &armavs.WorkloadNetworkPortMirroringProperties{
	// 			DisplayName: to.Ptr("portMirroring1"),
	// 			Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
	// 			Source: to.Ptr("vmGroup1"),
	// 			Destination: to.Ptr("vmGroup2"),
	// 			Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](2),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginUpdateSegments ¶

func (client *WorkloadNetworksClient) BeginUpdateSegments(ctx context.Context, resourceGroupName string, privateCloudName string, segmentID string, workloadNetworkSegment WorkloadNetworkSegment, options *WorkloadNetworksClientBeginUpdateSegmentsOptions) (*runtime.Poller[WorkloadNetworksClientUpdateSegmentsResponse], error)

BeginUpdateSegments - Update a WorkloadNetworkSegment If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
segmentID - The ID of the NSX Segment
workloadNetworkSegment - The resource properties to be updated.
options - WorkloadNetworksClientBeginUpdateSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateSegments method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_UpdateSegments.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginUpdateSegments(ctx, "group1", "cloud1", "segment1", armavs.WorkloadNetworkSegment{
		Properties: &armavs.WorkloadNetworkSegmentProperties{
			ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
			Subnet: &armavs.WorkloadNetworkSegmentSubnet{
				DhcpRanges: []*string{
					to.Ptr("40.20.0.0-40.20.0.1"),
				},
				GatewayAddress: to.Ptr("40.20.20.20/16"),
			},
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientUpdateSegmentsResponse{
	// 	WorkloadNetworkSegment: armavs.WorkloadNetworkSegment{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
	// 		Name: to.Ptr("segment1"),
	// 		Properties: &armavs.WorkloadNetworkSegmentProperties{
	// 			DisplayName: to.Ptr("segment1"),
	// 			ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
	// 			Subnet: &armavs.WorkloadNetworkSegmentSubnet{
	// 				DhcpRanges: []*string{
	// 					to.Ptr("40.20.0.0-40.20.0.1"),
	// 				},
	// 				GatewayAddress: to.Ptr("40.20.20.20/16"),
	// 			},
	// 			PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
	// 				{
	// 					PortName: to.Ptr("vm1"),
	// 				},
	// 			},
	// 			Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](2),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) BeginUpdateVMGroup ¶

func (client *WorkloadNetworksClient) BeginUpdateVMGroup(ctx context.Context, resourceGroupName string, privateCloudName string, vmGroupID string, workloadNetworkVMGroup WorkloadNetworkVMGroup, options *WorkloadNetworksClientBeginUpdateVMGroupOptions) (*runtime.Poller[WorkloadNetworksClientUpdateVMGroupResponse], error)

BeginUpdateVMGroup - Update a WorkloadNetworkVMGroup If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
vmGroupID - ID of the VM group.
workloadNetworkVMGroup - The resource properties to be updated.
options - WorkloadNetworksClientBeginUpdateVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateVMGroup method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_UpdateVMGroup.json

package main

import (
	"context"
	"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/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkloadNetworksClient().BeginUpdateVMGroup(ctx, "group1", "cloud1", "vmGroup1", armavs.WorkloadNetworkVMGroup{
		Properties: &armavs.WorkloadNetworkVMGroupProperties{
			Members: []*string{
				to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50"),
			},
			Revision: to.Ptr[int64](1),
		},
	}, 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 poll 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 = armavs.WorkloadNetworksClientUpdateVMGroupResponse{
	// 	WorkloadNetworkVMGroup: armavs.WorkloadNetworkVMGroup{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
	// 		Name: to.Ptr("cloud1"),
	// 		Properties: &armavs.WorkloadNetworkVMGroupProperties{
	// 			DisplayName: to.Ptr("vmGroup1"),
	// 			Members: []*string{
	// 				to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50"),
	// 			},
	// 			Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](2),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) Get ¶

func (client *WorkloadNetworksClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientGetOptions) (WorkloadNetworksClientGetResponse, error)

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

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientGetOptions contains the optional parameters for the WorkloadNetworksClient.Get method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_Get.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().Get(ctx, "group1", "cloud1", 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 = armavs.WorkloadNetworksClientGetResponse{
	// 	WorkloadNetwork: armavs.WorkloadNetwork{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default"),
	// 		Name: to.Ptr("default"),
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetDNSService ¶

func (client *WorkloadNetworksClient) GetDNSService(ctx context.Context, resourceGroupName string, privateCloudName string, dnsServiceID string, options *WorkloadNetworksClientGetDNSServiceOptions) (WorkloadNetworksClientGetDNSServiceResponse, error)

GetDNSService - Get a WorkloadNetworkDnsService If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dnsServiceID - ID of the DNS service.
options - WorkloadNetworksClientGetDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.GetDNSService method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetDnsService.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetDNSService(ctx, "group1", "cloud1", "dnsService1", 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 = armavs.WorkloadNetworksClientGetDNSServiceResponse{
	// 	WorkloadNetworkDNSService: armavs.WorkloadNetworkDNSService{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
	// 		Name: to.Ptr("portMirroring1"),
	// 		Properties: &armavs.WorkloadNetworkDNSServiceProperties{
	// 			DisplayName: to.Ptr("dnsService1"),
	// 			DNSServiceIP: to.Ptr("5.5.5.5"),
	// 			DefaultDNSZone: to.Ptr("defaultDnsZone1"),
	// 			FqdnZones: []*string{
	// 				to.Ptr("fqdnZone1"),
	// 			},
	// 			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
	// 			Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetDNSZone ¶

func (client *WorkloadNetworksClient) GetDNSZone(ctx context.Context, resourceGroupName string, privateCloudName string, dnsZoneID string, options *WorkloadNetworksClientGetDNSZoneOptions) (WorkloadNetworksClientGetDNSZoneResponse, error)

GetDNSZone - Get a WorkloadNetworkDnsZone If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
dnsZoneID - ID of the DNS zone.
options - WorkloadNetworksClientGetDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.GetDNSZone method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetDnsZone.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetDNSZone(ctx, "group1", "cloud1", "dnsZone1", 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 = armavs.WorkloadNetworksClientGetDNSZoneResponse{
	// 	WorkloadNetworkDNSZone: armavs.WorkloadNetworkDNSZone{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
	// 		Name: to.Ptr("portMirroring1"),
	// 		Properties: &armavs.WorkloadNetworkDNSZoneProperties{
	// 			DisplayName: to.Ptr("dnsZone1"),
	// 			Domain: []*string{
	// 			},
	// 			DNSServerIPs: []*string{
	// 				to.Ptr("1.1.1.1"),
	// 			},
	// 			SourceIP: to.Ptr("8.8.8.8"),
	// 			DNSServices: to.Ptr[int64](0),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetDhcp ¶

func (client *WorkloadNetworksClient) GetDhcp(ctx context.Context, resourceGroupName string, dhcpID string, privateCloudName string, options *WorkloadNetworksClientGetDhcpOptions) (WorkloadNetworksClientGetDhcpResponse, error)

GetDhcp - Get a WorkloadNetworkDhcp If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
dhcpID - The ID of the DHCP configuration
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientGetDhcpOptions contains the optional parameters for the WorkloadNetworksClient.GetDhcp method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetDhcp.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetDhcp(ctx, "group1", "dhcp1", "cloud1", 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 = armavs.WorkloadNetworksClientGetDhcpResponse{
	// 	WorkloadNetworkDhcp: armavs.WorkloadNetworkDhcp{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
	// 		Name: to.Ptr("dhcp1"),
	// 		Properties: &armavs.WorkloadNetworkDhcpServer{
	// 			DisplayName: to.Ptr("dhcpConfigurations1"),
	// 			DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
	// 			Segments: []*string{
	// 				to.Ptr("segment1"),
	// 				to.Ptr("segment2"),
	// 			},
	// 			ServerAddress: to.Ptr("40.1.5.1/24"),
	// 			LeaseTime: to.Ptr[int64](86400),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetGateway ¶

func (client *WorkloadNetworksClient) GetGateway(ctx context.Context, resourceGroupName string, privateCloudName string, gatewayID string, options *WorkloadNetworksClientGetGatewayOptions) (WorkloadNetworksClientGetGatewayResponse, error)

GetGateway - Get a WorkloadNetworkGateway If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
gatewayID - The ID of the NSX Gateway
options - WorkloadNetworksClientGetGatewayOptions contains the optional parameters for the WorkloadNetworksClient.GetGateway method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetGateway.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetGateway(ctx, "group1", "cloud1", "gateway1", 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 = armavs.WorkloadNetworksClientGetGatewayResponse{
	// 	WorkloadNetworkGateway: armavs.WorkloadNetworkGateway{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/gateways/gateway1"),
	// 		Name: to.Ptr("gateway1"),
	// 		Properties: &armavs.WorkloadNetworkGatewayProperties{
	// 			DisplayName: to.Ptr("gateway1"),
	// 			Path: to.Ptr("/infra/tier-1s/gateway1"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/gateways"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetPortMirroring ¶

func (client *WorkloadNetworksClient) GetPortMirroring(ctx context.Context, resourceGroupName string, privateCloudName string, portMirroringID string, options *WorkloadNetworksClientGetPortMirroringOptions) (WorkloadNetworksClientGetPortMirroringResponse, error)

GetPortMirroring - Get a WorkloadNetworkPortMirroring If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
portMirroringID - ID of the NSX port mirroring profile.
options - WorkloadNetworksClientGetPortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.GetPortMirroring method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetPortMirroring.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetPortMirroring(ctx, "group1", "cloud1", "portMirroring1", 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 = armavs.WorkloadNetworksClientGetPortMirroringResponse{
	// 	WorkloadNetworkPortMirroring: armavs.WorkloadNetworkPortMirroring{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
	// 		Name: to.Ptr("portMirroring1"),
	// 		Properties: &armavs.WorkloadNetworkPortMirroringProperties{
	// 			DisplayName: to.Ptr("portMirroring1"),
	// 			Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
	// 			Source: to.Ptr("vmGroup1"),
	// 			Destination: to.Ptr("vmGroup2"),
	// 			Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetPublicIP ¶

func (client *WorkloadNetworksClient) GetPublicIP(ctx context.Context, resourceGroupName string, privateCloudName string, publicIPID string, options *WorkloadNetworksClientGetPublicIPOptions) (WorkloadNetworksClientGetPublicIPResponse, error)

GetPublicIP - Get a WorkloadNetworkPublicIP If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
publicIPID - ID of the DNS zone.
options - WorkloadNetworksClientGetPublicIPOptions contains the optional parameters for the WorkloadNetworksClient.GetPublicIP method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetPublicIP.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetPublicIP(ctx, "group1", "cloud1", "publicIP1", 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 = armavs.WorkloadNetworksClientGetPublicIPResponse{
	// 	WorkloadNetworkPublicIP: armavs.WorkloadNetworkPublicIP{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/publicIPs/publicIP1"),
	// 		Name: to.Ptr("publicIP1"),
	// 		Properties: &armavs.WorkloadNetworkPublicIPProperties{
	// 			DisplayName: to.Ptr("publicIP1"),
	// 			PublicIPBlock: to.Ptr("20.20.40.50/32"),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/publicIPs"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetSegment ¶

func (client *WorkloadNetworksClient) GetSegment(ctx context.Context, resourceGroupName string, privateCloudName string, segmentID string, options *WorkloadNetworksClientGetSegmentOptions) (WorkloadNetworksClientGetSegmentResponse, error)

GetSegment - Get a WorkloadNetworkSegment If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
segmentID - The ID of the NSX Segment
options - WorkloadNetworksClientGetSegmentOptions contains the optional parameters for the WorkloadNetworksClient.GetSegment method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetSegment.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetSegment(ctx, "group1", "cloud1", "segment1", 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 = armavs.WorkloadNetworksClientGetSegmentResponse{
	// 	WorkloadNetworkSegment: armavs.WorkloadNetworkSegment{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
	// 		Name: to.Ptr("segment1"),
	// 		Properties: &armavs.WorkloadNetworkSegmentProperties{
	// 			DisplayName: to.Ptr("segment1"),
	// 			ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
	// 			Subnet: &armavs.WorkloadNetworkSegmentSubnet{
	// 				DhcpRanges: []*string{
	// 					to.Ptr("40.20.0.0-40.20.0.1"),
	// 				},
	// 				GatewayAddress: to.Ptr("40.20.20.20/16"),
	// 			},
	// 			PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
	// 				{
	// 					PortName: to.Ptr("vm1"),
	// 				},
	// 			},
	// 			Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetVMGroup ¶

func (client *WorkloadNetworksClient) GetVMGroup(ctx context.Context, resourceGroupName string, privateCloudName string, vmGroupID string, options *WorkloadNetworksClientGetVMGroupOptions) (WorkloadNetworksClientGetVMGroupResponse, error)

GetVMGroup - Get a WorkloadNetworkVMGroup If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
vmGroupID - ID of the VM group.
options - WorkloadNetworksClientGetVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.GetVMGroup method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetVMGroup.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetVMGroup(ctx, "group1", "cloud1", "vmGroup1", 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 = armavs.WorkloadNetworksClientGetVMGroupResponse{
	// 	WorkloadNetworkVMGroup: armavs.WorkloadNetworkVMGroup{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
	// 		Name: to.Ptr("cloud1"),
	// 		Properties: &armavs.WorkloadNetworkVMGroupProperties{
	// 			DisplayName: to.Ptr("vmGroup1"),
	// 			Members: []*string{
	// 				to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50"),
	// 			},
	// 			Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
	// 			Revision: to.Ptr[int64](1),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) GetVirtualMachine ¶

func (client *WorkloadNetworksClient) GetVirtualMachine(ctx context.Context, resourceGroupName string, privateCloudName string, virtualMachineID string, options *WorkloadNetworksClientGetVirtualMachineOptions) (WorkloadNetworksClientGetVirtualMachineResponse, error)

GetVirtualMachine - Get a WorkloadNetworkVirtualMachine If the operation fails it returns an *azcore.ResponseError type.

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
virtualMachineID - ID of the virtual machine.
options - WorkloadNetworksClientGetVirtualMachineOptions contains the optional parameters for the WorkloadNetworksClient.GetVirtualMachine method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_GetVirtualMachine.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkloadNetworksClient().GetVirtualMachine(ctx, "group1", "cloud1", "vm1", 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 = armavs.WorkloadNetworksClientGetVirtualMachineResponse{
	// 	WorkloadNetworkVirtualMachine: armavs.WorkloadNetworkVirtualMachine{
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/virtualMachines/vm1"),
	// 		Name: to.Ptr("vm1"),
	// 		Properties: &armavs.WorkloadNetworkVirtualMachineProperties{
	// 			DisplayName: to.Ptr("vm1"),
	// 			VMType: to.Ptr(armavs.VMTypeEnumREGULAR),
	// 		},
	// 		Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/virtualMachines"),
	// 	},
	// }
}

Output:

func (*WorkloadNetworksClient) NewListDNSServicesPager ¶

func (client *WorkloadNetworksClient) NewListDNSServicesPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListDNSServicesOptions) *runtime.Pager[WorkloadNetworksClientListDNSServicesResponse]

NewListDNSServicesPager - List WorkloadNetworkDnsService resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListDNSServicesOptions contains the optional parameters for the WorkloadNetworksClient.NewListDNSServicesPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListDnsServices.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListDNSServicesPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListDNSServicesResponse{
		// 	WorkloadNetworkDNSServicesList: armavs.WorkloadNetworkDNSServicesList{
		// 		Value: []*armavs.WorkloadNetworkDNSService{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
		// 				Name: to.Ptr("portMirroring1"),
		// 				Properties: &armavs.WorkloadNetworkDNSServiceProperties{
		// 					DisplayName: to.Ptr("dnsService1"),
		// 					DNSServiceIP: to.Ptr("5.5.5.5"),
		// 					DefaultDNSZone: to.Ptr("defaultDnsZone1"),
		// 					FqdnZones: []*string{
		// 						to.Ptr("fqdnZone1"),
		// 					},
		// 					LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
		// 					Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
		// 					Revision: to.Ptr[int64](1),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListDNSZonesPager ¶

func (client *WorkloadNetworksClient) NewListDNSZonesPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListDNSZonesOptions) *runtime.Pager[WorkloadNetworksClientListDNSZonesResponse]

NewListDNSZonesPager - List WorkloadNetworkDnsZone resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListDNSZonesOptions contains the optional parameters for the WorkloadNetworksClient.NewListDNSZonesPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListDnsZones.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListDNSZonesPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListDNSZonesResponse{
		// 	WorkloadNetworkDNSZonesList: armavs.WorkloadNetworkDNSZonesList{
		// 		Value: []*armavs.WorkloadNetworkDNSZone{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
		// 				Name: to.Ptr("portMirroring1"),
		// 				Properties: &armavs.WorkloadNetworkDNSZoneProperties{
		// 					DisplayName: to.Ptr("dnsZone1"),
		// 					Domain: []*string{
		// 					},
		// 					DNSServerIPs: []*string{
		// 						to.Ptr("1.1.1.1"),
		// 					},
		// 					SourceIP: to.Ptr("8.8.8.8"),
		// 					DNSServices: to.Ptr[int64](0),
		// 					Revision: to.Ptr[int64](1),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListDhcpPager ¶

func (client *WorkloadNetworksClient) NewListDhcpPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListDhcpOptions) *runtime.Pager[WorkloadNetworksClientListDhcpResponse]

NewListDhcpPager - List WorkloadNetworkDhcp resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListDhcpOptions contains the optional parameters for the WorkloadNetworksClient.NewListDhcpPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListDhcp.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListDhcpPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListDhcpResponse{
		// 	WorkloadNetworkDhcpList: armavs.WorkloadNetworkDhcpList{
		// 		Value: []*armavs.WorkloadNetworkDhcp{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
		// 				Name: to.Ptr("dhcp1"),
		// 				Properties: &armavs.WorkloadNetworkDhcpServer{
		// 					DisplayName: to.Ptr("dhcpConfigurations1"),
		// 					DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
		// 					Segments: []*string{
		// 						to.Ptr("segment1"),
		// 						to.Ptr("segment2"),
		// 					},
		// 					ServerAddress: to.Ptr("40.1.5.1/24"),
		// 					LeaseTime: to.Ptr[int64](86400),
		// 					Revision: to.Ptr[int64](1),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListGatewaysPager ¶

func (client *WorkloadNetworksClient) NewListGatewaysPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListGatewaysOptions) *runtime.Pager[WorkloadNetworksClientListGatewaysResponse]

NewListGatewaysPager - List WorkloadNetworkGateway resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListGatewaysOptions contains the optional parameters for the WorkloadNetworksClient.NewListGatewaysPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListGateways.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListGatewaysPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListGatewaysResponse{
		// 	WorkloadNetworkGatewayList: armavs.WorkloadNetworkGatewayList{
		// 		Value: []*armavs.WorkloadNetworkGateway{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/gateways/gateway1"),
		// 				Name: to.Ptr("gateway1"),
		// 				Properties: &armavs.WorkloadNetworkGatewayProperties{
		// 					DisplayName: to.Ptr("gateway1"),
		// 					Path: to.Ptr("/infra/tier-1s/gateway1"),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListPager ¶

func (client *WorkloadNetworksClient) NewListPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListOptions) *runtime.Pager[WorkloadNetworksClientListResponse]

NewListPager - List WorkloadNetwork resources by PrivateCloud

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListOptions contains the optional parameters for the WorkloadNetworksClient.NewListPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_List.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListResponse{
		// 	WorkloadNetworkList: armavs.WorkloadNetworkList{
		// 		Value: []*armavs.WorkloadNetwork{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default"),
		// 				Name: to.Ptr("default"),
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListPortMirroringPager ¶

func (client *WorkloadNetworksClient) NewListPortMirroringPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListPortMirroringOptions) *runtime.Pager[WorkloadNetworksClientListPortMirroringResponse]

NewListPortMirroringPager - List WorkloadNetworkPortMirroring resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListPortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.NewListPortMirroringPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListPortMirroring.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListPortMirroringPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListPortMirroringResponse{
		// 	WorkloadNetworkPortMirroringList: armavs.WorkloadNetworkPortMirroringList{
		// 		Value: []*armavs.WorkloadNetworkPortMirroring{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
		// 				Name: to.Ptr("cloud1"),
		// 				Properties: &armavs.WorkloadNetworkPortMirroringProperties{
		// 					DisplayName: to.Ptr("portMirroring1"),
		// 					Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
		// 					Source: to.Ptr("vmGroup1"),
		// 					Destination: to.Ptr("vmGroup2"),
		// 					Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
		// 					Revision: to.Ptr[int64](1),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListPublicIPsPager ¶

func (client *WorkloadNetworksClient) NewListPublicIPsPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListPublicIPsOptions) *runtime.Pager[WorkloadNetworksClientListPublicIPsResponse]

NewListPublicIPsPager - List WorkloadNetworkPublicIP resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListPublicIPsOptions contains the optional parameters for the WorkloadNetworksClient.NewListPublicIPsPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListPublicIPs.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListPublicIPsPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListPublicIPsResponse{
		// 	WorkloadNetworkPublicIPsList: armavs.WorkloadNetworkPublicIPsList{
		// 		Value: []*armavs.WorkloadNetworkPublicIP{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/publicIPs/publicIP1"),
		// 				Name: to.Ptr("publicIP1"),
		// 				Properties: &armavs.WorkloadNetworkPublicIPProperties{
		// 					DisplayName: to.Ptr("publicIP1"),
		// 					PublicIPBlock: to.Ptr("20.20.40.50/32"),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/publicIPs"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListSegmentsPager ¶

func (client *WorkloadNetworksClient) NewListSegmentsPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListSegmentsOptions) *runtime.Pager[WorkloadNetworksClientListSegmentsResponse]

NewListSegmentsPager - List WorkloadNetworkSegment resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.NewListSegmentsPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListSegments.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListSegmentsPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListSegmentsResponse{
		// 	WorkloadNetworkSegmentsList: armavs.WorkloadNetworkSegmentsList{
		// 		Value: []*armavs.WorkloadNetworkSegment{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
		// 				Name: to.Ptr("segment1"),
		// 				Properties: &armavs.WorkloadNetworkSegmentProperties{
		// 					DisplayName: to.Ptr("segment1"),
		// 					ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
		// 					Subnet: &armavs.WorkloadNetworkSegmentSubnet{
		// 						DhcpRanges: []*string{
		// 							to.Ptr("40.20.0.0-40.20.0.1"),
		// 						},
		// 						GatewayAddress: to.Ptr("40.20.20.20/16"),
		// 					},
		// 					PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
		// 						{
		// 							PortName: to.Ptr("vm1"),
		// 						},
		// 					},
		// 					Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
		// 					Revision: to.Ptr[int64](1),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListVMGroupsPager ¶

func (client *WorkloadNetworksClient) NewListVMGroupsPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListVMGroupsOptions) *runtime.Pager[WorkloadNetworksClientListVMGroupsResponse]

NewListVMGroupsPager - List WorkloadNetworkVMGroup resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListVMGroupsOptions contains the optional parameters for the WorkloadNetworksClient.NewListVMGroupsPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListVMGroups.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListVMGroupsPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListVMGroupsResponse{
		// 	WorkloadNetworkVMGroupsList: armavs.WorkloadNetworkVMGroupsList{
		// 		Value: []*armavs.WorkloadNetworkVMGroup{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
		// 				Name: to.Ptr("cloud1"),
		// 				Properties: &armavs.WorkloadNetworkVMGroupProperties{
		// 					DisplayName: to.Ptr("vmGroup1"),
		// 					Members: []*string{
		// 						to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50"),
		// 					},
		// 					Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
		// 					Revision: to.Ptr[int64](1),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

func (*WorkloadNetworksClient) NewListVirtualMachinesPager ¶

func (client *WorkloadNetworksClient) NewListVirtualMachinesPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListVirtualMachinesOptions) *runtime.Pager[WorkloadNetworksClientListVirtualMachinesResponse]

NewListVirtualMachinesPager - List WorkloadNetworkVirtualMachine resources by WorkloadNetwork

resourceGroupName - The name of the resource group. The name is case insensitive.
privateCloudName - Name of the private cloud
options - WorkloadNetworksClientListVirtualMachinesOptions contains the optional parameters for the WorkloadNetworksClient.NewListVirtualMachinesPager method.

Example ¶

Generated from example definition: 2026-03-01/WorkloadNetworks_ListVirtualMachines.json

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/avs/armavs/v2"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armavs.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkloadNetworksClient().NewListVirtualMachinesPager("group1", "cloud1", 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 = armavs.WorkloadNetworksClientListVirtualMachinesResponse{
		// 	WorkloadNetworkVirtualMachinesList: armavs.WorkloadNetworkVirtualMachinesList{
		// 		Value: []*armavs.WorkloadNetworkVirtualMachine{
		// 			{
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/virtualMachines/vm1"),
		// 				Name: to.Ptr("vm1"),
		// 				Properties: &armavs.WorkloadNetworkVirtualMachineProperties{
		// 					DisplayName: to.Ptr("vm1"),
		// 					VMType: to.Ptr(armavs.VMTypeEnumREGULAR),
		// 				},
		// 				Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/virtualMachines"),
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type WorkloadNetworksClientBeginCreateDNSServiceOptions ¶

type WorkloadNetworksClientBeginCreateDNSServiceOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreateDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDNSService method.

type WorkloadNetworksClientBeginCreateDNSZoneOptions ¶

type WorkloadNetworksClientBeginCreateDNSZoneOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreateDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDNSZone method.

type WorkloadNetworksClientBeginCreateDhcpOptions ¶

type WorkloadNetworksClientBeginCreateDhcpOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreateDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDhcp method.

type WorkloadNetworksClientBeginCreatePortMirroringOptions ¶

type WorkloadNetworksClientBeginCreatePortMirroringOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreatePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreatePortMirroring method.

type WorkloadNetworksClientBeginCreatePublicIPOptions ¶

type WorkloadNetworksClientBeginCreatePublicIPOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreatePublicIPOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreatePublicIP method.

type WorkloadNetworksClientBeginCreateSegmentsOptions ¶

type WorkloadNetworksClientBeginCreateSegmentsOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreateSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateSegments method.

type WorkloadNetworksClientBeginCreateVMGroupOptions ¶

type WorkloadNetworksClientBeginCreateVMGroupOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginCreateVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateVMGroup method.

type WorkloadNetworksClientBeginDeleteDNSServiceOptions ¶

type WorkloadNetworksClientBeginDeleteDNSServiceOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeleteDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDNSService method.

type WorkloadNetworksClientBeginDeleteDNSZoneOptions ¶

type WorkloadNetworksClientBeginDeleteDNSZoneOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeleteDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDNSZone method.

type WorkloadNetworksClientBeginDeleteDhcpOptions ¶

type WorkloadNetworksClientBeginDeleteDhcpOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeleteDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDhcp method.

type WorkloadNetworksClientBeginDeletePortMirroringOptions ¶

type WorkloadNetworksClientBeginDeletePortMirroringOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeletePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeletePortMirroring method.

type WorkloadNetworksClientBeginDeletePublicIPOptions ¶

type WorkloadNetworksClientBeginDeletePublicIPOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeletePublicIPOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeletePublicIP method.

type WorkloadNetworksClientBeginDeleteSegmentOptions ¶

type WorkloadNetworksClientBeginDeleteSegmentOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeleteSegmentOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteSegment method.

type WorkloadNetworksClientBeginDeleteVMGroupOptions ¶

type WorkloadNetworksClientBeginDeleteVMGroupOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginDeleteVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteVMGroup method.

type WorkloadNetworksClientBeginUpdateDNSServiceOptions ¶

type WorkloadNetworksClientBeginUpdateDNSServiceOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginUpdateDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDNSService method.

type WorkloadNetworksClientBeginUpdateDNSZoneOptions ¶

type WorkloadNetworksClientBeginUpdateDNSZoneOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginUpdateDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDNSZone method.

type WorkloadNetworksClientBeginUpdateDhcpOptions ¶

type WorkloadNetworksClientBeginUpdateDhcpOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginUpdateDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDhcp method.

type WorkloadNetworksClientBeginUpdatePortMirroringOptions ¶

type WorkloadNetworksClientBeginUpdatePortMirroringOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginUpdatePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdatePortMirroring method.

type WorkloadNetworksClientBeginUpdateSegmentsOptions ¶

type WorkloadNetworksClientBeginUpdateSegmentsOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginUpdateSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateSegments method.

type WorkloadNetworksClientBeginUpdateVMGroupOptions ¶

type WorkloadNetworksClientBeginUpdateVMGroupOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

WorkloadNetworksClientBeginUpdateVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateVMGroup method.

type WorkloadNetworksClientCreateDNSServiceResponse ¶

type WorkloadNetworksClientCreateDNSServiceResponse struct {
	// NSX DNS Service
	WorkloadNetworkDNSService
}

WorkloadNetworksClientCreateDNSServiceResponse contains the response from method WorkloadNetworksClient.BeginCreateDNSService.

type WorkloadNetworksClientCreateDNSZoneResponse ¶

type WorkloadNetworksClientCreateDNSZoneResponse struct {
	// NSX DNS Zone
	WorkloadNetworkDNSZone
}

WorkloadNetworksClientCreateDNSZoneResponse contains the response from method WorkloadNetworksClient.BeginCreateDNSZone.

type WorkloadNetworksClientCreateDhcpResponse ¶

type WorkloadNetworksClientCreateDhcpResponse struct {
	// NSX DHCP
	WorkloadNetworkDhcp
}

WorkloadNetworksClientCreateDhcpResponse contains the response from method WorkloadNetworksClient.BeginCreateDhcp.

type WorkloadNetworksClientCreatePortMirroringResponse ¶

type WorkloadNetworksClientCreatePortMirroringResponse struct {
	// NSX Port Mirroring
	WorkloadNetworkPortMirroring
}

WorkloadNetworksClientCreatePortMirroringResponse contains the response from method WorkloadNetworksClient.BeginCreatePortMirroring.

type WorkloadNetworksClientCreatePublicIPResponse ¶

type WorkloadNetworksClientCreatePublicIPResponse struct {
	// NSX Public IP Block
	WorkloadNetworkPublicIP
}

WorkloadNetworksClientCreatePublicIPResponse contains the response from method WorkloadNetworksClient.BeginCreatePublicIP.

type WorkloadNetworksClientCreateSegmentsResponse ¶

type WorkloadNetworksClientCreateSegmentsResponse struct {
	// NSX Segment
	WorkloadNetworkSegment
}

WorkloadNetworksClientCreateSegmentsResponse contains the response from method WorkloadNetworksClient.BeginCreateSegments.

type WorkloadNetworksClientCreateVMGroupResponse ¶

type WorkloadNetworksClientCreateVMGroupResponse struct {
	// NSX VM Group
	WorkloadNetworkVMGroup
}

WorkloadNetworksClientCreateVMGroupResponse contains the response from method WorkloadNetworksClient.BeginCreateVMGroup.

type WorkloadNetworksClientDeleteDNSServiceResponse ¶

type WorkloadNetworksClientDeleteDNSServiceResponse struct {
}

WorkloadNetworksClientDeleteDNSServiceResponse contains the response from method WorkloadNetworksClient.BeginDeleteDNSService.

type WorkloadNetworksClientDeleteDNSZoneResponse ¶

type WorkloadNetworksClientDeleteDNSZoneResponse struct {
}

WorkloadNetworksClientDeleteDNSZoneResponse contains the response from method WorkloadNetworksClient.BeginDeleteDNSZone.

type WorkloadNetworksClientDeleteDhcpResponse ¶

type WorkloadNetworksClientDeleteDhcpResponse struct {
}

WorkloadNetworksClientDeleteDhcpResponse contains the response from method WorkloadNetworksClient.BeginDeleteDhcp.

type WorkloadNetworksClientDeletePortMirroringResponse ¶

type WorkloadNetworksClientDeletePortMirroringResponse struct {
}

WorkloadNetworksClientDeletePortMirroringResponse contains the response from method WorkloadNetworksClient.BeginDeletePortMirroring.

type WorkloadNetworksClientDeletePublicIPResponse ¶

type WorkloadNetworksClientDeletePublicIPResponse struct {
}

WorkloadNetworksClientDeletePublicIPResponse contains the response from method WorkloadNetworksClient.BeginDeletePublicIP.

type WorkloadNetworksClientDeleteSegmentResponse ¶

type WorkloadNetworksClientDeleteSegmentResponse struct {
}

WorkloadNetworksClientDeleteSegmentResponse contains the response from method WorkloadNetworksClient.BeginDeleteSegment.

type WorkloadNetworksClientDeleteVMGroupResponse ¶

type WorkloadNetworksClientDeleteVMGroupResponse struct {
}

WorkloadNetworksClientDeleteVMGroupResponse contains the response from method WorkloadNetworksClient.BeginDeleteVMGroup.

type WorkloadNetworksClientGetDNSServiceOptions ¶

type WorkloadNetworksClientGetDNSServiceOptions struct {
}

WorkloadNetworksClientGetDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.GetDNSService method.

type WorkloadNetworksClientGetDNSServiceResponse ¶

type WorkloadNetworksClientGetDNSServiceResponse struct {
	// NSX DNS Service
	WorkloadNetworkDNSService
}

WorkloadNetworksClientGetDNSServiceResponse contains the response from method WorkloadNetworksClient.GetDNSService.

type WorkloadNetworksClientGetDNSZoneOptions ¶

type WorkloadNetworksClientGetDNSZoneOptions struct {
}

WorkloadNetworksClientGetDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.GetDNSZone method.

type WorkloadNetworksClientGetDNSZoneResponse ¶

type WorkloadNetworksClientGetDNSZoneResponse struct {
	// NSX DNS Zone
	WorkloadNetworkDNSZone
}

WorkloadNetworksClientGetDNSZoneResponse contains the response from method WorkloadNetworksClient.GetDNSZone.

type WorkloadNetworksClientGetDhcpOptions ¶

type WorkloadNetworksClientGetDhcpOptions struct {
}

WorkloadNetworksClientGetDhcpOptions contains the optional parameters for the WorkloadNetworksClient.GetDhcp method.

type WorkloadNetworksClientGetDhcpResponse ¶

type WorkloadNetworksClientGetDhcpResponse struct {
	// NSX DHCP
	WorkloadNetworkDhcp
}

WorkloadNetworksClientGetDhcpResponse contains the response from method WorkloadNetworksClient.GetDhcp.

type WorkloadNetworksClientGetGatewayOptions ¶

type WorkloadNetworksClientGetGatewayOptions struct {
}

WorkloadNetworksClientGetGatewayOptions contains the optional parameters for the WorkloadNetworksClient.GetGateway method.

type WorkloadNetworksClientGetGatewayResponse ¶

type WorkloadNetworksClientGetGatewayResponse struct {
	// NSX Gateway.
	WorkloadNetworkGateway
}

WorkloadNetworksClientGetGatewayResponse contains the response from method WorkloadNetworksClient.GetGateway.

type WorkloadNetworksClientGetOptions ¶

type WorkloadNetworksClientGetOptions struct {
}

WorkloadNetworksClientGetOptions contains the optional parameters for the WorkloadNetworksClient.Get method.

type WorkloadNetworksClientGetPortMirroringOptions ¶

type WorkloadNetworksClientGetPortMirroringOptions struct {
}

WorkloadNetworksClientGetPortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.GetPortMirroring method.

type WorkloadNetworksClientGetPortMirroringResponse ¶

type WorkloadNetworksClientGetPortMirroringResponse struct {
	// NSX Port Mirroring
	WorkloadNetworkPortMirroring
}

WorkloadNetworksClientGetPortMirroringResponse contains the response from method WorkloadNetworksClient.GetPortMirroring.

type WorkloadNetworksClientGetPublicIPOptions ¶

type WorkloadNetworksClientGetPublicIPOptions struct {
}

WorkloadNetworksClientGetPublicIPOptions contains the optional parameters for the WorkloadNetworksClient.GetPublicIP method.

type WorkloadNetworksClientGetPublicIPResponse ¶

type WorkloadNetworksClientGetPublicIPResponse struct {
	// NSX Public IP Block
	WorkloadNetworkPublicIP
}

WorkloadNetworksClientGetPublicIPResponse contains the response from method WorkloadNetworksClient.GetPublicIP.

type WorkloadNetworksClientGetResponse ¶

type WorkloadNetworksClientGetResponse struct {
	// Workload Network
	WorkloadNetwork
}

WorkloadNetworksClientGetResponse contains the response from method WorkloadNetworksClient.Get.

type WorkloadNetworksClientGetSegmentOptions ¶

type WorkloadNetworksClientGetSegmentOptions struct {
}

WorkloadNetworksClientGetSegmentOptions contains the optional parameters for the WorkloadNetworksClient.GetSegment method.

type WorkloadNetworksClientGetSegmentResponse ¶

type WorkloadNetworksClientGetSegmentResponse struct {
	// NSX Segment
	WorkloadNetworkSegment
}

WorkloadNetworksClientGetSegmentResponse contains the response from method WorkloadNetworksClient.GetSegment.

type WorkloadNetworksClientGetVMGroupOptions ¶

type WorkloadNetworksClientGetVMGroupOptions struct {
}

WorkloadNetworksClientGetVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.GetVMGroup method.

type WorkloadNetworksClientGetVMGroupResponse ¶

type WorkloadNetworksClientGetVMGroupResponse struct {
	// NSX VM Group
	WorkloadNetworkVMGroup
}

WorkloadNetworksClientGetVMGroupResponse contains the response from method WorkloadNetworksClient.GetVMGroup.

type WorkloadNetworksClientGetVirtualMachineOptions ¶

type WorkloadNetworksClientGetVirtualMachineOptions struct {
}

WorkloadNetworksClientGetVirtualMachineOptions contains the optional parameters for the WorkloadNetworksClient.GetVirtualMachine method.

type WorkloadNetworksClientGetVirtualMachineResponse ¶

type WorkloadNetworksClientGetVirtualMachineResponse struct {
	// NSX Virtual Machine
	WorkloadNetworkVirtualMachine
}

WorkloadNetworksClientGetVirtualMachineResponse contains the response from method WorkloadNetworksClient.GetVirtualMachine.

type WorkloadNetworksClientListDNSServicesOptions ¶

type WorkloadNetworksClientListDNSServicesOptions struct {
}

WorkloadNetworksClientListDNSServicesOptions contains the optional parameters for the WorkloadNetworksClient.NewListDNSServicesPager method.

type WorkloadNetworksClientListDNSServicesResponse ¶

type WorkloadNetworksClientListDNSServicesResponse struct {
	// The response of a WorkloadNetworkDnsService list operation.
	WorkloadNetworkDNSServicesList
}

WorkloadNetworksClientListDNSServicesResponse contains the response from method WorkloadNetworksClient.NewListDNSServicesPager.

type WorkloadNetworksClientListDNSZonesOptions ¶

type WorkloadNetworksClientListDNSZonesOptions struct {
}

WorkloadNetworksClientListDNSZonesOptions contains the optional parameters for the WorkloadNetworksClient.NewListDNSZonesPager method.

type WorkloadNetworksClientListDNSZonesResponse ¶

type WorkloadNetworksClientListDNSZonesResponse struct {
	// The response of a WorkloadNetworkDnsZone list operation.
	WorkloadNetworkDNSZonesList
}

WorkloadNetworksClientListDNSZonesResponse contains the response from method WorkloadNetworksClient.NewListDNSZonesPager.

type WorkloadNetworksClientListDhcpOptions ¶

type WorkloadNetworksClientListDhcpOptions struct {
}

WorkloadNetworksClientListDhcpOptions contains the optional parameters for the WorkloadNetworksClient.NewListDhcpPager method.

type WorkloadNetworksClientListDhcpResponse ¶

type WorkloadNetworksClientListDhcpResponse struct {
	// The response of a WorkloadNetworkDhcp list operation.
	WorkloadNetworkDhcpList
}

WorkloadNetworksClientListDhcpResponse contains the response from method WorkloadNetworksClient.NewListDhcpPager.

type WorkloadNetworksClientListGatewaysOptions ¶

type WorkloadNetworksClientListGatewaysOptions struct {
}

WorkloadNetworksClientListGatewaysOptions contains the optional parameters for the WorkloadNetworksClient.NewListGatewaysPager method.

type WorkloadNetworksClientListGatewaysResponse ¶

type WorkloadNetworksClientListGatewaysResponse struct {
	// The response of a WorkloadNetworkGateway list operation.
	WorkloadNetworkGatewayList
}

WorkloadNetworksClientListGatewaysResponse contains the response from method WorkloadNetworksClient.NewListGatewaysPager.

type WorkloadNetworksClientListOptions ¶

type WorkloadNetworksClientListOptions struct {
}

WorkloadNetworksClientListOptions contains the optional parameters for the WorkloadNetworksClient.NewListPager method.

type WorkloadNetworksClientListPortMirroringOptions ¶

type WorkloadNetworksClientListPortMirroringOptions struct {
}

WorkloadNetworksClientListPortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.NewListPortMirroringPager method.

type WorkloadNetworksClientListPortMirroringResponse ¶

type WorkloadNetworksClientListPortMirroringResponse struct {
	// The response of a WorkloadNetworkPortMirroring list operation.
	WorkloadNetworkPortMirroringList
}

WorkloadNetworksClientListPortMirroringResponse contains the response from method WorkloadNetworksClient.NewListPortMirroringPager.

type WorkloadNetworksClientListPublicIPsOptions ¶

type WorkloadNetworksClientListPublicIPsOptions struct {
}

WorkloadNetworksClientListPublicIPsOptions contains the optional parameters for the WorkloadNetworksClient.NewListPublicIPsPager method.

type WorkloadNetworksClientListPublicIPsResponse ¶

type WorkloadNetworksClientListPublicIPsResponse struct {
	// The response of a WorkloadNetworkPublicIP list operation.
	WorkloadNetworkPublicIPsList
}

WorkloadNetworksClientListPublicIPsResponse contains the response from method WorkloadNetworksClient.NewListPublicIPsPager.

type WorkloadNetworksClientListResponse ¶

type WorkloadNetworksClientListResponse struct {
	// The response of a WorkloadNetwork list operation.
	WorkloadNetworkList
}

WorkloadNetworksClientListResponse contains the response from method WorkloadNetworksClient.NewListPager.

type WorkloadNetworksClientListSegmentsOptions ¶

type WorkloadNetworksClientListSegmentsOptions struct {
}

WorkloadNetworksClientListSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.NewListSegmentsPager method.

type WorkloadNetworksClientListSegmentsResponse ¶

type WorkloadNetworksClientListSegmentsResponse struct {
	// The response of a WorkloadNetworkSegment list operation.
	WorkloadNetworkSegmentsList
}

WorkloadNetworksClientListSegmentsResponse contains the response from method WorkloadNetworksClient.NewListSegmentsPager.

type WorkloadNetworksClientListVMGroupsOptions ¶

type WorkloadNetworksClientListVMGroupsOptions struct {
}

WorkloadNetworksClientListVMGroupsOptions contains the optional parameters for the WorkloadNetworksClient.NewListVMGroupsPager method.

type WorkloadNetworksClientListVMGroupsResponse ¶

type WorkloadNetworksClientListVMGroupsResponse struct {
	// The response of a WorkloadNetworkVMGroup list operation.
	WorkloadNetworkVMGroupsList
}

WorkloadNetworksClientListVMGroupsResponse contains the response from method WorkloadNetworksClient.NewListVMGroupsPager.

type WorkloadNetworksClientListVirtualMachinesOptions ¶

type WorkloadNetworksClientListVirtualMachinesOptions struct {
}

WorkloadNetworksClientListVirtualMachinesOptions contains the optional parameters for the WorkloadNetworksClient.NewListVirtualMachinesPager method.

type WorkloadNetworksClientListVirtualMachinesResponse ¶

type WorkloadNetworksClientListVirtualMachinesResponse struct {
	// The response of a WorkloadNetworkVirtualMachine list operation.
	WorkloadNetworkVirtualMachinesList
}

WorkloadNetworksClientListVirtualMachinesResponse contains the response from method WorkloadNetworksClient.NewListVirtualMachinesPager.

type WorkloadNetworksClientUpdateDNSServiceResponse ¶

type WorkloadNetworksClientUpdateDNSServiceResponse struct {
	// NSX DNS Service
	WorkloadNetworkDNSService
}

WorkloadNetworksClientUpdateDNSServiceResponse contains the response from method WorkloadNetworksClient.BeginUpdateDNSService.

type WorkloadNetworksClientUpdateDNSZoneResponse ¶

type WorkloadNetworksClientUpdateDNSZoneResponse struct {
	// NSX DNS Zone
	WorkloadNetworkDNSZone
}

WorkloadNetworksClientUpdateDNSZoneResponse contains the response from method WorkloadNetworksClient.BeginUpdateDNSZone.

type WorkloadNetworksClientUpdateDhcpResponse ¶

type WorkloadNetworksClientUpdateDhcpResponse struct {
	// NSX DHCP
	WorkloadNetworkDhcp
}

WorkloadNetworksClientUpdateDhcpResponse contains the response from method WorkloadNetworksClient.BeginUpdateDhcp.

type WorkloadNetworksClientUpdatePortMirroringResponse ¶

type WorkloadNetworksClientUpdatePortMirroringResponse struct {
	// NSX Port Mirroring
	WorkloadNetworkPortMirroring
}

WorkloadNetworksClientUpdatePortMirroringResponse contains the response from method WorkloadNetworksClient.BeginUpdatePortMirroring.

type WorkloadNetworksClientUpdateSegmentsResponse ¶

type WorkloadNetworksClientUpdateSegmentsResponse struct {
	// NSX Segment
	WorkloadNetworkSegment
}

WorkloadNetworksClientUpdateSegmentsResponse contains the response from method WorkloadNetworksClient.BeginUpdateSegments.

type WorkloadNetworksClientUpdateVMGroupResponse ¶

type WorkloadNetworksClientUpdateVMGroupResponse struct {
	// NSX VM Group
	WorkloadNetworkVMGroup
}

WorkloadNetworksClientUpdateVMGroupResponse contains the response from method WorkloadNetworksClient.BeginUpdateVMGroup.

Directories ¶

Path	Synopsis
fake

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL