armavs

package module
v2.0.0 Latest Latest
Warning

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

 Go to latest Published: Sep 27, 2024 License: MIT Imports: 14 Imported by: 0

README

Azure VMware Solution Module for Go

PkgGoDev

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

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure 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(<subscription ID>, cred, nil)

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

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

Clients

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

client := clientFactory.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 - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type Addon 

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

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

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

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

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

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 {
	// REQUIRED; Addon type
	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 {
	// REQUIRED; Addon type
	AddonType *AddonType

	// REQUIRED; The HCX offer, example VMware MaaS Cloud Provider (Enterprise)
	Offer *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 {
	// REQUIRED; Addon type
	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 {
	// REQUIRED; Addon type
	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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_CreateOrUpdate_ArcReg.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Addon = armavs.Addon{
// 	Name: to.Ptr("arc"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/arc"),
// 	Properties: &armavs.AddonArcProperties{
// 		AddonType: to.Ptr(armavs.AddonTypeArc),
// 		ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
// 		VCenter: to.Ptr("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg_test/providers/Microsoft.ConnectedVMwarevSphere/VCenters/test-vcenter"),
// 	},
// }

Output:
Example (AddonsCreateOrUpdateHcx)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_CreateOrUpdate_HCX.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Addon = armavs.Addon{
// 	Name: to.Ptr("hcx"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/hcx"),
// 	Properties: &armavs.AddonHcxProperties{
// 		AddonType: to.Ptr(armavs.AddonTypeHCX),
// 		ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
// 		Offer: to.Ptr("VMware MaaS Cloud Provider (Enterprise)"),
// 	},
// }

Output:
Example (AddonsCreateOrUpdateSrm)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_CreateOrUpdate_SRM.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Addon = armavs.Addon{
// 	Name: to.Ptr("srm"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/srm"),
// 	Properties: &armavs.AddonSrmProperties{
// 		AddonType: to.Ptr(armavs.AddonTypeSRM),
// 		ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
// 		LicenseKey: to.Ptr("41915178-A8FF-4A4D-B683-6D735AF5E3F5"),
// 	},
// }

Output:
Example (AddonsCreateOrUpdateVr)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_CreateOrUpdate_VR.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Addon = armavs.Addon{
// 	Name: to.Ptr("vr"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/addons"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/addons/vr"),
// 	Properties: &armavs.AddonVrProperties{
// 		AddonType: to.Ptr(armavs.AddonTypeVR),
// 		ProvisioningState: to.Ptr(armavs.AddonProvisioningStateSucceeded),
// 		VrsCount: to.Ptr[int32](1),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_Get_ArcReg.json 

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

Output:
Example (AddonsGetHcx)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_Get_HCX.json 

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

Output:
Example (AddonsGetSrm)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_Get_SRM.json 

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

Output:
Example (AddonsGetVr)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_Get_VR.json 

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

Output:

func (*AddonsClient) NewListPager 

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

NewListPager - List Addon resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Addons_List.json 

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

Output:

type AddonsClientBeginCreateOrUpdateOptions 

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

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

type AddonsClientBeginDeleteOptions 

type AddonsClientBeginDeleteOptions struct {
	// Resumes the LRO 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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Authorizations_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ExpressRouteAuthorization = armavs.ExpressRouteAuthorization{
// 	Name: to.Ptr("authorization1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/authorizations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/authorizations/authorization1"),
// 	Properties: &armavs.ExpressRouteAuthorizationProperties{
// 		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"),
// 		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"),
// 		ProvisioningState: to.Ptr(armavs.ExpressRouteAuthorizationProvisioningStateSucceeded),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Authorizations_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Authorizations_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ExpressRouteAuthorization = armavs.ExpressRouteAuthorization{
// 	Name: to.Ptr("authorization1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/authorizations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/authorizations/authorization1"),
// 	Properties: &armavs.ExpressRouteAuthorizationProperties{
// 		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"),
// 		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"),
// 		ProvisioningState: to.Ptr(armavs.ExpressRouteAuthorizationProvisioningStateSucceeded),
// 	},
// }

Output:

func (*AuthorizationsClient) NewListPager 

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

NewListPager - List ExpressRouteAuthorization resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Authorizations_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ExpressRouteAuthorizationList = armavs.ExpressRouteAuthorizationList{
	// 	Value: []*armavs.ExpressRouteAuthorization{
	// 		{
	// 			Name: to.Ptr("authorization1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/authorizations"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/authorizations/authorization1"),
	// 			Properties: &armavs.ExpressRouteAuthorizationProperties{
	// 				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"),
	// 				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"),
	// 				ProvisioningState: to.Ptr(armavs.ExpressRouteAuthorizationProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

type AuthorizationsClientBeginCreateOrUpdateOptions 

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

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

type AuthorizationsClientBeginDeleteOptions 

type AuthorizationsClientBeginDeleteOptions struct {
	// Resumes the LRO 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 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 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) NewIscsiPathsClient 

func (c *ClientFactory) NewIscsiPathsClient() *IscsiPathsClient

NewIscsiPathsClient creates a new instance of IscsiPathsClient.

func (*ClientFactory) NewLocationsClient 

func (c *ClientFactory) NewLocationsClient() *LocationsClient

NewLocationsClient creates a new instance of LocationsClient.

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) 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 struct {
	// The resource-specific properties for this resource.
	Properties *CloudLinkProperties

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

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

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

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

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

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/CloudLinks_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CloudLink = armavs.CloudLink{
// 	Name: to.Ptr("cloudLink1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/cloudLinks"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/cloudLinks/cloudLink1"),
// 	Properties: &armavs.CloudLinkProperties{
// 		LinkedCloud: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2"),
// 		Status: to.Ptr(armavs.CloudLinkStatusActive),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/CloudLinks_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/CloudLinks_Get.json 

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

Output:

func (*CloudLinksClient) NewListPager 

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

NewListPager - List CloudLink resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/CloudLinks_List.json 

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

Output:

type CloudLinksClientBeginCreateOrUpdateOptions 

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

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

type CloudLinksClientBeginDeleteOptions 

type CloudLinksClientBeginDeleteOptions struct {
	// Resumes the LRO 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewClustersClient().BeginCreateOrUpdate(ctx, "group1", "cloud1", "cluster1", armavs.Cluster{
	Properties: &armavs.ClusterProperties{
		ClusterSize: to.Ptr[int32](3),
	},
	SKU: &armavs.SKU{
		Name: to.Ptr("AV20"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Cluster = armavs.Cluster{
// 	Name: to.Ptr("cluster1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
// 	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),
// 		},
// 		SKU: &armavs.SKU{
// 			Name: to.Ptr("AV20"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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 cluster properties to be updated.
  • options - ClustersClientBeginUpdateOptions contains the optional parameters for the ClustersClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Cluster = armavs.Cluster{
// 	Name: to.Ptr("cluster1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
// 	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),
// 		},
// 		SKU: &armavs.SKU{
// 			Name: to.Ptr("AV20"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.Cluster = armavs.Cluster{
// 	Name: to.Ptr("cluster1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
// 	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),
// 		},
// 		SKU: &armavs.SKU{
// 			Name: to.Ptr("AV20"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_ListZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_ListZones_Stretched.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Clusters_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ClusterList = armavs.ClusterList{
	// 	Value: []*armavs.Cluster{
	// 		{
	// 			Name: to.Ptr("cluster1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/clusters"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1"),
	// 			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),
	// 				},
	// 				SKU: &armavs.SKU{
	// 					Name: to.Ptr("AV20"),
	// 				},
	// 		}},
	// 	}
}

Output:

type ClustersClientBeginCreateOrUpdateOptions 

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

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

type ClustersClientBeginDeleteOptions 

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

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

type ClustersClientBeginUpdateOptions 

type ClustersClientBeginUpdateOptions struct {
	// Resumes the LRO 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 type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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

	// 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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Datastores_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Datastore = armavs.Datastore{
// 	Name: to.Ptr("datastore1"),
// 	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/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),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Datastores_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Datastores_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.Datastore = armavs.Datastore{
// 	Name: to.Ptr("datastore1"),
// 	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/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),
// 	},
// }

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Datastores_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.DatastoreList = armavs.DatastoreList{
	// 	Value: []*armavs.Datastore{
	// 		{
	// 			Name: to.Ptr("datastore1"),
	// 			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/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),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("datastore2"),
	// 			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"),
	// 			Properties: &armavs.DatastoreProperties{
	// 				DiskPoolVolume: &armavs.DiskPoolVolume{
	// 					Path: to.Ptr("/vmfs/devices/disks/naa.6001405f75f6bdf7f6f49db8b4b21723"),
	// 					LunName: to.Ptr("lun0"),
	// 					MountOption: to.Ptr(armavs.MountOptionEnumMOUNT),
	// 					TargetID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/ResourceGroup1/providers/Microsoft.StoragePool/diskPools/DiskPool1/targets/Target1"),
	// 				},
	// 				ProvisioningState: to.Ptr(armavs.DatastoreProvisioningStateSucceeded),
	// 				Status: to.Ptr(armavs.DatastoreStatusAccessible),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("datastore2"),
	// 			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"),
	// 			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),
	// 			},
	// 	}},
	// }
}

Output:

type DatastoresClientBeginCreateOrUpdateOptions 

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

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

type DatastoresClientBeginDeleteOptions 

type DatastoresClientBeginDeleteOptions struct {
	// Resumes the LRO 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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 GlobalReachConnection 

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

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

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/GlobalReachConnections_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		AuthorizationKey:        to.Ptr("01010101-0101-0101-0101-010101010101"),
		PeerExpressRouteCircuit: to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.Network/expressRouteCircuits/mypeer"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.GlobalReachConnection = armavs.GlobalReachConnection{
// 	Name: to.Ptr("connection1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/globalReachConnections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/globalReachConnections/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),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/GlobalReachConnections_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/GlobalReachConnections_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.GlobalReachConnection = armavs.GlobalReachConnection{
// 	Name: to.Ptr("connection1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/globalReachConnections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/globalReachConnections/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),
// 	},
// }

Output:

func (*GlobalReachConnectionsClient) NewListPager 

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

NewListPager - List GlobalReachConnection resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/GlobalReachConnections_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.GlobalReachConnectionList = armavs.GlobalReachConnectionList{
	// 	Value: []*armavs.GlobalReachConnection{
	// 		{
	// 			Name: to.Ptr("connection1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/globalReachConnections"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/globalReachConnections/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),
	// 			},
	// 	}},
	// }
}

Output:

type GlobalReachConnectionsClientBeginCreateOrUpdateOptions 

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

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

type GlobalReachConnectionsClientBeginDeleteOptions 

type GlobalReachConnectionsClientBeginDeleteOptions struct {
	// Resumes the LRO 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/HcxEnterpriseSites_CreateOrUpdate.json 

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

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/HcxEnterpriseSites_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewHcxEnterpriseSitesClient().Delete(ctx, "group1", "cloud1", "site1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/HcxEnterpriseSites_Get.json 

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

Output:

func (*HcxEnterpriseSitesClient) NewListPager 

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

NewListPager - List HcxEnterpriseSite resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/HcxEnterpriseSites_List.json 

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

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 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 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/IscsiPaths_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.IscsiPath = armavs.IscsiPath{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/iscsiPaths"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/iscsiPaths/default"),
// 	Properties: &armavs.IscsiPathProperties{
// 		NetworkBlock: to.Ptr("192.168.0.0/24"),
// 		ProvisioningState: to.Ptr(armavs.IscsiPathProvisioningStateSucceeded),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/IscsiPaths_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/IscsiPaths_Get.json 

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

Output:

func (*IscsiPathsClient) NewListByPrivateCloudPager 

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

NewListByPrivateCloudPager - List IscsiPath resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/IscsiPaths_List.json 

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

Output:

type IscsiPathsClientBeginCreateOrUpdateOptions 

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

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

type IscsiPathsClientBeginDeleteOptions 

type IscsiPathsClientBeginDeleteOptions struct {
	// Resumes the LRO 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 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.

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

Generated from API version 2023-09-01

  • location - The name of the Azure region.
  • options - LocationsClientCheckQuotaAvailabilityOptions contains the optional parameters for the LocationsClient.CheckQuotaAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Locations_CheckQuotaAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.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.

Generated from API version 2023-09-01

  • location - The name of the Azure region.
  • options - LocationsClientCheckTrialAvailabilityOptions contains the optional parameters for the LocationsClient.CheckTrialAvailability method.
Example (LocationsCheckTrialAvailability)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Locations_CheckTrialAvailability.json 

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

Output:
Example (LocationsCheckTrialAvailabilityWithSku)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Locations_CheckTrialAvailabilityWithSku.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.Trial = armavs.Trial{
// 	AvailableHosts: to.Ptr[int32](4),
// 	Status: to.Ptr(armavs.TrialStatusTrialAvailable),
// }

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 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 - Mode that describes whether the LUN has to be mounted as a datastore or attached as a LUN 

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; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
	// operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for this particular operation.

func (OperationDisplay) MarshalJSON 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; URL to get the next set of operation list results (if there are any).
	NextLink *string

	// READ-ONLY; List of operations supported by the resource provider
	Value []*Operation
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

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

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - List the operations for the provider

Generated from API version 2023-09-01

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/Operations_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OperationListResult = armavs.OperationListResult{
	// 	Value: []*armavs.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/operations/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/register/action"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/unregister/action"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/checkNameAvailability/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/locations/checkNameAvailability/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/locations/checkQuotaAvailability/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/locations/checkTrialAvailability/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/register/action"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/write"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/delete"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/operationstatuses/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/write"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/delete"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/clusters/operationstatuses/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateclouds/clusters/operationresults/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/operationresults/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/authorizations/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/authorizations/write"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/authorizations/delete"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/listAdminCredentials/action"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites/write"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/hcxEnterpriseSites/delete"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/hostInstances/read"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/hostInstances/write"),
	// 			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),
	// 			Origin: to.Ptr(armavs.OriginUserSystem),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS/privateClouds/hostInstances/delete"),
	// 			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),
	// 			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     Origin = "system"
	OriginUser       Origin = "user"
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PSCredentialExecutionParameter 

type PSCredentialExecutionParameter struct {
	// REQUIRED; The parameter name
	Name *string

	// REQUIRED; script execution parameter type
	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 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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PlacementPolicies_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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),
		AffinityStrength:       to.Ptr(armavs.AffinityStrengthMust),
		AffinityType:           to.Ptr(armavs.AffinityTypeAntiAffinity),
		AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
		HostMembers: []*string{
			to.Ptr("fakehost22.nyc1.kubernetes.center"),
			to.Ptr("fakehost23.nyc1.kubernetes.center"),
			to.Ptr("fakehost24.nyc1.kubernetes.center")},
		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")},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PlacementPolicy = armavs.PlacementPolicy{
// 	Name: to.Ptr("policy1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
// 	Properties: &armavs.VMHostPlacementPolicyProperties{
// 		Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
// 		DisplayName: to.Ptr("policy1"),
// 		ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
// 		State: to.Ptr(armavs.PlacementPolicyStateEnabled),
// 		AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
// 		AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
// 		AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
// 		HostMembers: []*string{
// 			to.Ptr("fakehost22.nyc1.kubernetes.center"),
// 			to.Ptr("fakehost23.nyc1.kubernetes.center"),
// 			to.Ptr("fakehost24.nyc1.kubernetes.center")},
// 			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")},
// 			},
// 		}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PlacementPolicies_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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 placement policy properties to be updated.
  • options - PlacementPoliciesClientBeginUpdateOptions contains the optional parameters for the PlacementPoliciesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PlacementPolicies_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		AffinityStrength:       to.Ptr(armavs.AffinityStrengthMust),
		AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
		HostMembers: []*string{
			to.Ptr("fakehost22.nyc1.kubernetes.center"),
			to.Ptr("fakehost23.nyc1.kubernetes.center"),
			to.Ptr("fakehost24.nyc1.kubernetes.center")},
		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")},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PlacementPolicy = armavs.PlacementPolicy{
// 	Name: to.Ptr("policy1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
// 	Properties: &armavs.VMHostPlacementPolicyProperties{
// 		Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
// 		DisplayName: to.Ptr("policy1"),
// 		ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
// 		State: to.Ptr(armavs.PlacementPolicyStateDisabled),
// 		AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
// 		AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
// 		AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
// 		HostMembers: []*string{
// 			to.Ptr("fakehost22.nyc1.kubernetes.center"),
// 			to.Ptr("fakehost23.nyc1.kubernetes.center"),
// 			to.Ptr("fakehost24.nyc1.kubernetes.center")},
// 			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")},
// 			},
// 		}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PlacementPolicies_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PlacementPolicy = armavs.PlacementPolicy{
// 	Name: to.Ptr("policy1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
// 	Properties: &armavs.VMHostPlacementPolicyProperties{
// 		Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
// 		DisplayName: to.Ptr("policy1"),
// 		ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
// 		State: to.Ptr(armavs.PlacementPolicyStateEnabled),
// 		AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
// 		AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
// 		AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
// 		HostMembers: []*string{
// 			to.Ptr("fakehost22.nyc1.kubernetes.center"),
// 			to.Ptr("fakehost23.nyc1.kubernetes.center"),
// 			to.Ptr("fakehost24.nyc1.kubernetes.center")},
// 			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")},
// 			},
// 		}

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PlacementPolicies_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PlacementPoliciesList = armavs.PlacementPoliciesList{
	// 	Value: []*armavs.PlacementPolicy{
	// 		{
	// 			Name: to.Ptr("policy1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy1"),
	// 			Properties: &armavs.VMHostPlacementPolicyProperties{
	// 				Type: to.Ptr(armavs.PlacementPolicyTypeVMHost),
	// 				DisplayName: to.Ptr("policy1"),
	// 				ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
	// 				State: to.Ptr(armavs.PlacementPolicyStateEnabled),
	// 				AffinityStrength: to.Ptr(armavs.AffinityStrengthMust),
	// 				AffinityType: to.Ptr(armavs.AffinityTypeAntiAffinity),
	// 				AzureHybridBenefitType: to.Ptr(armavs.AzureHybridBenefitTypeSQLHost),
	// 				HostMembers: []*string{
	// 					to.Ptr("fakehost22.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost23.nyc1.kubernetes.center"),
	// 					to.Ptr("fakehost24.nyc1.kubernetes.center")},
	// 					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")},
	// 					},
	// 				},
	// 				{
	// 					Name: to.Ptr("policy2"),
	// 					Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/placementPolicies"),
	// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/placementPolicies/policy2"),
	// 					Properties: &armavs.VMPlacementPolicyProperties{
	// 						Type: to.Ptr(armavs.PlacementPolicyTypeVMVM),
	// 						DisplayName: to.Ptr("policy2"),
	// 						ProvisioningState: to.Ptr(armavs.PlacementPolicyProvisioningStateSucceeded),
	// 						State: to.Ptr(armavs.PlacementPolicyStateEnabled),
	// 						AffinityType: to.Ptr(armavs.AffinityTypeAffinity),
	// 						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")},
	// 						},
	// 				}},
	// 			}
}

Output:

type PlacementPoliciesClientBeginCreateOrUpdateOptions 

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

PlacementPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the PlacementPoliciesClient.BeginCreateOrUpdate method.

type PlacementPoliciesClientBeginDeleteOptions 

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

PlacementPoliciesClientBeginDeleteOptions contains the optional parameters for the PlacementPoliciesClient.BeginDelete method.

type PlacementPoliciesClientBeginUpdateOptions 

type PlacementPoliciesClientBeginUpdateOptions struct {
	// Resumes the LRO 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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

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

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

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

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

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; Type of managed service identity (either system assigned, or none).
	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

	// 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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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"),
	Tags:     map[string]*string{},
	Identity: &armavs.PrivateCloudIdentity{
		Type: to.Ptr(armavs.ResourceIdentityTypeSystemAssigned),
	},
	Properties: &armavs.PrivateCloudProperties{
		ManagementCluster: &armavs.ManagementCluster{
			ClusterSize: to.Ptr[int32](4),
		},
		NetworkBlock: to.Ptr("192.168.48.0/22"),
	},
	SKU: &armavs.SKU{
		Name: to.Ptr("AV36"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PrivateCloud = armavs.PrivateCloud{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
// 	Location: to.Ptr("eastus2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armavs.PrivateCloudProperties{
// 		Availability: &armavs.AvailabilityProperties{
// 			Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
// 			Zone: to.Ptr[int32](1),
// 		},
// 		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"),
// 		},
// 		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{
// 				{
// 					Name: to.Ptr("group1"),
// 					Alias: to.Ptr("groupAlias"),
// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
// 					BaseUserDN: to.Ptr("ou=baseUser"),
// 					Domain: to.Ptr("domain1"),
// 					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),
// 			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")},
// 				},
// 				NetworkBlock: to.Ptr("192.168.48.0/22"),
// 				ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
// 			},
// 			SKU: &armavs.SKU{
// 				Name: to.Ptr("AV36"),
// 			},
// 		}

Output:
Example (PrivateCloudsCreateOrUpdateStretched)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_CreateOrUpdate_Stretched.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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"),
	Tags:     map[string]*string{},
	Properties: &armavs.PrivateCloudProperties{
		Availability: &armavs.AvailabilityProperties{
			SecondaryZone: to.Ptr[int32](2),
			Strategy:      to.Ptr(armavs.AvailabilityStrategyDualZone),
			Zone:          to.Ptr[int32](1),
		},
		ManagementCluster: &armavs.ManagementCluster{
			ClusterSize: to.Ptr[int32](4),
		},
		NetworkBlock: to.Ptr("192.168.48.0/22"),
	},
	SKU: &armavs.SKU{
		Name: to.Ptr("AV36"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PrivateCloud = armavs.PrivateCloud{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
// 	Location: to.Ptr("eastus2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armavs.PrivateCloudProperties{
// 		Availability: &armavs.AvailabilityProperties{
// 			SecondaryZone: to.Ptr[int32](2),
// 			Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
// 			Zone: to.Ptr[int32](1),
// 		},
// 		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"),
// 		},
// 		Endpoints: &armavs.Endpoints{
// 			HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			HcxCloudManagerIP: to.Ptr("192.168.50.4"),
// 			NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			NsxtManagerIP: to.Ptr("192.168.50.3"),
// 			VcenterIP: to.Ptr("192.168.50.2"),
// 			Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 		},
// 		ExternalCloudLinks: []*string{
// 			to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
// 			IdentitySources: []*armavs.IdentitySource{
// 				{
// 					Name: to.Ptr("group1"),
// 					Alias: to.Ptr("groupAlias"),
// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
// 					BaseUserDN: to.Ptr("ou=baseUser"),
// 					Domain: to.Ptr("domain1"),
// 					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),
// 			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")},
// 				},
// 				NetworkBlock: to.Ptr("192.168.48.0/22"),
// 				ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
// 				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"),
// 				},
// 			},
// 			SKU: &armavs.SKU{
// 				Name: to.Ptr("AV36"),
// 			},
// 		}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_RotateNsxtPassword.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull 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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_RotateVcenterPassword.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull 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.

Generated from API version 2023-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • privateCloudName - Name of the private cloud
  • privateCloudUpdate - The private cloud properties to be updated.
  • options - PrivateCloudsClientBeginUpdateOptions contains the optional parameters for the PrivateCloudsClient.BeginUpdate method.
Example (PrivateCloudsUpdate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		Encryption: &armavs.Encryption{
			KeyVaultProperties: &armavs.EncryptionKeyVaultProperties{
				KeyName:     to.Ptr("keyname1"),
				KeyVaultURL: to.Ptr("https://keyvault1-kmip-kvault.vault.azure.net/"),
				KeyVersion:  to.Ptr("ver1.0"),
			},
			Status: to.Ptr(armavs.EncryptionStateEnabled),
		},
		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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PrivateCloud = armavs.PrivateCloud{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
// 	Location: to.Ptr("eastus2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armavs.PrivateCloudProperties{
// 		Availability: &armavs.AvailabilityProperties{
// 			Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
// 			Zone: to.Ptr[int32](1),
// 		},
// 		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"),
// 			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"),
// 			PrimarySubnet: to.Ptr("192.168.53.0/30"),
// 			SecondarySubnet: to.Ptr("192.168.53.4/30"),
// 		},
// 		Encryption: &armavs.Encryption{
// 			KeyVaultProperties: &armavs.EncryptionKeyVaultProperties{
// 				KeyName: to.Ptr("keyname1"),
// 				KeyVaultURL: to.Ptr("https://keyvault1-kmip-kvault.vault.azure.net/"),
// 				KeyVersion: to.Ptr("ver1.0"),
// 				VersionType: to.Ptr(armavs.EncryptionVersionTypeFixed),
// 			},
// 			Status: to.Ptr(armavs.EncryptionStateEnabled),
// 		},
// 		Endpoints: &armavs.Endpoints{
// 			HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			HcxCloudManagerIP: to.Ptr("192.168.50.4"),
// 			NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			NsxtManagerIP: to.Ptr("192.168.50.3"),
// 			VcenterIP: to.Ptr("192.168.50.2"),
// 			Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 		},
// 		ExternalCloudLinks: []*string{
// 			to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
// 			IdentitySources: []*armavs.IdentitySource{
// 				{
// 					Name: to.Ptr("group1"),
// 					Alias: to.Ptr("groupAlias"),
// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
// 					BaseUserDN: to.Ptr("ou=baseUser"),
// 					Domain: to.Ptr("domain1"),
// 					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),
// 			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")},
// 				},
// 				NetworkBlock: to.Ptr("192.168.48.0/22"),
// 				ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
// 			},
// 			SKU: &armavs.SKU{
// 				Name: to.Ptr("AV36"),
// 			},
// 		}

Output:
Example (PrivateCloudsUpdateStretched)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_Update_Stretched.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PrivateCloud = armavs.PrivateCloud{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
// 	Location: to.Ptr("eastus2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armavs.PrivateCloudProperties{
// 		Availability: &armavs.AvailabilityProperties{
// 			SecondaryZone: to.Ptr[int32](2),
// 			Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
// 			Zone: to.Ptr[int32](1),
// 		},
// 		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"),
// 			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"),
// 			PrimarySubnet: to.Ptr("192.168.53.0/30"),
// 			SecondarySubnet: to.Ptr("192.168.53.4/30"),
// 		},
// 		Endpoints: &armavs.Endpoints{
// 			HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			HcxCloudManagerIP: to.Ptr("192.168.50.4"),
// 			NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			NsxtManagerIP: to.Ptr("192.168.50.3"),
// 			VcenterIP: to.Ptr("192.168.50.2"),
// 			Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 		},
// 		ExternalCloudLinks: []*string{
// 			to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
// 			IdentitySources: []*armavs.IdentitySource{
// 				{
// 					Name: to.Ptr("group1"),
// 					Alias: to.Ptr("groupAlias"),
// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
// 					BaseUserDN: to.Ptr("ou=baseUser"),
// 					Domain: to.Ptr("domain1"),
// 					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),
// 			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")},
// 				},
// 				NetworkBlock: to.Ptr("192.168.48.0/22"),
// 				ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
// 				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"),
// 					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"),
// 					PrimarySubnet: to.Ptr("192.168.53.0/30"),
// 					SecondarySubnet: to.Ptr("192.168.53.4/30"),
// 				},
// 			},
// 			SKU: &armavs.SKU{
// 				Name: to.Ptr("AV36"),
// 			},
// 		}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PrivateCloud = armavs.PrivateCloud{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
// 	Location: to.Ptr("eastus2"),
// 	Tags: map[string]*string{
// 	},
// 	Identity: &armavs.PrivateCloudIdentity{
// 		Type: to.Ptr(armavs.ResourceIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("881e5573-063f-49e4-8c08-79d7df0169d8"),
// 		TenantID: to.Ptr("881e5573-063f-49e4-8c08-79d7df0169d8"),
// 	},
// 	Properties: &armavs.PrivateCloudProperties{
// 		Availability: &armavs.AvailabilityProperties{
// 			Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
// 			Zone: to.Ptr[int32](1),
// 		},
// 		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"),
// 			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"),
// 			PrimarySubnet: to.Ptr("192.168.53.0/30"),
// 			SecondarySubnet: to.Ptr("192.168.53.4/30"),
// 		},
// 		Encryption: &armavs.Encryption{
// 			KeyVaultProperties: &armavs.EncryptionKeyVaultProperties{
// 				KeyName: to.Ptr("keyname1"),
// 				KeyState: to.Ptr(armavs.EncryptionKeyStatusConnected),
// 				KeyVaultURL: to.Ptr("https://keyvault1-kmip-kvault.vault.azure.net/"),
// 				KeyVersion: to.Ptr("ver1.0"),
// 				VersionType: to.Ptr(armavs.EncryptionVersionTypeFixed),
// 			},
// 			Status: to.Ptr(armavs.EncryptionStateEnabled),
// 		},
// 		Endpoints: &armavs.Endpoints{
// 			HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			HcxCloudManagerIP: to.Ptr("192.168.50.4"),
// 			NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			NsxtManagerIP: to.Ptr("192.168.50.3"),
// 			VcenterIP: to.Ptr("192.168.50.2"),
// 			Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 		},
// 		ExternalCloudLinks: []*string{
// 			to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
// 			IdentitySources: []*armavs.IdentitySource{
// 				{
// 					Name: to.Ptr("group1"),
// 					Alias: to.Ptr("groupAlias"),
// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
// 					BaseUserDN: to.Ptr("ou=baseUser"),
// 					Domain: to.Ptr("domain1"),
// 					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),
// 			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")},
// 				},
// 				NetworkBlock: to.Ptr("192.168.48.0/22"),
// 				ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
// 			},
// 			SKU: &armavs.SKU{
// 				Name: to.Ptr("AV36"),
// 			},
// 		}

Output:
Example (PrivateCloudsGetStretched)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_Get_Stretched.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PrivateCloud = armavs.PrivateCloud{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
// 	Location: to.Ptr("eastus2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armavs.PrivateCloudProperties{
// 		Availability: &armavs.AvailabilityProperties{
// 			SecondaryZone: to.Ptr[int32](2),
// 			Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
// 			Zone: to.Ptr[int32](1),
// 		},
// 		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"),
// 			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"),
// 			PrimarySubnet: to.Ptr("192.168.53.0/30"),
// 			SecondarySubnet: to.Ptr("192.168.53.4/30"),
// 		},
// 		Endpoints: &armavs.Endpoints{
// 			HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			HcxCloudManagerIP: to.Ptr("192.168.50.4"),
// 			NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 			NsxtManagerIP: to.Ptr("192.168.50.3"),
// 			VcenterIP: to.Ptr("192.168.50.2"),
// 			Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
// 		},
// 		ExternalCloudLinks: []*string{
// 			to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
// 			IdentitySources: []*armavs.IdentitySource{
// 				{
// 					Name: to.Ptr("group1"),
// 					Alias: to.Ptr("groupAlias"),
// 					BaseGroupDN: to.Ptr("ou=baseGroup"),
// 					BaseUserDN: to.Ptr("ou=baseUser"),
// 					Domain: to.Ptr("domain1"),
// 					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),
// 			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")},
// 				},
// 				NetworkBlock: to.Ptr("192.168.48.0/22"),
// 				ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
// 				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"),
// 					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"),
// 					PrimarySubnet: to.Ptr("192.168.53.0/30"),
// 					SecondarySubnet: to.Ptr("192.168.53.4/30"),
// 				},
// 			},
// 			SKU: &armavs.SKU{
// 				Name: to.Ptr("AV36"),
// 			},
// 		}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_ListAdminCredentials.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.AdminCredentials = armavs.AdminCredentials{
// 	NsxtPassword: to.Ptr("$(1X4Dkk"),
// 	NsxtUsername: to.Ptr("admin"),
// 	VcenterPassword: to.Ptr("<vcenterPassword>"),
// 	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

Generated from API version 2023-09-01

  • options - PrivateCloudsClientListInSubscriptionOptions contains the optional parameters for the PrivateCloudsClient.NewListInSubscriptionPager method.
Example (PrivateCloudsListInSubscription)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_ListInSubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PrivateCloudList = armavs.PrivateCloudList{
	// 	Value: []*armavs.PrivateCloud{
	// 		{
	// 			Name: to.Ptr("cloud1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 			Location: to.Ptr("eastus2"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armavs.PrivateCloudProperties{
	// 				Availability: &armavs.AvailabilityProperties{
	// 					Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
	// 					Zone: to.Ptr[int32](1),
	// 				},
	// 				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"),
	// 					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"),
	// 					PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 					SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				},
	// 				Endpoints: &armavs.Endpoints{
	// 					HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 					NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 					VcenterIP: to.Ptr("192.168.50.2"),
	// 					Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				},
	// 				IdentitySources: []*armavs.IdentitySource{
	// 					{
	// 						Name: to.Ptr("group1"),
	// 						Alias: to.Ptr("groupAlias"),
	// 						BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 						BaseUserDN: to.Ptr("ou=baseUser"),
	// 						Domain: to.Ptr("domain1"),
	// 						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),
	// 				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")},
	// 					},
	// 					NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 					ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 				},
	// 				SKU: &armavs.SKU{
	// 					Name: to.Ptr("AV36"),
	// 				},
	// 		}},
	// 	}
}

Output:
Example (PrivateCloudsListInSubscriptionStretched)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_ListInSubscription_Stretched.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PrivateCloudList = armavs.PrivateCloudList{
	// 	Value: []*armavs.PrivateCloud{
	// 		{
	// 			Name: to.Ptr("cloud1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 			Location: to.Ptr("eastus2"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armavs.PrivateCloudProperties{
	// 				Availability: &armavs.AvailabilityProperties{
	// 					SecondaryZone: to.Ptr[int32](2),
	// 					Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
	// 					Zone: to.Ptr[int32](1),
	// 				},
	// 				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"),
	// 					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"),
	// 					PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 					SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				},
	// 				Endpoints: &armavs.Endpoints{
	// 					HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 					NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 					VcenterIP: to.Ptr("192.168.50.2"),
	// 					Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				},
	// 				IdentitySources: []*armavs.IdentitySource{
	// 					{
	// 						Name: to.Ptr("group1"),
	// 						Alias: to.Ptr("groupAlias"),
	// 						BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 						BaseUserDN: to.Ptr("ou=baseUser"),
	// 						Domain: to.Ptr("domain1"),
	// 						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),
	// 				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")},
	// 					},
	// 					NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 					ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 					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"),
	// 						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"),
	// 						PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 						SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 					},
	// 				},
	// 				SKU: &armavs.SKU{
	// 					Name: to.Ptr("AV36"),
	// 				},
	// 		}},
	// 	}
}

Output:

func (*PrivateCloudsClient) NewListPager 

func (client *PrivateCloudsClient) NewListPager(resourceGroupName string, options *PrivateCloudsClientListOptions) *runtime.Pager[PrivateCloudsClientListResponse]

NewListPager - List PrivateCloud resources by resource group

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PrivateCloudList = armavs.PrivateCloudList{
	// 	Value: []*armavs.PrivateCloud{
	// 		{
	// 			Name: to.Ptr("cloud1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 			Location: to.Ptr("eastus2"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armavs.PrivateCloudProperties{
	// 				Availability: &armavs.AvailabilityProperties{
	// 					Strategy: to.Ptr(armavs.AvailabilityStrategySingleZone),
	// 					Zone: to.Ptr[int32](1),
	// 				},
	// 				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"),
	// 					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"),
	// 					PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 					SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				},
	// 				Endpoints: &armavs.Endpoints{
	// 					HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 					NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 					VcenterIP: to.Ptr("192.168.50.2"),
	// 					Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				},
	// 				ExternalCloudLinks: []*string{
	// 					to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
	// 					IdentitySources: []*armavs.IdentitySource{
	// 						{
	// 							Name: to.Ptr("group1"),
	// 							Alias: to.Ptr("groupAlias"),
	// 							BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 							BaseUserDN: to.Ptr("ou=baseUser"),
	// 							Domain: to.Ptr("domain1"),
	// 							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),
	// 					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")},
	// 						},
	// 						NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 						ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 					},
	// 					SKU: &armavs.SKU{
	// 						Name: to.Ptr("AV36"),
	// 					},
	// 			}},
	// 		}
}

Output:
Example (PrivateCloudsListStretched)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/PrivateClouds_List_Stretched.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.PrivateCloudList = armavs.PrivateCloudList{
	// 	Value: []*armavs.PrivateCloud{
	// 		{
	// 			Name: to.Ptr("cloud1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1"),
	// 			Location: to.Ptr("eastus2"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armavs.PrivateCloudProperties{
	// 				Availability: &armavs.AvailabilityProperties{
	// 					SecondaryZone: to.Ptr[int32](2),
	// 					Strategy: to.Ptr(armavs.AvailabilityStrategyDualZone),
	// 					Zone: to.Ptr[int32](1),
	// 				},
	// 				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"),
	// 					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"),
	// 					PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 					SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 				},
	// 				Endpoints: &armavs.Endpoints{
	// 					HcxCloudManager: to.Ptr("https://hcx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					HcxCloudManagerIP: to.Ptr("192.168.50.4"),
	// 					NsxtManager: to.Ptr("https://nsx.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 					NsxtManagerIP: to.Ptr("192.168.50.3"),
	// 					VcenterIP: to.Ptr("192.168.50.2"),
	// 					Vcsa: to.Ptr("https://vc.290351365f5b41a19b77af.eastus.avslab.azure.com/"),
	// 				},
	// 				ExternalCloudLinks: []*string{
	// 					to.Ptr("/subscriptions/12341234-1234-1234-1234-123412341234/resourceGroups/mygroup/providers/Microsoft.AVS/privateClouds/cloud2")},
	// 					IdentitySources: []*armavs.IdentitySource{
	// 						{
	// 							Name: to.Ptr("group1"),
	// 							Alias: to.Ptr("groupAlias"),
	// 							BaseGroupDN: to.Ptr("ou=baseGroup"),
	// 							BaseUserDN: to.Ptr("ou=baseUser"),
	// 							Domain: to.Ptr("domain1"),
	// 							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),
	// 					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")},
	// 						},
	// 						NetworkBlock: to.Ptr("192.168.48.0/22"),
	// 						ProvisioningState: to.Ptr(armavs.PrivateCloudProvisioningStateSucceeded),
	// 						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"),
	// 							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"),
	// 							PrimarySubnet: to.Ptr("192.168.53.0/30"),
	// 							SecondarySubnet: to.Ptr("192.168.53.4/30"),
	// 						},
	// 					},
	// 					SKU: &armavs.SKU{
	// 						Name: to.Ptr("AV36"),
	// 					},
	// 			}},
	// 		}
}

Output:

type PrivateCloudsClientBeginCreateOrUpdateOptions 

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

PrivateCloudsClientBeginCreateOrUpdateOptions contains the optional parameters for the PrivateCloudsClient.BeginCreateOrUpdate method.

type PrivateCloudsClientBeginDeleteOptions 

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

PrivateCloudsClientBeginDeleteOptions contains the optional parameters for the PrivateCloudsClient.BeginDelete method.

type PrivateCloudsClientBeginRotateNsxtPasswordOptions 

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

PrivateCloudsClientBeginRotateNsxtPasswordOptions contains the optional parameters for the PrivateCloudsClient.BeginRotateNsxtPassword method.

type PrivateCloudsClientBeginRotateVcenterPasswordOptions 

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

PrivateCloudsClientBeginRotateVcenterPasswordOptions contains the optional parameters for the PrivateCloudsClient.BeginRotateVcenterPassword method.

type PrivateCloudsClientBeginUpdateOptions 

type PrivateCloudsClientBeginUpdateOptions struct {
	// Resumes the LRO 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 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 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 ResourceIdentityType 

type ResourceIdentityType string

ResourceIdentityType - Type of managed service identity (either system assigned, or none). 

const (
	ResourceIdentityTypeNone           ResourceIdentityType = "None"
	ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
)

func PossibleResourceIdentityTypeValues 

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type SKU 

type SKU struct {
	// REQUIRED; The name of the SKU. E.g. 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    SKUTier = "Basic"
	SKUTierFree     SKUTier = "Free"
	SKUTierPremium  SKUTier = "Premium"
	SKUTierStandard SKUTier = "Standard"
)

func PossibleSKUTierValues 

func PossibleSKUTierValues() []SKUTier

PossibleSKUTierValues returns the possible values for the SKUTier const type.

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 ScriptCmdlet 

type ScriptCmdlet struct {
	// The resource-specific properties for this resource.
	Properties *ScriptCmdletProperties

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

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptCmdlets_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptCmdlet = armavs.ScriptCmdlet{
// 	Name: to.Ptr("New-ExternalSsoDomain"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages/scriptCmdlets"),
// 	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"),
// 		Audience: to.Ptr(armavs.ScriptCmdletAudienceAny),
// 		Parameters: []*armavs.ScriptParameter{
// 			{
// 				Name: to.Ptr("DomainName"),
// 				Type: to.Ptr(armavs.ScriptParameterTypesString),
// 				Description: to.Ptr("Domain name of the Server"),
// 				Optional: to.Ptr(armavs.OptionalParamEnumRequired),
// 				Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
// 			},
// 			{
// 				Name: to.Ptr("BaseUserDN"),
// 				Type: to.Ptr(armavs.ScriptParameterTypesString),
// 				Description: to.Ptr("Base User DN of the Server"),
// 				Optional: to.Ptr(armavs.OptionalParamEnumRequired),
// 				Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
// 			},
// 			{
// 				Name: to.Ptr("Password"),
// 				Type: to.Ptr(armavs.ScriptParameterTypesSecureString),
// 				Description: to.Ptr("Password for authenticating to the server"),
// 				Optional: to.Ptr(armavs.OptionalParamEnumRequired),
// 				Visibility: to.Ptr(armavs.VisibilityParameterEnumHidden),
// 		}},
// 		Timeout: to.Ptr("P0Y0M0DT0H60M0S"),
// 	},
// }

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptCmdlets_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptCmdletsList = armavs.ScriptCmdletsList{
	// 	Value: []*armavs.ScriptCmdlet{
	// 		{
	// 			Name: to.Ptr("Set-AvsStoragePolicy"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages/scriptCmdlets"),
	// 			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"),
	// 				Audience: to.Ptr(armavs.ScriptCmdletAudienceAny),
	// 				Parameters: []*armavs.ScriptParameter{
	// 					{
	// 						Name: to.Ptr("VM"),
	// 						Type: to.Ptr(armavs.ScriptParameterTypesString),
	// 						Description: to.Ptr("VM to set the storage policy on"),
	// 						Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 						Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
	// 					},
	// 					{
	// 						Name: to.Ptr("StoragePolicyName"),
	// 						Type: to.Ptr(armavs.ScriptParameterTypesString),
	// 						Description: to.Ptr("Name of the storage policy to set"),
	// 						Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 						Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
	// 				}},
	// 				Timeout: to.Ptr("P0Y0M0DT0H60M0S"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("New-ExternalSsoDomain"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages/scriptCmdlets"),
	// 			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"),
	// 				Audience: to.Ptr(armavs.ScriptCmdletAudienceAny),
	// 				Parameters: []*armavs.ScriptParameter{
	// 					{
	// 						Name: to.Ptr("DomainName"),
	// 						Type: to.Ptr(armavs.ScriptParameterTypesString),
	// 						Description: to.Ptr("Domain name of the Server"),
	// 						Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 						Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
	// 					},
	// 					{
	// 						Name: to.Ptr("BaseUserDN"),
	// 						Type: to.Ptr(armavs.ScriptParameterTypesString),
	// 						Description: to.Ptr("Base User DN of the Server"),
	// 						Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 						Visibility: to.Ptr(armavs.VisibilityParameterEnumVisible),
	// 					},
	// 					{
	// 						Name: to.Ptr("Password"),
	// 						Type: to.Ptr(armavs.ScriptParameterTypesSecureString),
	// 						Description: to.Ptr("Password for authenticating to the server"),
	// 						Optional: to.Ptr(armavs.OptionalParamEnumRequired),
	// 						Visibility: to.Ptr(armavs.VisibilityParameterEnumHidden),
	// 				}},
	// 				Timeout: to.Ptr("P0Y0M0DT0H60M0S"),
	// 			},
	// 	}},
	// }
}

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptExecutions_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		HiddenParameters: []armavs.ScriptExecutionParameterClassification{
			&armavs.ScriptSecureStringExecutionParameter{
				Name:        to.Ptr("Password"),
				Type:        to.Ptr(armavs.ScriptExecutionParameterTypeSecureValue),
				SecureValue: to.Ptr("PlaceholderPassword"),
			}},
		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"),
			}},
		Retention:      to.Ptr("P0Y0M60DT0H60M60S"),
		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"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ScriptExecution = armavs.ScriptExecution{
// 	Name: to.Ptr("addSsoServer"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/scriptExecutions"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
// 	Properties: &armavs.ScriptExecutionProperties{
// 		FailureReason: to.Ptr("vCenter failed to connect to the external server"),

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptExecutions_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptExecutions_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptExecution = armavs.ScriptExecution{
// 	Name: to.Ptr("addSsoServer"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/scriptExecutions"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
// 	Properties: &armavs.ScriptExecutionProperties{
// 		FailureReason: to.Ptr("vCenter failed to connect to the external server"),
// 		FinishedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-21T18:32:28.000Z"); return t}()),
// 		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"),
// 		}},
// 		ProvisioningState: to.Ptr(armavs.ScriptExecutionProvisioningStateSucceeded),
// 		Retention: to.Ptr("P0Y0M60DT0H60M60S"),
// 		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"),
// 		StartedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-21T17:32:28.000Z"); return t}()),
// 		SubmittedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-21T17:31:28.000Z"); return t}()),
// 		Timeout: to.Ptr("P0Y0M0DT0H60M60S"),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptExecutions_GetExecutionLogs.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptExecution = armavs.ScriptExecution{
// 	Name: to.Ptr("addSsoServer"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
// 	Properties: &armavs.ScriptExecutionProperties{
// 		Errors: []*string{
// 			to.Ptr("Most recent error output"),
// 			to.Ptr("Second most error recent output")},
// 			Information: []*string{
// 				to.Ptr("Most recent information output"),
// 				to.Ptr("Second most recent information output")},

Output:

func (*ScriptExecutionsClient) NewListPager 

func (client *ScriptExecutionsClient) NewListPager(resourceGroupName string, privateCloudName string, options *ScriptExecutionsClientListOptions) *runtime.Pager[ScriptExecutionsClientListResponse]

NewListPager - List ScriptExecution resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptExecutions_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptExecutionsList = armavs.ScriptExecutionsList{
	// 	Value: []*armavs.ScriptExecution{
	// 		{
	// 			Name: to.Ptr("addSsoServer"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/scriptExecutions"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptExecutions/addSsoServer"),
	// 			Properties: &armavs.ScriptExecutionProperties{
	// 				FailureReason: to.Ptr("vCenter failed to connect to the external server"),
	// 				FinishedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-21T18:32:28.000Z"); return t}()),
	// 				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"),
	// 				}},
	// 				ProvisioningState: to.Ptr(armavs.ScriptExecutionProvisioningStateSucceeded),
	// 				Retention: to.Ptr("P0Y0M60DT0H60M60S"),
	// 				ScriptCmdletID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/scriptPackages/AVS:1.0.0/scriptCmdlets/New-SsoExternalIdentitySource"),
	// 				StartedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-21T17:32:28.000Z"); return t}()),
	// 				SubmittedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-21T17:31:28.000Z"); return t}()),
	// 				Timeout: to.Ptr("P0Y0M0DT0H60M60S"),
	// 			},
	// 	}},
	// }
}

Output:

type ScriptExecutionsClientBeginCreateOrUpdateOptions 

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

ScriptExecutionsClientBeginCreateOrUpdateOptions contains the optional parameters for the ScriptExecutionsClient.BeginCreateOrUpdate method.

type ScriptExecutionsClientBeginDeleteOptions 

type ScriptExecutionsClientBeginDeleteOptions struct {
	// Resumes the LRO 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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptPackages_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptPackage = armavs.ScriptPackage{
// 	Name: to.Ptr("Microsoft.AVS.Management@3.0.48"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages"),
// 	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"),
// 		Company: to.Ptr("Microsoft"),
// 		URI: to.Ptr("https://microsoft.com"),
// 		Version: to.Ptr("3.0.48"),
// 	},
// }

Output:

func (*ScriptPackagesClient) NewListPager 

func (client *ScriptPackagesClient) NewListPager(resourceGroupName string, privateCloudName string, options *ScriptPackagesClientListOptions) *runtime.Pager[ScriptPackagesClientListResponse]

NewListPager - List ScriptPackage resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/ScriptPackages_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.ScriptPackagesList = armavs.ScriptPackagesList{
	// 	Value: []*armavs.ScriptPackage{
	// 		{
	// 			Name: to.Ptr("Microsoft.AVS.Management@3.0.48"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages"),
	// 			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"),
	// 				Company: to.Ptr("Microsoft"),
	// 				URI: to.Ptr("https://microsoft.com"),
	// 				Version: to.Ptr("3.0.48"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("JSDR.Configuration@1.0.0"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/scriptPackages"),
	// 			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"),
	// 				Company: to.Ptr("Jetstream Software"),
	// 				URI: to.Ptr("https://www.jetstreamsoft.com/about/support/"),
	// 				Version: to.Ptr("1.0.0"),
	// 			},
	// 	}},
	// }
}

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

	// REQUIRED; script execution parameter type
	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

	// REQUIRED; script execution parameter type
	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 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

	// REQUIRED; Placement Policy type
	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

	// REQUIRED; Placement Policy type
	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 VirtualMachine 

type VirtualMachine struct {
	// The resource-specific properties for this resource.
	Properties *VirtualMachineProperties

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

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

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

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

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; Virtual machine managed object reference id
	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.

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

Generated from API version 2023-09-01

  • 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 body type of the operation request.
  • options - VirtualMachinesClientBeginRestrictMovementOptions contains the optional parameters for the VirtualMachinesClient.BeginRestrictMovement method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/VirtualMachines_RestrictMovement.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull 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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/VirtualMachines_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.VirtualMachine = armavs.VirtualMachine{
// 	Name: to.Ptr("vm-209"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/virtualMachines"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-209"),
// 	Properties: &armavs.VirtualMachineProperties{
// 		DisplayName: to.Ptr("contoso-vm"),
// 		FolderPath: to.Ptr("vm/folder-1"),
// 		MoRefID: to.Ptr("vm-209"),
// 		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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/VirtualMachines_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.VirtualMachinesList = armavs.VirtualMachinesList{
	// 	Value: []*armavs.VirtualMachine{
	// 		{
	// 			Name: to.Ptr("vm-209"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/virtualMachines"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-209"),
	// 			Properties: &armavs.VirtualMachineProperties{
	// 				DisplayName: to.Ptr("contoso-vm1"),
	// 				FolderPath: to.Ptr("vm/folder-1"),
	// 				MoRefID: to.Ptr("vm-209"),
	// 				RestrictMovement: to.Ptr(armavs.VirtualMachineRestrictMovementStateDisabled),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vm-128"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/clusters/virtualMachines"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/clusters/cluster1/virtualMachines/vm-128"),
	// 			Properties: &armavs.VirtualMachineProperties{
	// 				DisplayName: to.Ptr("contoso-vm2"),
	// 				FolderPath: to.Ptr("vm"),
	// 				MoRefID: to.Ptr("vm-128"),
	// 				RestrictMovement: to.Ptr(armavs.VirtualMachineRestrictMovementStateEnabled),
	// 			},
	// 	}},
	// }
}

Output:

type VirtualMachinesClientBeginRestrictMovementOptions 

type VirtualMachinesClientBeginRestrictMovementOptions struct {
	// Resumes the LRO 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 WorkloadNetwork 

type WorkloadNetwork struct {
	// The resource-specific properties for this resource.
	Properties *WorkloadNetworkProperties

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

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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 {
	// REQUIRED; Type of DHCP: SERVER or RELAY.
	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 {
	// REQUIRED; Type of DHCP: SERVER or RELAY.
	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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

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

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

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

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.

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

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreateDnsService.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		DefaultDNSZone: to.Ptr("defaultDnsZone1"),
		DisplayName:    to.Ptr("dnsService1"),
		DNSServiceIP:   to.Ptr("5.5.5.5"),
		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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkDNSService = armavs.WorkloadNetworkDNSService{
// 	Name: to.Ptr("dnsService1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
// 	Properties: &armavs.WorkloadNetworkDNSServiceProperties{
// 		DefaultDNSZone: to.Ptr("defaultDnsZone1"),
// 		DisplayName: to.Ptr("dnsService1"),
// 		DNSServiceIP: to.Ptr("5.5.5.5"),
// 		FqdnZones: []*string{
// 			to.Ptr("fqdnZone1")},
// 			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
// 			Revision: to.Ptr[int64](1),
// 			Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreateDnsZone.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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"),
		DNSServerIPs: []*string{
			to.Ptr("1.1.1.1")},
		Domain:   []*string{},
		Revision: to.Ptr[int64](1),
		SourceIP: to.Ptr("8.8.8.8"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkDNSZone = armavs.WorkloadNetworkDNSZone{
// 	Name: to.Ptr("dnsZone1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
// 	Properties: &armavs.WorkloadNetworkDNSZoneProperties{
// 		DisplayName: to.Ptr("dnsZone1"),
// 		DNSServerIPs: []*string{
// 			to.Ptr("1.1.1.1")},
// 			DNSServices: to.Ptr[int64](0),
// 			Domain: []*string{
// 			},
// 			Revision: to.Ptr[int64](1),
// 			SourceIP: to.Ptr("8.8.8.8"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreateDhcp.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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"),
		Revision:      to.Ptr[int64](1),
		LeaseTime:     to.Ptr[int64](86400),
		ServerAddress: to.Ptr("40.1.5.1/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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkDhcp = armavs.WorkloadNetworkDhcp{
// 	Name: to.Ptr("dhcp1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
// 	Properties: &armavs.WorkloadNetworkDhcpServer{
// 		DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
// 		DisplayName: to.Ptr("dhcpConfigurations1"),
// 		Revision: to.Ptr[int64](1),
// 		Segments: []*string{
// 			to.Ptr("segment1"),
// 			to.Ptr("segment2")},
// 			LeaseTime: to.Ptr[int64](86400),
// 			ServerAddress: to.Ptr("40.1.5.1/24"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreatePortMirroring.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		Destination: to.Ptr("vmGroup2"),
		Direction:   to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
		DisplayName: to.Ptr("portMirroring1"),
		Revision:    to.Ptr[int64](1),
		Source:      to.Ptr("vmGroup1"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkPortMirroring = armavs.WorkloadNetworkPortMirroring{
// 	Name: to.Ptr("portMirroring1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
// 	Properties: &armavs.WorkloadNetworkPortMirroringProperties{
// 		Destination: to.Ptr("vmGroup2"),
// 		Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
// 		DisplayName: to.Ptr("portMirroring1"),
// 		Revision: to.Ptr[int64](1),
// 		Source: to.Ptr("vmGroup1"),
// 		Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreatePublicIP.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkPublicIP = armavs.WorkloadNetworkPublicIP{
// 	Name: to.Ptr("publicIP1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/publicIPs"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/publicIPs/publicIP1"),
// 	Properties: &armavs.WorkloadNetworkPublicIPProperties{
// 		DisplayName: to.Ptr("publicIP1"),
// 		PublicIPBlock: to.Ptr("20.20.40.50/32"),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreateSegments.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
		DisplayName:      to.Ptr("segment1"),
		Revision:         to.Ptr[int64](1),
		Subnet: &armavs.WorkloadNetworkSegmentSubnet{
			DhcpRanges: []*string{
				to.Ptr("40.20.0.0-40.20.0.1")},
			GatewayAddress: to.Ptr("40.20.20.20/16"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkSegment = armavs.WorkloadNetworkSegment{
// 	Name: to.Ptr("segment1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
// 	Properties: &armavs.WorkloadNetworkSegmentProperties{
// 		ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
// 		DisplayName: to.Ptr("segment1"),
// 		PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
// 		},
// 		Revision: to.Ptr[int64](1),
// 		Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
// 		Subnet: &armavs.WorkloadNetworkSegmentSubnet{
// 			DhcpRanges: []*string{
// 				to.Ptr("40.20.0.0-40.20.0.1")},
// 				GatewayAddress: to.Ptr("40.20.20.20/16"),
// 			},
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_CreateVMGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkVMGroup = armavs.WorkloadNetworkVMGroup{
// 	Name: to.Ptr("vmGroup1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
// 	Properties: &armavs.WorkloadNetworkVMGroupProperties{
// 		DisplayName: to.Ptr("vmGroup1"),
// 		Members: []*string{
// 			to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50")},
// 			Revision: to.Ptr[int64](1),
// 			Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeleteDnsService.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeleteDnsZone.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeleteDhcp.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeletePortMirroring.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeletePublicIP.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeleteSegment.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_DeleteVMGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_UpdateDnsService.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		DefaultDNSZone: to.Ptr("defaultDnsZone1"),
		DisplayName:    to.Ptr("dnsService1"),
		DNSServiceIP:   to.Ptr("5.5.5.5"),
		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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkDNSService = armavs.WorkloadNetworkDNSService{
// 	Name: to.Ptr("dnsService1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
// 	Properties: &armavs.WorkloadNetworkDNSServiceProperties{
// 		DefaultDNSZone: to.Ptr("defaultDnsZone1"),
// 		DisplayName: to.Ptr("dnsService1"),
// 		DNSServiceIP: to.Ptr("5.5.5.5"),
// 		FqdnZones: []*string{
// 			to.Ptr("fqdnZone1")},
// 			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
// 			Revision: to.Ptr[int64](1),
// 			Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_UpdateDnsZone.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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"),
		DNSServerIPs: []*string{
			to.Ptr("1.1.1.1")},
		Domain:   []*string{},
		Revision: to.Ptr[int64](1),
		SourceIP: to.Ptr("8.8.8.8"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkDNSZone = armavs.WorkloadNetworkDNSZone{
// 	Name: to.Ptr("dnsZone1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
// 	Properties: &armavs.WorkloadNetworkDNSZoneProperties{
// 		DisplayName: to.Ptr("dnsZone1"),
// 		DNSServerIPs: []*string{
// 			to.Ptr("1.1.1.1")},
// 			DNSServices: to.Ptr[int64](0),
// 			Domain: []*string{
// 			},
// 			Revision: to.Ptr[int64](1),
// 			SourceIP: to.Ptr("8.8.8.8"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_UpdateDhcp.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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),
		Revision:      to.Ptr[int64](1),
		LeaseTime:     to.Ptr[int64](86400),
		ServerAddress: to.Ptr("40.1.5.1/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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkDhcp = armavs.WorkloadNetworkDhcp{
// 	Name: to.Ptr("dhcp1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
// 	Properties: &armavs.WorkloadNetworkDhcpServer{
// 		DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
// 		DisplayName: to.Ptr("dhcpConfigurations1"),
// 		Revision: to.Ptr[int64](2),
// 		Segments: []*string{
// 			to.Ptr("segment1"),
// 			to.Ptr("segment2")},
// 			LeaseTime: to.Ptr[int64](86400),
// 			ServerAddress: to.Ptr("40.1.5.1/24"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_UpdatePortMirroring.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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{
		Destination: to.Ptr("vmGroup2"),
		Direction:   to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
		Revision:    to.Ptr[int64](1),
		Source:      to.Ptr("vmGroup1"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkPortMirroring = armavs.WorkloadNetworkPortMirroring{
// 	Name: to.Ptr("portMirroring1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
// 	Properties: &armavs.WorkloadNetworkPortMirroringProperties{
// 		Destination: to.Ptr("vmGroup2"),
// 		Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
// 		DisplayName: to.Ptr("portMirroring1"),
// 		Revision: to.Ptr[int64](2),
// 		Source: to.Ptr("vmGroup1"),
// 		Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_UpdateSegments.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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"),
		Revision:         to.Ptr[int64](1),
		Subnet: &armavs.WorkloadNetworkSegmentSubnet{
			DhcpRanges: []*string{
				to.Ptr("40.20.0.0-40.20.0.1")},
			GatewayAddress: to.Ptr("40.20.20.20/16"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkSegment = armavs.WorkloadNetworkSegment{
// 	Name: to.Ptr("segment1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
// 	Properties: &armavs.WorkloadNetworkSegmentProperties{
// 		ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
// 		DisplayName: to.Ptr("segment1"),
// 		PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
// 			{
// 				PortName: to.Ptr("vm1"),
// 		}},
// 		Revision: to.Ptr[int64](2),
// 		Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
// 		Subnet: &armavs.WorkloadNetworkSegmentSubnet{
// 			DhcpRanges: []*string{
// 				to.Ptr("40.20.0.0-40.20.0.1")},
// 				GatewayAddress: to.Ptr("40.20.20.20/16"),
// 			},
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_UpdateVMGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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 pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.WorkloadNetworkVMGroup = armavs.WorkloadNetworkVMGroup{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
// 	Properties: &armavs.WorkloadNetworkVMGroupProperties{
// 		DisplayName: to.Ptr("vmGroup1"),
// 		Members: []*string{
// 			to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50")},
// 			Revision: to.Ptr[int64](2),
// 			Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetwork = armavs.WorkloadNetwork{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default"),
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetDnsService.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkDNSService = armavs.WorkloadNetworkDNSService{
// 	Name: to.Ptr("portMirroring1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
// 	Properties: &armavs.WorkloadNetworkDNSServiceProperties{
// 		DefaultDNSZone: to.Ptr("defaultDnsZone1"),
// 		DisplayName: to.Ptr("dnsService1"),
// 		DNSServiceIP: to.Ptr("5.5.5.5"),
// 		FqdnZones: []*string{
// 			to.Ptr("fqdnZone1")},
// 			LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
// 			Revision: to.Ptr[int64](1),
// 			Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetDnsZone.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkDNSZone = armavs.WorkloadNetworkDNSZone{
// 	Name: to.Ptr("portMirroring1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
// 	Properties: &armavs.WorkloadNetworkDNSZoneProperties{
// 		DisplayName: to.Ptr("dnsZone1"),
// 		DNSServerIPs: []*string{
// 			to.Ptr("1.1.1.1")},
// 			DNSServices: to.Ptr[int64](0),
// 			Domain: []*string{
// 			},
// 			Revision: to.Ptr[int64](1),
// 			SourceIP: to.Ptr("8.8.8.8"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetDhcp.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkDhcp = armavs.WorkloadNetworkDhcp{
// 	Name: to.Ptr("dhcp1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
// 	Properties: &armavs.WorkloadNetworkDhcpServer{
// 		DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
// 		DisplayName: to.Ptr("dhcpConfigurations1"),
// 		Revision: to.Ptr[int64](1),
// 		Segments: []*string{
// 			to.Ptr("segment1"),
// 			to.Ptr("segment2")},
// 			LeaseTime: to.Ptr[int64](86400),
// 			ServerAddress: to.Ptr("40.1.5.1/24"),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetGateway.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkGateway = armavs.WorkloadNetworkGateway{
// 	Name: to.Ptr("gateway1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/gateways"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/gateways/gateway1"),
// 	Properties: &armavs.WorkloadNetworkGatewayProperties{
// 		Path: to.Ptr("/infra/tier-1s/gateway1"),
// 		DisplayName: to.Ptr("gateway1"),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetPortMirroring.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkPortMirroring = armavs.WorkloadNetworkPortMirroring{
// 	Name: to.Ptr("portMirroring1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
// 	Properties: &armavs.WorkloadNetworkPortMirroringProperties{
// 		Destination: to.Ptr("vmGroup2"),
// 		Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
// 		DisplayName: to.Ptr("portMirroring1"),
// 		Revision: to.Ptr[int64](1),
// 		Source: to.Ptr("vmGroup1"),
// 		Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetPublicIP.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkPublicIP = armavs.WorkloadNetworkPublicIP{
// 	Name: to.Ptr("publicIP1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/publicIPs"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/publicIPs/publicIP1"),
// 	Properties: &armavs.WorkloadNetworkPublicIPProperties{
// 		DisplayName: to.Ptr("publicIP1"),
// 		PublicIPBlock: to.Ptr("20.20.40.50/32"),
// 	},
// }

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetSegment.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkSegment = armavs.WorkloadNetworkSegment{
// 	Name: to.Ptr("segment1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
// 	Properties: &armavs.WorkloadNetworkSegmentProperties{
// 		ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
// 		DisplayName: to.Ptr("segment1"),
// 		PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
// 			{
// 				PortName: to.Ptr("vm1"),
// 		}},
// 		Revision: to.Ptr[int64](1),
// 		Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
// 		Subnet: &armavs.WorkloadNetworkSegmentSubnet{
// 			DhcpRanges: []*string{
// 				to.Ptr("40.20.0.0-40.20.0.1")},
// 				GatewayAddress: to.Ptr("40.20.20.20/16"),
// 			},
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetVMGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkVMGroup = armavs.WorkloadNetworkVMGroup{
// 	Name: to.Ptr("cloud1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
// 	Properties: &armavs.WorkloadNetworkVMGroupProperties{
// 		DisplayName: to.Ptr("vmGroup1"),
// 		Members: []*string{
// 			to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50")},
// 			Revision: to.Ptr[int64](1),
// 			Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
// 		},
// 	}

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.

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_GetVirtualMachine.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkVirtualMachine = armavs.WorkloadNetworkVirtualMachine{
// 	Name: to.Ptr("vm1"),
// 	Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/virtualMachines"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/virtualMachines/vm1"),
// 	Properties: &armavs.WorkloadNetworkVirtualMachineProperties{
// 		DisplayName: to.Ptr("vm1"),
// 		VMType: to.Ptr(armavs.VMTypeEnumREGULAR),
// 	},
// }

Output:

func (*WorkloadNetworksClient) NewListDNSServicesPager 

func (client *WorkloadNetworksClient) NewListDNSServicesPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListDNSServicesOptions) *runtime.Pager[WorkloadNetworksClientListDNSServicesResponse]

NewListDNSServicesPager - List WorkloadNetworkDnsService resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListDnsServices.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkDNSServicesList = armavs.WorkloadNetworkDNSServicesList{
	// 	Value: []*armavs.WorkloadNetworkDNSService{
	// 		{
	// 			Name: to.Ptr("portMirroring1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsServices"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsServices/dnsService1"),
	// 			Properties: &armavs.WorkloadNetworkDNSServiceProperties{
	// 				DefaultDNSZone: to.Ptr("defaultDnsZone1"),
	// 				DisplayName: to.Ptr("dnsService1"),
	// 				DNSServiceIP: to.Ptr("5.5.5.5"),
	// 				FqdnZones: []*string{
	// 					to.Ptr("fqdnZone1")},
	// 					LogLevel: to.Ptr(armavs.DNSServiceLogLevelEnumINFO),
	// 					Revision: to.Ptr[int64](1),
	// 					Status: to.Ptr(armavs.DNSServiceStatusEnumSUCCESS),
	// 				},
	// 		}},
	// 	}
}

Output:

func (*WorkloadNetworksClient) NewListDNSZonesPager 

func (client *WorkloadNetworksClient) NewListDNSZonesPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListDNSZonesOptions) *runtime.Pager[WorkloadNetworksClientListDNSZonesResponse]

NewListDNSZonesPager - List WorkloadNetworkDnsZone resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListDnsZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkDNSZonesList = armavs.WorkloadNetworkDNSZonesList{
	// 	Value: []*armavs.WorkloadNetworkDNSZone{
	// 		{
	// 			Name: to.Ptr("portMirroring1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dnsZones"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dnsZones/dnsZone1"),
	// 			Properties: &armavs.WorkloadNetworkDNSZoneProperties{
	// 				DisplayName: to.Ptr("dnsZone1"),
	// 				DNSServerIPs: []*string{
	// 					to.Ptr("1.1.1.1")},
	// 					DNSServices: to.Ptr[int64](0),
	// 					Domain: []*string{
	// 					},
	// 					Revision: to.Ptr[int64](1),
	// 					SourceIP: to.Ptr("8.8.8.8"),
	// 				},
	// 		}},
	// 	}
}

Output:

func (*WorkloadNetworksClient) NewListDhcpPager 

func (client *WorkloadNetworksClient) NewListDhcpPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListDhcpOptions) *runtime.Pager[WorkloadNetworksClientListDhcpResponse]

NewListDhcpPager - List WorkloadNetworkDhcp resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListDhcp.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkDhcpList = armavs.WorkloadNetworkDhcpList{
	// 	Value: []*armavs.WorkloadNetworkDhcp{
	// 		{
	// 			Name: to.Ptr("dhcp1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/dhcpConfigurations"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/dhcpConfigurations/dhcpConfigurations1"),
	// 			Properties: &armavs.WorkloadNetworkDhcpServer{
	// 				DhcpType: to.Ptr(armavs.DhcpTypeEnumSERVER),
	// 				DisplayName: to.Ptr("dhcpConfigurations1"),
	// 				Revision: to.Ptr[int64](1),
	// 				Segments: []*string{
	// 					to.Ptr("segment1"),
	// 					to.Ptr("segment2")},
	// 					LeaseTime: to.Ptr[int64](86400),
	// 					ServerAddress: to.Ptr("40.1.5.1/24"),
	// 				},
	// 		}},
	// 	}
}

Output:

func (*WorkloadNetworksClient) NewListGatewaysPager 

func (client *WorkloadNetworksClient) NewListGatewaysPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListGatewaysOptions) *runtime.Pager[WorkloadNetworksClientListGatewaysResponse]

NewListGatewaysPager - List WorkloadNetworkGateway resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListGateways.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkGatewayList = armavs.WorkloadNetworkGatewayList{
	// 	Value: []*armavs.WorkloadNetworkGateway{
	// 		{
	// 			Name: to.Ptr("gateway1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/gateways/gateway1"),
	// 			Properties: &armavs.WorkloadNetworkGatewayProperties{
	// 				Path: to.Ptr("/infra/tier-1s/gateway1"),
	// 				DisplayName: to.Ptr("gateway1"),
	// 			},
	// 	}},
	// }
}

Output:

func (*WorkloadNetworksClient) NewListPager 

func (client *WorkloadNetworksClient) NewListPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListOptions) *runtime.Pager[WorkloadNetworksClientListResponse]

NewListPager - List WorkloadNetwork resources by PrivateCloud

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkList = armavs.WorkloadNetworkList{
	// 	Value: []*armavs.WorkloadNetwork{
	// 		{
	// 			Name: to.Ptr("default"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default"),
	// 	}},
	// }
}

Output:

func (*WorkloadNetworksClient) NewListPortMirroringPager 

func (client *WorkloadNetworksClient) NewListPortMirroringPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListPortMirroringOptions) *runtime.Pager[WorkloadNetworksClientListPortMirroringResponse]

NewListPortMirroringPager - List WorkloadNetworkPortMirroring resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListPortMirroring.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkPortMirroringList = armavs.WorkloadNetworkPortMirroringList{
	// 	Value: []*armavs.WorkloadNetworkPortMirroring{
	// 		{
	// 			Name: to.Ptr("cloud1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/portMirroringProfiles"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/portMirroringProfiles/portMirroring1"),
	// 			Properties: &armavs.WorkloadNetworkPortMirroringProperties{
	// 				Destination: to.Ptr("vmGroup2"),
	// 				Direction: to.Ptr(armavs.PortMirroringDirectionEnumBIDIRECTIONAL),
	// 				DisplayName: to.Ptr("portMirroring1"),
	// 				Revision: to.Ptr[int64](1),
	// 				Source: to.Ptr("vmGroup1"),
	// 				Status: to.Ptr(armavs.PortMirroringStatusEnumSUCCESS),
	// 			},
	// 	}},
	// }
}

Output:

func (*WorkloadNetworksClient) NewListPublicIPsPager 

func (client *WorkloadNetworksClient) NewListPublicIPsPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListPublicIPsOptions) *runtime.Pager[WorkloadNetworksClientListPublicIPsResponse]

NewListPublicIPsPager - List WorkloadNetworkPublicIP resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListPublicIPs.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkPublicIPsList = armavs.WorkloadNetworkPublicIPsList{
	// 	Value: []*armavs.WorkloadNetworkPublicIP{
	// 		{
	// 			Name: to.Ptr("publicIP1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/publicIPs"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/publicIPs/publicIP1"),
	// 			Properties: &armavs.WorkloadNetworkPublicIPProperties{
	// 				DisplayName: to.Ptr("publicIP1"),
	// 				PublicIPBlock: to.Ptr("20.20.40.50/32"),
	// 			},
	// 	}},
	// }
}

Output:

func (*WorkloadNetworksClient) NewListSegmentsPager 

func (client *WorkloadNetworksClient) NewListSegmentsPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListSegmentsOptions) *runtime.Pager[WorkloadNetworksClientListSegmentsResponse]

NewListSegmentsPager - List WorkloadNetworkSegment resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListSegments.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkSegmentsList = armavs.WorkloadNetworkSegmentsList{
	// 	Value: []*armavs.WorkloadNetworkSegment{
	// 		{
	// 			Name: to.Ptr("segment1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/segments"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/segments/segment1"),
	// 			Properties: &armavs.WorkloadNetworkSegmentProperties{
	// 				ConnectedGateway: to.Ptr("/infra/tier-1s/gateway"),
	// 				DisplayName: to.Ptr("segment1"),
	// 				PortVif: []*armavs.WorkloadNetworkSegmentPortVif{
	// 					{
	// 						PortName: to.Ptr("vm1"),
	// 				}},
	// 				Revision: to.Ptr[int64](1),
	// 				Status: to.Ptr(armavs.SegmentStatusEnumSUCCESS),
	// 				Subnet: &armavs.WorkloadNetworkSegmentSubnet{
	// 					DhcpRanges: []*string{
	// 						to.Ptr("40.20.0.0-40.20.0.1")},
	// 						GatewayAddress: to.Ptr("40.20.20.20/16"),
	// 					},
	// 				},
	// 		}},
	// 	}
}

Output:

func (*WorkloadNetworksClient) NewListVMGroupsPager 

func (client *WorkloadNetworksClient) NewListVMGroupsPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListVMGroupsOptions) *runtime.Pager[WorkloadNetworksClientListVMGroupsResponse]

NewListVMGroupsPager - List WorkloadNetworkVMGroup resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListVMGroups.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkVMGroupsList = armavs.WorkloadNetworkVMGroupsList{
	// 	Value: []*armavs.WorkloadNetworkVMGroup{
	// 		{
	// 			Name: to.Ptr("cloud1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/vmGroups"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/vmGroups/vmGroup1"),
	// 			Properties: &armavs.WorkloadNetworkVMGroupProperties{
	// 				DisplayName: to.Ptr("vmGroup1"),
	// 				Members: []*string{
	// 					to.Ptr("564d43da-fefc-2a3b-1d92-42855622fa50")},
	// 					Revision: to.Ptr[int64](1),
	// 					Status: to.Ptr(armavs.VMGroupStatusEnumSUCCESS),
	// 				},
	// 		}},
	// 	}
}

Output:

func (*WorkloadNetworksClient) NewListVirtualMachinesPager 

func (client *WorkloadNetworksClient) NewListVirtualMachinesPager(resourceGroupName string, privateCloudName string, options *WorkloadNetworksClientListVirtualMachinesOptions) *runtime.Pager[WorkloadNetworksClientListVirtualMachinesResponse]

NewListVirtualMachinesPager - List WorkloadNetworkVirtualMachine resources by WorkloadNetwork

Generated from API version 2023-09-01

  • 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: https://github.com/Azure/azure-rest-api-specs/blob/e7678455846b1000fd31db27596e4ca3d299a872/specification/vmware/resource-manager/Microsoft.AVS/stable/2023-09-01/examples/WorkloadNetworks_ListVirtualMachines.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armavs.NewClientFactory("<subscription-id>", 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.WorkloadNetworkVirtualMachinesList = armavs.WorkloadNetworkVirtualMachinesList{
	// 	Value: []*armavs.WorkloadNetworkVirtualMachine{
	// 		{
	// 			Name: to.Ptr("vm1"),
	// 			Type: to.Ptr("Microsoft.AVS/privateClouds/workloadNetworks/virtualMachines"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/cloud1/workloadNetworks/default/virtualMachines/vm1"),
	// 			Properties: &armavs.WorkloadNetworkVirtualMachineProperties{
	// 				DisplayName: to.Ptr("vm1"),
	// 				VMType: to.Ptr(armavs.VMTypeEnumREGULAR),
	// 			},
	// 	}},
	// }
}

Output:

type WorkloadNetworksClientBeginCreateDNSServiceOptions 

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

WorkloadNetworksClientBeginCreateDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDNSService method.

type WorkloadNetworksClientBeginCreateDNSZoneOptions 

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

WorkloadNetworksClientBeginCreateDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDNSZone method.

type WorkloadNetworksClientBeginCreateDhcpOptions 

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

WorkloadNetworksClientBeginCreateDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateDhcp method.

type WorkloadNetworksClientBeginCreatePortMirroringOptions 

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

WorkloadNetworksClientBeginCreatePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreatePortMirroring method.

type WorkloadNetworksClientBeginCreatePublicIPOptions 

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

WorkloadNetworksClientBeginCreatePublicIPOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreatePublicIP method.

type WorkloadNetworksClientBeginCreateSegmentsOptions 

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

WorkloadNetworksClientBeginCreateSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateSegments method.

type WorkloadNetworksClientBeginCreateVMGroupOptions 

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

WorkloadNetworksClientBeginCreateVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginCreateVMGroup method.

type WorkloadNetworksClientBeginDeleteDNSServiceOptions 

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

WorkloadNetworksClientBeginDeleteDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDNSService method.

type WorkloadNetworksClientBeginDeleteDNSZoneOptions 

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

WorkloadNetworksClientBeginDeleteDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDNSZone method.

type WorkloadNetworksClientBeginDeleteDhcpOptions 

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

WorkloadNetworksClientBeginDeleteDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteDhcp method.

type WorkloadNetworksClientBeginDeletePortMirroringOptions 

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

WorkloadNetworksClientBeginDeletePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeletePortMirroring method.

type WorkloadNetworksClientBeginDeletePublicIPOptions 

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

WorkloadNetworksClientBeginDeletePublicIPOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeletePublicIP method.

type WorkloadNetworksClientBeginDeleteSegmentOptions 

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

WorkloadNetworksClientBeginDeleteSegmentOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteSegment method.

type WorkloadNetworksClientBeginDeleteVMGroupOptions 

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

WorkloadNetworksClientBeginDeleteVMGroupOptions contains the optional parameters for the WorkloadNetworksClient.BeginDeleteVMGroup method.

type WorkloadNetworksClientBeginUpdateDNSServiceOptions 

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

WorkloadNetworksClientBeginUpdateDNSServiceOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDNSService method.

type WorkloadNetworksClientBeginUpdateDNSZoneOptions 

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

WorkloadNetworksClientBeginUpdateDNSZoneOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDNSZone method.

type WorkloadNetworksClientBeginUpdateDhcpOptions 

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

WorkloadNetworksClientBeginUpdateDhcpOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateDhcp method.

type WorkloadNetworksClientBeginUpdatePortMirroringOptions 

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

WorkloadNetworksClientBeginUpdatePortMirroringOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdatePortMirroring method.

type WorkloadNetworksClientBeginUpdateSegmentsOptions 

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

WorkloadNetworksClientBeginUpdateSegmentsOptions contains the optional parameters for the WorkloadNetworksClient.BeginUpdateSegments method.

type WorkloadNetworksClientBeginUpdateVMGroupOptions 

type WorkloadNetworksClientBeginUpdateVMGroupOptions struct {
	// Resumes the LRO 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.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.