networkclouds

package
v0.20240313.1132601 Latest Latest
Warning

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

 Go to latest Published: Mar 13, 2024 License: MPL-2.0 Imports: 16 Imported by: 0

README ¶

github.com/hashicorp/go-azure-sdk/resource-manager/networkcloud/2023-07-01/networkclouds Documentation

The networkclouds SDK allows for interaction with the Azure Resource Manager Service networkcloud (API Version 2023-07-01).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
import "github.com/hashicorp/go-azure-sdk/resource-manager/networkcloud/2023-07-01/networkclouds"

Client Initialization

client := networkclouds.NewNetworkcloudsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: NetworkcloudsClient.AgentPoolsCreateOrUpdate

ctx := context.TODO()
id := networkclouds.NewAgentPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "kubernetesClusterValue", "agentPoolValue")

payload := networkclouds.AgentPool{
	// ...
}


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

Example Usage: NetworkcloudsClient.AgentPoolsDelete

ctx := context.TODO()
id := networkclouds.NewAgentPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "kubernetesClusterValue", "agentPoolValue")

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

Example Usage: NetworkcloudsClient.AgentPoolsGet

ctx := context.TODO()
id := networkclouds.NewAgentPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "kubernetesClusterValue", "agentPoolValue")

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

Example Usage: NetworkcloudsClient.AgentPoolsListByKubernetesCluster

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

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

Example Usage: NetworkcloudsClient.AgentPoolsUpdate

ctx := context.TODO()
id := networkclouds.NewAgentPoolID("12345678-1234-9876-4563-123456789012", "example-resource-group", "kubernetesClusterValue", "agentPoolValue")

payload := networkclouds.AgentPoolPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachineKeySetsCreateOrUpdate

ctx := context.TODO()
id := networkclouds.NewBareMetalMachineKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bareMetalMachineKeySetValue")

payload := networkclouds.BareMetalMachineKeySet{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachineKeySetsDelete

ctx := context.TODO()
id := networkclouds.NewBareMetalMachineKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bareMetalMachineKeySetValue")

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

Example Usage: NetworkcloudsClient.BareMetalMachineKeySetsGet

ctx := context.TODO()
id := networkclouds.NewBareMetalMachineKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bareMetalMachineKeySetValue")

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

Example Usage: NetworkcloudsClient.BareMetalMachineKeySetsListByCluster

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

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

Example Usage: NetworkcloudsClient.BareMetalMachineKeySetsUpdate

ctx := context.TODO()
id := networkclouds.NewBareMetalMachineKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bareMetalMachineKeySetValue")

payload := networkclouds.BareMetalMachineKeySetPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesCordon

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

payload := networkclouds.BareMetalMachineCordonParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesCreateOrUpdate

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

payload := networkclouds.BareMetalMachine{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesDelete

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesGet

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesListBySubscription

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesPowerOff

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

payload := networkclouds.BareMetalMachinePowerOffParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesReimage

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesReplace

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

payload := networkclouds.BareMetalMachineReplaceParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesRestart

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesRunCommand

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

payload := networkclouds.BareMetalMachineRunCommandParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesRunDataExtracts

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

payload := networkclouds.BareMetalMachineRunDataExtractsParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesRunReadCommands

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

payload := networkclouds.BareMetalMachineRunReadCommandsParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BareMetalMachinesStart

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesUncordon

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

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

Example Usage: NetworkcloudsClient.BareMetalMachinesUpdate

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

payload := networkclouds.BareMetalMachinePatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.BmcKeySetsCreateOrUpdate

ctx := context.TODO()
id := networkclouds.NewBmcKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bmcKeySetValue")

payload := networkclouds.BmcKeySet{
	// ...
}


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

Example Usage: NetworkcloudsClient.BmcKeySetsDelete

ctx := context.TODO()
id := networkclouds.NewBmcKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bmcKeySetValue")

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

Example Usage: NetworkcloudsClient.BmcKeySetsGet

ctx := context.TODO()
id := networkclouds.NewBmcKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bmcKeySetValue")

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

Example Usage: NetworkcloudsClient.BmcKeySetsListByCluster

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

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

Example Usage: NetworkcloudsClient.BmcKeySetsUpdate

ctx := context.TODO()
id := networkclouds.NewBmcKeySetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "bmcKeySetValue")

payload := networkclouds.BmcKeySetPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.CloudServicesNetworksCreateOrUpdate

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

payload := networkclouds.CloudServicesNetwork{
	// ...
}


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

Example Usage: NetworkcloudsClient.CloudServicesNetworksDelete

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

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

Example Usage: NetworkcloudsClient.CloudServicesNetworksGet

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

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

Example Usage: NetworkcloudsClient.CloudServicesNetworksListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.CloudServicesNetworksListBySubscription

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

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

Example Usage: NetworkcloudsClient.CloudServicesNetworksUpdate

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

payload := networkclouds.CloudServicesNetworkPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.ClusterManagersCreateOrUpdate

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

payload := networkclouds.ClusterManager{
	// ...
}


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

Example Usage: NetworkcloudsClient.ClusterManagersDelete

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

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

Example Usage: NetworkcloudsClient.ClusterManagersGet

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

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

Example Usage: NetworkcloudsClient.ClusterManagersListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.ClusterManagersListBySubscription

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

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

Example Usage: NetworkcloudsClient.ClusterManagersUpdate

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

payload := networkclouds.ClusterManagerPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.ClustersCreateOrUpdate

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

payload := networkclouds.Cluster{
	// ...
}


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

Example Usage: NetworkcloudsClient.ClustersDelete

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

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

Example Usage: NetworkcloudsClient.ClustersDeploy

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

payload := networkclouds.ClusterDeployParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.ClustersGet

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

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

Example Usage: NetworkcloudsClient.ClustersListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.ClustersListBySubscription

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

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

Example Usage: NetworkcloudsClient.ClustersUpdate

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

payload := networkclouds.ClusterPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.ClustersUpdateVersion

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

payload := networkclouds.ClusterUpdateVersionParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.ConsolesCreateOrUpdate

ctx := context.TODO()
id := networkclouds.NewConsoleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualMachineValue", "consoleValue")

payload := networkclouds.Console{
	// ...
}


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

Example Usage: NetworkcloudsClient.ConsolesDelete

ctx := context.TODO()
id := networkclouds.NewConsoleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualMachineValue", "consoleValue")

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

Example Usage: NetworkcloudsClient.ConsolesGet

ctx := context.TODO()
id := networkclouds.NewConsoleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualMachineValue", "consoleValue")

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

Example Usage: NetworkcloudsClient.ConsolesListByVirtualMachine

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

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

Example Usage: NetworkcloudsClient.ConsolesUpdate

ctx := context.TODO()
id := networkclouds.NewConsoleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "virtualMachineValue", "consoleValue")

payload := networkclouds.ConsolePatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.KubernetesClustersCreateOrUpdate

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

payload := networkclouds.KubernetesCluster{
	// ...
}


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

Example Usage: NetworkcloudsClient.KubernetesClustersDelete

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

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

Example Usage: NetworkcloudsClient.KubernetesClustersGet

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

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

Example Usage: NetworkcloudsClient.KubernetesClustersListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.KubernetesClustersListBySubscription

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

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

Example Usage: NetworkcloudsClient.KubernetesClustersRestartNode

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

payload := networkclouds.KubernetesClusterRestartNodeParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.KubernetesClustersUpdate

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

payload := networkclouds.KubernetesClusterPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.L2NetworksCreateOrUpdate

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

payload := networkclouds.L2Network{
	// ...
}


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

Example Usage: NetworkcloudsClient.L2NetworksDelete

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

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

Example Usage: NetworkcloudsClient.L2NetworksGet

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

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

Example Usage: NetworkcloudsClient.L2NetworksListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.L2NetworksListBySubscription

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

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

Example Usage: NetworkcloudsClient.L2NetworksUpdate

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

payload := networkclouds.L2NetworkPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.L3NetworksCreateOrUpdate

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

payload := networkclouds.L3Network{
	// ...
}


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

Example Usage: NetworkcloudsClient.L3NetworksDelete

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

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

Example Usage: NetworkcloudsClient.L3NetworksGet

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

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

Example Usage: NetworkcloudsClient.L3NetworksListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.L3NetworksListBySubscription

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

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

Example Usage: NetworkcloudsClient.L3NetworksUpdate

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

payload := networkclouds.L3NetworkPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.MetricsConfigurationsCreateOrUpdate

ctx := context.TODO()
id := networkclouds.NewMetricsConfigurationID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "metricsConfigurationValue")

payload := networkclouds.ClusterMetricsConfiguration{
	// ...
}


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

Example Usage: NetworkcloudsClient.MetricsConfigurationsDelete

ctx := context.TODO()
id := networkclouds.NewMetricsConfigurationID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "metricsConfigurationValue")

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

Example Usage: NetworkcloudsClient.MetricsConfigurationsGet

ctx := context.TODO()
id := networkclouds.NewMetricsConfigurationID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "metricsConfigurationValue")

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

Example Usage: NetworkcloudsClient.MetricsConfigurationsListByCluster

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

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

Example Usage: NetworkcloudsClient.MetricsConfigurationsUpdate

ctx := context.TODO()
id := networkclouds.NewMetricsConfigurationID("12345678-1234-9876-4563-123456789012", "example-resource-group", "clusterValue", "metricsConfigurationValue")

payload := networkclouds.ClusterMetricsConfigurationPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.RackSkusGet

ctx := context.TODO()
id := networkclouds.NewRackSkuID("12345678-1234-9876-4563-123456789012", "rackSkuValue")

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

Example Usage: NetworkcloudsClient.RackSkusListBySubscription

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

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

Example Usage: NetworkcloudsClient.RacksCreateOrUpdate

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

payload := networkclouds.Rack{
	// ...
}


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

Example Usage: NetworkcloudsClient.RacksDelete

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

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

Example Usage: NetworkcloudsClient.RacksGet

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

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

Example Usage: NetworkcloudsClient.RacksListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.RacksListBySubscription

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

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

Example Usage: NetworkcloudsClient.RacksUpdate

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

payload := networkclouds.RackPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.StorageAppliancesCreateOrUpdate

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

payload := networkclouds.StorageAppliance{
	// ...
}


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

Example Usage: NetworkcloudsClient.StorageAppliancesDelete

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

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

Example Usage: NetworkcloudsClient.StorageAppliancesDisableRemoteVendorManagement

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

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

Example Usage: NetworkcloudsClient.StorageAppliancesEnableRemoteVendorManagement

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

payload := networkclouds.StorageApplianceEnableRemoteVendorManagementParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.StorageAppliancesGet

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

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

Example Usage: NetworkcloudsClient.StorageAppliancesListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.StorageAppliancesListBySubscription

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

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

Example Usage: NetworkcloudsClient.StorageAppliancesUpdate

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

payload := networkclouds.StorageAppliancePatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.TrunkedNetworksCreateOrUpdate

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

payload := networkclouds.TrunkedNetwork{
	// ...
}


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

Example Usage: NetworkcloudsClient.TrunkedNetworksDelete

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

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

Example Usage: NetworkcloudsClient.TrunkedNetworksGet

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

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

Example Usage: NetworkcloudsClient.TrunkedNetworksListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.TrunkedNetworksListBySubscription

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

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

Example Usage: NetworkcloudsClient.TrunkedNetworksUpdate

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

payload := networkclouds.TrunkedNetworkPatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.VirtualMachinesCreateOrUpdate

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

payload := networkclouds.VirtualMachine{
	// ...
}


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

Example Usage: NetworkcloudsClient.VirtualMachinesDelete

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesGet

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesListBySubscription

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesPowerOff

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

payload := networkclouds.VirtualMachinePowerOffParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.VirtualMachinesReimage

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesRestart

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesStart

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

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

Example Usage: NetworkcloudsClient.VirtualMachinesUpdate

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

payload := networkclouds.VirtualMachinePatchParameters{
	// ...
}


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

Example Usage: NetworkcloudsClient.VolumesCreateOrUpdate

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

payload := networkclouds.Volume{
	// ...
}


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

Example Usage: NetworkcloudsClient.VolumesDelete

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

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

Example Usage: NetworkcloudsClient.VolumesGet

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

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

Example Usage: NetworkcloudsClient.VolumesListByResourceGroup

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

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

Example Usage: NetworkcloudsClient.VolumesListBySubscription

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

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

Example Usage: NetworkcloudsClient.VolumesUpdate

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

payload := networkclouds.VolumePatchParameters{
	// ...
}


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

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func PossibleValuesForAdvertiseToFabric ¶ 

func PossibleValuesForAdvertiseToFabric() []string

func PossibleValuesForAgentPoolDetailedStatus ¶ 

func PossibleValuesForAgentPoolDetailedStatus() []string

func PossibleValuesForAgentPoolMode ¶ 

func PossibleValuesForAgentPoolMode() []string

func PossibleValuesForAgentPoolProvisioningState ¶ 

func PossibleValuesForAgentPoolProvisioningState() []string

func PossibleValuesForAvailabilityLifecycle ¶ 

func PossibleValuesForAvailabilityLifecycle() []string

func PossibleValuesForBareMetalMachineCordonStatus ¶ 

func PossibleValuesForBareMetalMachineCordonStatus() []string

func PossibleValuesForBareMetalMachineDetailedStatus ¶ 

func PossibleValuesForBareMetalMachineDetailedStatus() []string

func PossibleValuesForBareMetalMachineEvacuate ¶ 

func PossibleValuesForBareMetalMachineEvacuate() []string

func PossibleValuesForBareMetalMachineHardwareValidationResult ¶ 

func PossibleValuesForBareMetalMachineHardwareValidationResult() []string

func PossibleValuesForBareMetalMachineKeySetDetailedStatus ¶ 

func PossibleValuesForBareMetalMachineKeySetDetailedStatus() []string

func PossibleValuesForBareMetalMachineKeySetPrivilegeLevel ¶ 

func PossibleValuesForBareMetalMachineKeySetPrivilegeLevel() []string

func PossibleValuesForBareMetalMachineKeySetProvisioningState ¶ 

func PossibleValuesForBareMetalMachineKeySetProvisioningState() []string

func PossibleValuesForBareMetalMachineKeySetUserSetupStatus ¶ 

func PossibleValuesForBareMetalMachineKeySetUserSetupStatus() []string

func PossibleValuesForBareMetalMachinePowerState ¶ 

func PossibleValuesForBareMetalMachinePowerState() []string

func PossibleValuesForBareMetalMachineProvisioningState ¶ 

func PossibleValuesForBareMetalMachineProvisioningState() []string

func PossibleValuesForBareMetalMachineReadyState ¶ 

func PossibleValuesForBareMetalMachineReadyState() []string

func PossibleValuesForBareMetalMachineSkipShutdown ¶ 

func PossibleValuesForBareMetalMachineSkipShutdown() []string

func PossibleValuesForBfdEnabled ¶ 

func PossibleValuesForBfdEnabled() []string

func PossibleValuesForBgpMultiHop ¶ 

func PossibleValuesForBgpMultiHop() []string

func PossibleValuesForBmcKeySetDetailedStatus ¶ 

func PossibleValuesForBmcKeySetDetailedStatus() []string

func PossibleValuesForBmcKeySetPrivilegeLevel ¶ 

func PossibleValuesForBmcKeySetPrivilegeLevel() []string

func PossibleValuesForBmcKeySetProvisioningState ¶ 

func PossibleValuesForBmcKeySetProvisioningState() []string

func PossibleValuesForBootstrapProtocol ¶ 

func PossibleValuesForBootstrapProtocol() []string

func PossibleValuesForCloudServicesNetworkDetailedStatus ¶ 

func PossibleValuesForCloudServicesNetworkDetailedStatus() []string

func PossibleValuesForCloudServicesNetworkEnableDefaultEgressEndpoints ¶ 

func PossibleValuesForCloudServicesNetworkEnableDefaultEgressEndpoints() []string

func PossibleValuesForCloudServicesNetworkProvisioningState ¶ 

func PossibleValuesForCloudServicesNetworkProvisioningState() []string

func PossibleValuesForClusterConnectionStatus ¶ 

func PossibleValuesForClusterConnectionStatus() []string

func PossibleValuesForClusterDetailedStatus ¶ 

func PossibleValuesForClusterDetailedStatus() []string

func PossibleValuesForClusterManagerConnectionStatus ¶ 

func PossibleValuesForClusterManagerConnectionStatus() []string

func PossibleValuesForClusterManagerDetailedStatus ¶ 

func PossibleValuesForClusterManagerDetailedStatus() []string

func PossibleValuesForClusterManagerProvisioningState ¶ 

func PossibleValuesForClusterManagerProvisioningState() []string

func PossibleValuesForClusterMetricsConfigurationDetailedStatus ¶ 

func PossibleValuesForClusterMetricsConfigurationDetailedStatus() []string

func PossibleValuesForClusterMetricsConfigurationProvisioningState ¶ 

func PossibleValuesForClusterMetricsConfigurationProvisioningState() []string

func PossibleValuesForClusterProvisioningState ¶ 

func PossibleValuesForClusterProvisioningState() []string

func PossibleValuesForClusterType ¶ 

func PossibleValuesForClusterType() []string

func PossibleValuesForConsoleDetailedStatus ¶ 

func PossibleValuesForConsoleDetailedStatus() []string

func PossibleValuesForConsoleEnabled ¶ 

func PossibleValuesForConsoleEnabled() []string

func PossibleValuesForConsoleProvisioningState ¶ 

func PossibleValuesForConsoleProvisioningState() []string

func PossibleValuesForControlImpact ¶ 

func PossibleValuesForControlImpact() []string

func PossibleValuesForDefaultGateway ¶ 

func PossibleValuesForDefaultGateway() []string

func PossibleValuesForDeviceConnectionType ¶ 

func PossibleValuesForDeviceConnectionType() []string

func PossibleValuesForDiskType ¶ 

func PossibleValuesForDiskType() []string

func PossibleValuesForFabricPeeringEnabled ¶ 

func PossibleValuesForFabricPeeringEnabled() []string

func PossibleValuesForFeatureDetailedStatus ¶ 

func PossibleValuesForFeatureDetailedStatus() []string

func PossibleValuesForHugepagesSize ¶ 

func PossibleValuesForHugepagesSize() []string

func PossibleValuesForHybridAksIPamEnabled ¶ 

func PossibleValuesForHybridAksIPamEnabled() []string

func PossibleValuesForHybridAksPluginType ¶ 

func PossibleValuesForHybridAksPluginType() []string

func PossibleValuesForIPAllocationType ¶ 

func PossibleValuesForIPAllocationType() []string

func PossibleValuesForKubernetesClusterDetailedStatus ¶ 

func PossibleValuesForKubernetesClusterDetailedStatus() []string

func PossibleValuesForKubernetesClusterNodeDetailedStatus ¶ 

func PossibleValuesForKubernetesClusterNodeDetailedStatus() []string

func PossibleValuesForKubernetesClusterProvisioningState ¶ 

func PossibleValuesForKubernetesClusterProvisioningState() []string

func PossibleValuesForKubernetesNodePowerState ¶ 

func PossibleValuesForKubernetesNodePowerState() []string

func PossibleValuesForKubernetesNodeRole ¶ 

func PossibleValuesForKubernetesNodeRole() []string

func PossibleValuesForKubernetesPluginType ¶ 

func PossibleValuesForKubernetesPluginType() []string

func PossibleValuesForL2NetworkDetailedStatus ¶ 

func PossibleValuesForL2NetworkDetailedStatus() []string

func PossibleValuesForL2NetworkProvisioningState ¶ 

func PossibleValuesForL2NetworkProvisioningState() []string

func PossibleValuesForL3NetworkConfigurationIPamEnabled ¶ 

func PossibleValuesForL3NetworkConfigurationIPamEnabled() []string

func PossibleValuesForL3NetworkDetailedStatus ¶ 

func PossibleValuesForL3NetworkDetailedStatus() []string

func PossibleValuesForL3NetworkProvisioningState ¶ 

func PossibleValuesForL3NetworkProvisioningState() []string

func PossibleValuesForMachineSkuDiskConnectionType ¶ 

func PossibleValuesForMachineSkuDiskConnectionType() []string

func PossibleValuesForOsDiskCreateOption ¶ 

func PossibleValuesForOsDiskCreateOption() []string

func PossibleValuesForOsDiskDeleteOption ¶ 

func PossibleValuesForOsDiskDeleteOption() []string

func PossibleValuesForRackDetailedStatus ¶ 

func PossibleValuesForRackDetailedStatus() []string

func PossibleValuesForRackProvisioningState ¶ 

func PossibleValuesForRackProvisioningState() []string

func PossibleValuesForRackSkuProvisioningState ¶ 

func PossibleValuesForRackSkuProvisioningState() []string

func PossibleValuesForRackSkuType ¶ 

func PossibleValuesForRackSkuType() []string

func PossibleValuesForRemoteVendorManagementFeature ¶ 

func PossibleValuesForRemoteVendorManagementFeature() []string

func PossibleValuesForRemoteVendorManagementStatus ¶ 

func PossibleValuesForRemoteVendorManagementStatus() []string

func PossibleValuesForSkipShutdown ¶ 

func PossibleValuesForSkipShutdown() []string

func PossibleValuesForStorageApplianceDetailedStatus ¶ 

func PossibleValuesForStorageApplianceDetailedStatus() []string

func PossibleValuesForStorageApplianceProvisioningState ¶ 

func PossibleValuesForStorageApplianceProvisioningState() []string

func PossibleValuesForTrunkedNetworkDetailedStatus ¶ 

func PossibleValuesForTrunkedNetworkDetailedStatus() []string

func PossibleValuesForTrunkedNetworkProvisioningState ¶ 

func PossibleValuesForTrunkedNetworkProvisioningState() []string

func PossibleValuesForValidationThresholdGrouping ¶ 

func PossibleValuesForValidationThresholdGrouping() []string

func PossibleValuesForValidationThresholdType ¶ 

func PossibleValuesForValidationThresholdType() []string

func PossibleValuesForVirtualMachineBootMethod ¶ 

func PossibleValuesForVirtualMachineBootMethod() []string

func PossibleValuesForVirtualMachineDetailedStatus ¶ 

func PossibleValuesForVirtualMachineDetailedStatus() []string

func PossibleValuesForVirtualMachineDeviceModelType ¶ 

func PossibleValuesForVirtualMachineDeviceModelType() []string

func PossibleValuesForVirtualMachineIPAllocationMethod ¶ 

func PossibleValuesForVirtualMachineIPAllocationMethod() []string

func PossibleValuesForVirtualMachineIsolateEmulatorThread ¶ 

func PossibleValuesForVirtualMachineIsolateEmulatorThread() []string

func PossibleValuesForVirtualMachinePlacementHintPodAffinityScope ¶ 

func PossibleValuesForVirtualMachinePlacementHintPodAffinityScope() []string

func PossibleValuesForVirtualMachinePlacementHintType ¶ 

func PossibleValuesForVirtualMachinePlacementHintType() []string

func PossibleValuesForVirtualMachinePowerState ¶ 

func PossibleValuesForVirtualMachinePowerState() []string

func PossibleValuesForVirtualMachineProvisioningState ¶ 

func PossibleValuesForVirtualMachineProvisioningState() []string

func PossibleValuesForVirtualMachineSchedulingExecution ¶ 

func PossibleValuesForVirtualMachineSchedulingExecution() []string

func PossibleValuesForVirtualMachineVirtioInterfaceType ¶ 

func PossibleValuesForVirtualMachineVirtioInterfaceType() []string

func PossibleValuesForVolumeDetailedStatus ¶ 

func PossibleValuesForVolumeDetailedStatus() []string

func PossibleValuesForVolumeProvisioningState ¶ 

func PossibleValuesForVolumeProvisioningState() []string

func PossibleValuesForWorkloadImpact ¶ 

func PossibleValuesForWorkloadImpact() []string

func ValidateAgentPoolID ¶ 

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

ValidateAgentPoolID checks that 'input' can be parsed as a Agent Pool ID

func ValidateBareMetalMachineID ¶ 

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

ValidateBareMetalMachineID checks that 'input' can be parsed as a Bare Metal Machine ID

func ValidateBareMetalMachineKeySetID ¶ 

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

ValidateBareMetalMachineKeySetID checks that 'input' can be parsed as a Bare Metal Machine Key Set ID

func ValidateBmcKeySetID ¶ 

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

ValidateBmcKeySetID checks that 'input' can be parsed as a Bmc Key Set ID

func ValidateCloudServicesNetworkID ¶ 

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

ValidateCloudServicesNetworkID checks that 'input' can be parsed as a Cloud Services Network ID

func ValidateClusterID ¶ 

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

ValidateClusterID checks that 'input' can be parsed as a Cluster ID

func ValidateClusterManagerID ¶ 

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

ValidateClusterManagerID checks that 'input' can be parsed as a Cluster Manager ID

func ValidateConsoleID ¶ 

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

ValidateConsoleID checks that 'input' can be parsed as a Console ID

func ValidateKubernetesClusterID ¶ 

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

ValidateKubernetesClusterID checks that 'input' can be parsed as a Kubernetes Cluster ID

func ValidateL2NetworkID ¶ 

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

ValidateL2NetworkID checks that 'input' can be parsed as a L 2 Network ID

func ValidateL3NetworkID ¶ 

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

ValidateL3NetworkID checks that 'input' can be parsed as a L 3 Network ID

func ValidateMetricsConfigurationID ¶ 

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

ValidateMetricsConfigurationID checks that 'input' can be parsed as a Metrics Configuration ID

func ValidateRackID ¶ 

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

ValidateRackID checks that 'input' can be parsed as a Rack ID

func ValidateRackSkuID ¶ 

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

ValidateRackSkuID checks that 'input' can be parsed as a Rack Sku ID

func ValidateStorageApplianceID ¶ 

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

ValidateStorageApplianceID checks that 'input' can be parsed as a Storage Appliance ID

func ValidateTrunkedNetworkID ¶ 

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

ValidateTrunkedNetworkID checks that 'input' can be parsed as a Trunked Network ID

func ValidateVirtualMachineID ¶ 

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

ValidateVirtualMachineID checks that 'input' can be parsed as a Virtual Machine ID

func ValidateVolumeID ¶ 

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

ValidateVolumeID checks that 'input' can be parsed as a Volume ID

Types ¶

type AadConfiguration ¶ 

type AadConfiguration struct {
	AdminGroupObjectIds []string `json:"adminGroupObjectIds"`
}

type AdministrativeCredentials ¶ 

type AdministrativeCredentials struct {
	Password string `json:"password"`
	Username string `json:"username"`
}

type AdministratorConfiguration ¶ 

type AdministratorConfiguration struct {
	AdminUsername *string         `json:"adminUsername,omitempty"`
	SshPublicKeys *[]SshPublicKey `json:"sshPublicKeys,omitempty"`
}

type AdvertiseToFabric ¶ 

type AdvertiseToFabric string
const (
	AdvertiseToFabricFalse AdvertiseToFabric = "False"
	AdvertiseToFabricTrue  AdvertiseToFabric = "True"
)

func (*AdvertiseToFabric) UnmarshalJSON ¶ 

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

type AgentOptions ¶ 

type AgentOptions struct {
	HugepagesCount int64          `json:"hugepagesCount"`
	HugepagesSize  *HugepagesSize `json:"hugepagesSize,omitempty"`
}

type AgentPool ¶ 

type AgentPool struct {
	ExtendedLocation *ExtendedLocation      `json:"extendedLocation,omitempty"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       AgentPoolProperties    `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type AgentPoolDetailedStatus ¶ 

type AgentPoolDetailedStatus string
const (
	AgentPoolDetailedStatusAvailable    AgentPoolDetailedStatus = "Available"
	AgentPoolDetailedStatusError        AgentPoolDetailedStatus = "Error"
	AgentPoolDetailedStatusProvisioning AgentPoolDetailedStatus = "Provisioning"
)

func (*AgentPoolDetailedStatus) UnmarshalJSON ¶ 

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

type AgentPoolId ¶ 

type AgentPoolId struct {
	SubscriptionId        string
	ResourceGroupName     string
	KubernetesClusterName string
	AgentPoolName         string
}

AgentPoolId is a struct representing the Resource ID for a Agent Pool

func NewAgentPoolID ¶ 

func NewAgentPoolID(subscriptionId string, resourceGroupName string, kubernetesClusterName string, agentPoolName string) AgentPoolId

NewAgentPoolID returns a new AgentPoolId struct

func ParseAgentPoolID ¶ 

func ParseAgentPoolID(input string) (*AgentPoolId, error)

ParseAgentPoolID parses 'input' into a AgentPoolId

func ParseAgentPoolIDInsensitively ¶ 

func ParseAgentPoolIDInsensitively(input string) (*AgentPoolId, error)

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

func (*AgentPoolId) FromParseResult ¶ 

func (id *AgentPoolId) FromParseResult(input resourceids.ParseResult) error

func (AgentPoolId) ID ¶ 

func (id AgentPoolId) ID() string

ID returns the formatted Agent Pool ID

func (AgentPoolId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Agent Pool ID

func (AgentPoolId) String ¶ 

func (id AgentPoolId) String() string

String returns a human-readable description of this Agent Pool ID

type AgentPoolMode ¶ 

type AgentPoolMode string
const (
	AgentPoolModeNotApplicable AgentPoolMode = "NotApplicable"
	AgentPoolModeSystem        AgentPoolMode = "System"
	AgentPoolModeUser          AgentPoolMode = "User"
)

func (*AgentPoolMode) UnmarshalJSON ¶ 

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

type AgentPoolOperationPredicate ¶ 

type AgentPoolOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (AgentPoolOperationPredicate) Matches ¶ 

func (p AgentPoolOperationPredicate) Matches(input AgentPool) bool

type AgentPoolPatchParameters ¶ 

type AgentPoolPatchParameters struct {
	Properties *AgentPoolPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string        `json:"tags,omitempty"`
}

type AgentPoolPatchProperties ¶ 

type AgentPoolPatchProperties struct {
	Count           *int64                    `json:"count,omitempty"`
	UpgradeSettings *AgentPoolUpgradeSettings `json:"upgradeSettings,omitempty"`
}

type AgentPoolProperties ¶ 

type AgentPoolProperties struct {
	AdministratorConfiguration   *AdministratorConfiguration   `json:"administratorConfiguration,omitempty"`
	AgentOptions                 *AgentOptions                 `json:"agentOptions,omitempty"`
	AttachedNetworkConfiguration *AttachedNetworkConfiguration `json:"attachedNetworkConfiguration,omitempty"`
	AvailabilityZones            *zones.Schema                 `json:"availabilityZones,omitempty"`
	Count                        int64                         `json:"count"`
	DetailedStatus               *AgentPoolDetailedStatus      `json:"detailedStatus,omitempty"`
	DetailedStatusMessage        *string                       `json:"detailedStatusMessage,omitempty"`
	KubernetesVersion            *string                       `json:"kubernetesVersion,omitempty"`
	Labels                       *[]KubernetesLabel            `json:"labels,omitempty"`
	Mode                         AgentPoolMode                 `json:"mode"`
	ProvisioningState            *AgentPoolProvisioningState   `json:"provisioningState,omitempty"`
	Taints                       *[]KubernetesLabel            `json:"taints,omitempty"`
	UpgradeSettings              *AgentPoolUpgradeSettings     `json:"upgradeSettings,omitempty"`
	VMSkuName                    string                        `json:"vmSkuName"`
}

type AgentPoolProvisioningState ¶ 

type AgentPoolProvisioningState string
const (
	AgentPoolProvisioningStateAccepted   AgentPoolProvisioningState = "Accepted"
	AgentPoolProvisioningStateCanceled   AgentPoolProvisioningState = "Canceled"
	AgentPoolProvisioningStateDeleting   AgentPoolProvisioningState = "Deleting"
	AgentPoolProvisioningStateFailed     AgentPoolProvisioningState = "Failed"
	AgentPoolProvisioningStateInProgress AgentPoolProvisioningState = "InProgress"
	AgentPoolProvisioningStateSucceeded  AgentPoolProvisioningState = "Succeeded"
	AgentPoolProvisioningStateUpdating   AgentPoolProvisioningState = "Updating"
)

func (*AgentPoolProvisioningState) UnmarshalJSON ¶ 

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

type AgentPoolUpgradeSettings ¶ 

type AgentPoolUpgradeSettings struct {
	MaxSurge *string `json:"maxSurge,omitempty"`
}

type AgentPoolsCreateOrUpdateOperationResponse ¶ 

type AgentPoolsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *AgentPool
}

type AgentPoolsDeleteOperationResponse ¶ 

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

type AgentPoolsGetOperationResponse ¶ 

type AgentPoolsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *AgentPool
}

type AgentPoolsListByKubernetesClusterCompleteResult ¶ 

type AgentPoolsListByKubernetesClusterCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []AgentPool
}

type AgentPoolsListByKubernetesClusterOperationResponse ¶ 

type AgentPoolsListByKubernetesClusterOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]AgentPool
}

type AgentPoolsUpdateOperationResponse ¶ 

type AgentPoolsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *AgentPool
}

type AttachedNetworkConfiguration ¶ 

type AttachedNetworkConfiguration struct {
	L2Networks      *[]L2NetworkAttachmentConfiguration      `json:"l2Networks,omitempty"`
	L3Networks      *[]L3NetworkAttachmentConfiguration      `json:"l3Networks,omitempty"`
	TrunkedNetworks *[]TrunkedNetworkAttachmentConfiguration `json:"trunkedNetworks,omitempty"`
}

type AvailabilityLifecycle ¶ 

type AvailabilityLifecycle string
const (
	AvailabilityLifecycleGenerallyAvailable AvailabilityLifecycle = "GenerallyAvailable"
	AvailabilityLifecyclePreview            AvailabilityLifecycle = "Preview"
)

func (*AvailabilityLifecycle) UnmarshalJSON ¶ 

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

type AvailableUpgrade ¶ 

type AvailableUpgrade struct {
	AvailabilityLifecycle *AvailabilityLifecycle `json:"availabilityLifecycle,omitempty"`
	Version               *string                `json:"version,omitempty"`
}

type BareMetalMachine ¶ 

type BareMetalMachine struct {
	ExtendedLocation ExtendedLocation           `json:"extendedLocation"`
	Id               *string                    `json:"id,omitempty"`
	Location         string                     `json:"location"`
	Name             *string                    `json:"name,omitempty"`
	Properties       BareMetalMachineProperties `json:"properties"`
	SystemData       *systemdata.SystemData     `json:"systemData,omitempty"`
	Tags             *map[string]string         `json:"tags,omitempty"`
	Type             *string                    `json:"type,omitempty"`
}

type BareMetalMachineCommandSpecification ¶ 

type BareMetalMachineCommandSpecification struct {
	Arguments *[]string `json:"arguments,omitempty"`
	Command   string    `json:"command"`
}

type BareMetalMachineConfigurationData ¶ 

type BareMetalMachineConfigurationData struct {
	BmcConnectionString *string                   `json:"bmcConnectionString,omitempty"`
	BmcCredentials      AdministrativeCredentials `json:"bmcCredentials"`
	BmcMacAddress       string                    `json:"bmcMacAddress"`
	BootMacAddress      string                    `json:"bootMacAddress"`
	MachineDetails      *string                   `json:"machineDetails,omitempty"`
	MachineName         *string                   `json:"machineName,omitempty"`
	RackSlot            int64                     `json:"rackSlot"`
	SerialNumber        string                    `json:"serialNumber"`
}

type BareMetalMachineCordonParameters ¶ 

type BareMetalMachineCordonParameters struct {
	Evacuate *BareMetalMachineEvacuate `json:"evacuate,omitempty"`
}

type BareMetalMachineCordonStatus ¶ 

type BareMetalMachineCordonStatus string
const (
	BareMetalMachineCordonStatusCordoned   BareMetalMachineCordonStatus = "Cordoned"
	BareMetalMachineCordonStatusUncordoned BareMetalMachineCordonStatus = "Uncordoned"
)

func (*BareMetalMachineCordonStatus) UnmarshalJSON ¶ 

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

type BareMetalMachineDetailedStatus ¶ 

type BareMetalMachineDetailedStatus string
const (
	BareMetalMachineDetailedStatusAvailable      BareMetalMachineDetailedStatus = "Available"
	BareMetalMachineDetailedStatusDeprovisioning BareMetalMachineDetailedStatus = "Deprovisioning"
	BareMetalMachineDetailedStatusError          BareMetalMachineDetailedStatus = "Error"
	BareMetalMachineDetailedStatusPreparing      BareMetalMachineDetailedStatus = "Preparing"
	BareMetalMachineDetailedStatusProvisioned    BareMetalMachineDetailedStatus = "Provisioned"
	BareMetalMachineDetailedStatusProvisioning   BareMetalMachineDetailedStatus = "Provisioning"
)

func (*BareMetalMachineDetailedStatus) UnmarshalJSON ¶ 

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

type BareMetalMachineEvacuate ¶ 

type BareMetalMachineEvacuate string
const (
	BareMetalMachineEvacuateFalse BareMetalMachineEvacuate = "False"
	BareMetalMachineEvacuateTrue  BareMetalMachineEvacuate = "True"
)

func (*BareMetalMachineEvacuate) UnmarshalJSON ¶ 

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

type BareMetalMachineHardwareValidationResult ¶ 

type BareMetalMachineHardwareValidationResult string
const (
	BareMetalMachineHardwareValidationResultFail BareMetalMachineHardwareValidationResult = "Fail"
	BareMetalMachineHardwareValidationResultPass BareMetalMachineHardwareValidationResult = "Pass"
)

func (*BareMetalMachineHardwareValidationResult) UnmarshalJSON ¶ 

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

type BareMetalMachineId ¶ 

type BareMetalMachineId struct {
	SubscriptionId       string
	ResourceGroupName    string
	BareMetalMachineName string
}

BareMetalMachineId is a struct representing the Resource ID for a Bare Metal Machine

func NewBareMetalMachineID ¶ 

func NewBareMetalMachineID(subscriptionId string, resourceGroupName string, bareMetalMachineName string) BareMetalMachineId

NewBareMetalMachineID returns a new BareMetalMachineId struct

func ParseBareMetalMachineID ¶ 

func ParseBareMetalMachineID(input string) (*BareMetalMachineId, error)

ParseBareMetalMachineID parses 'input' into a BareMetalMachineId

func ParseBareMetalMachineIDInsensitively ¶ 

func ParseBareMetalMachineIDInsensitively(input string) (*BareMetalMachineId, error)

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

func (*BareMetalMachineId) FromParseResult ¶ 

func (id *BareMetalMachineId) FromParseResult(input resourceids.ParseResult) error

func (BareMetalMachineId) ID ¶ 

func (id BareMetalMachineId) ID() string

ID returns the formatted Bare Metal Machine ID

func (BareMetalMachineId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Bare Metal Machine ID

func (BareMetalMachineId) String ¶ 

func (id BareMetalMachineId) String() string

String returns a human-readable description of this Bare Metal Machine ID

type BareMetalMachineKeySet ¶ 

type BareMetalMachineKeySet struct {
	ExtendedLocation ExtendedLocation                 `json:"extendedLocation"`
	Id               *string                          `json:"id,omitempty"`
	Location         string                           `json:"location"`
	Name             *string                          `json:"name,omitempty"`
	Properties       BareMetalMachineKeySetProperties `json:"properties"`
	SystemData       *systemdata.SystemData           `json:"systemData,omitempty"`
	Tags             *map[string]string               `json:"tags,omitempty"`
	Type             *string                          `json:"type,omitempty"`
}

type BareMetalMachineKeySetDetailedStatus ¶ 

type BareMetalMachineKeySetDetailedStatus string
const (
	BareMetalMachineKeySetDetailedStatusAllActive   BareMetalMachineKeySetDetailedStatus = "AllActive"
	BareMetalMachineKeySetDetailedStatusAllInvalid  BareMetalMachineKeySetDetailedStatus = "AllInvalid"
	BareMetalMachineKeySetDetailedStatusSomeInvalid BareMetalMachineKeySetDetailedStatus = "SomeInvalid"
	BareMetalMachineKeySetDetailedStatusValidating  BareMetalMachineKeySetDetailedStatus = "Validating"
)

func (*BareMetalMachineKeySetDetailedStatus) UnmarshalJSON ¶ 

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

type BareMetalMachineKeySetId ¶ 

type BareMetalMachineKeySetId struct {
	SubscriptionId             string
	ResourceGroupName          string
	ClusterName                string
	BareMetalMachineKeySetName string
}

BareMetalMachineKeySetId is a struct representing the Resource ID for a Bare Metal Machine Key Set

func NewBareMetalMachineKeySetID ¶ 

func NewBareMetalMachineKeySetID(subscriptionId string, resourceGroupName string, clusterName string, bareMetalMachineKeySetName string) BareMetalMachineKeySetId

NewBareMetalMachineKeySetID returns a new BareMetalMachineKeySetId struct

func ParseBareMetalMachineKeySetID ¶ 

func ParseBareMetalMachineKeySetID(input string) (*BareMetalMachineKeySetId, error)

ParseBareMetalMachineKeySetID parses 'input' into a BareMetalMachineKeySetId

func ParseBareMetalMachineKeySetIDInsensitively ¶ 

func ParseBareMetalMachineKeySetIDInsensitively(input string) (*BareMetalMachineKeySetId, error)

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

func (*BareMetalMachineKeySetId) FromParseResult ¶ 

func (id *BareMetalMachineKeySetId) FromParseResult(input resourceids.ParseResult) error

func (BareMetalMachineKeySetId) ID ¶ 

func (id BareMetalMachineKeySetId) ID() string

ID returns the formatted Bare Metal Machine Key Set ID

func (BareMetalMachineKeySetId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Bare Metal Machine Key Set ID

func (BareMetalMachineKeySetId) String ¶ 

func (id BareMetalMachineKeySetId) String() string

String returns a human-readable description of this Bare Metal Machine Key Set ID

type BareMetalMachineKeySetOperationPredicate ¶ 

type BareMetalMachineKeySetOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (BareMetalMachineKeySetOperationPredicate) Matches ¶ 

func (p BareMetalMachineKeySetOperationPredicate) Matches(input BareMetalMachineKeySet) bool

type BareMetalMachineKeySetPatchParameters ¶ 

type BareMetalMachineKeySetPatchParameters struct {
	Properties *BareMetalMachineKeySetPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string                     `json:"tags,omitempty"`
}

type BareMetalMachineKeySetPatchProperties ¶ 

type BareMetalMachineKeySetPatchProperties struct {
	Expiration       *string       `json:"expiration,omitempty"`
	JumpHostsAllowed *[]string     `json:"jumpHostsAllowed,omitempty"`
	UserList         *[]KeySetUser `json:"userList,omitempty"`
}

func (*BareMetalMachineKeySetPatchProperties) GetExpirationAsTime ¶ 

func (o *BareMetalMachineKeySetPatchProperties) GetExpirationAsTime() (*time.Time, error)

func (*BareMetalMachineKeySetPatchProperties) SetExpirationAsTime ¶ 

func (o *BareMetalMachineKeySetPatchProperties) SetExpirationAsTime(input time.Time)

type BareMetalMachineKeySetPrivilegeLevel ¶ 

type BareMetalMachineKeySetPrivilegeLevel string
const (
	BareMetalMachineKeySetPrivilegeLevelStandard  BareMetalMachineKeySetPrivilegeLevel = "Standard"
	BareMetalMachineKeySetPrivilegeLevelSuperuser BareMetalMachineKeySetPrivilegeLevel = "Superuser"
)

func (*BareMetalMachineKeySetPrivilegeLevel) UnmarshalJSON ¶ 

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

type BareMetalMachineKeySetProperties ¶ 

type BareMetalMachineKeySetProperties struct {
	AzureGroupId          string                                   `json:"azureGroupId"`
	DetailedStatus        *BareMetalMachineKeySetDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                                  `json:"detailedStatusMessage,omitempty"`
	Expiration            string                                   `json:"expiration"`
	JumpHostsAllowed      []string                                 `json:"jumpHostsAllowed"`
	LastValidation        *string                                  `json:"lastValidation,omitempty"`
	OsGroupName           *string                                  `json:"osGroupName,omitempty"`
	PrivilegeLevel        BareMetalMachineKeySetPrivilegeLevel     `json:"privilegeLevel"`
	ProvisioningState     *BareMetalMachineKeySetProvisioningState `json:"provisioningState,omitempty"`
	UserList              []KeySetUser                             `json:"userList"`
	UserListStatus        *[]KeySetUserStatus                      `json:"userListStatus,omitempty"`
}

func (*BareMetalMachineKeySetProperties) GetExpirationAsTime ¶ 

func (o *BareMetalMachineKeySetProperties) GetExpirationAsTime() (*time.Time, error)

func (*BareMetalMachineKeySetProperties) GetLastValidationAsTime ¶ 

func (o *BareMetalMachineKeySetProperties) GetLastValidationAsTime() (*time.Time, error)

func (*BareMetalMachineKeySetProperties) SetExpirationAsTime ¶ 

func (o *BareMetalMachineKeySetProperties) SetExpirationAsTime(input time.Time)

func (*BareMetalMachineKeySetProperties) SetLastValidationAsTime ¶ 

func (o *BareMetalMachineKeySetProperties) SetLastValidationAsTime(input time.Time)

type BareMetalMachineKeySetProvisioningState ¶ 

type BareMetalMachineKeySetProvisioningState string
const (
	BareMetalMachineKeySetProvisioningStateAccepted     BareMetalMachineKeySetProvisioningState = "Accepted"
	BareMetalMachineKeySetProvisioningStateCanceled     BareMetalMachineKeySetProvisioningState = "Canceled"
	BareMetalMachineKeySetProvisioningStateFailed       BareMetalMachineKeySetProvisioningState = "Failed"
	BareMetalMachineKeySetProvisioningStateProvisioning BareMetalMachineKeySetProvisioningState = "Provisioning"
	BareMetalMachineKeySetProvisioningStateSucceeded    BareMetalMachineKeySetProvisioningState = "Succeeded"
)

func (*BareMetalMachineKeySetProvisioningState) UnmarshalJSON ¶ 

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

type BareMetalMachineKeySetUserSetupStatus ¶ 

type BareMetalMachineKeySetUserSetupStatus string
const (
	BareMetalMachineKeySetUserSetupStatusActive  BareMetalMachineKeySetUserSetupStatus = "Active"
	BareMetalMachineKeySetUserSetupStatusInvalid BareMetalMachineKeySetUserSetupStatus = "Invalid"
)

func (*BareMetalMachineKeySetUserSetupStatus) UnmarshalJSON ¶ 

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

type BareMetalMachineKeySetsCreateOrUpdateOperationResponse ¶ 

type BareMetalMachineKeySetsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BareMetalMachineKeySet
}

type BareMetalMachineKeySetsDeleteOperationResponse ¶ 

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

type BareMetalMachineKeySetsGetOperationResponse ¶ 

type BareMetalMachineKeySetsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BareMetalMachineKeySet
}

type BareMetalMachineKeySetsListByClusterCompleteResult ¶ 

type BareMetalMachineKeySetsListByClusterCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []BareMetalMachineKeySet
}

type BareMetalMachineKeySetsListByClusterOperationResponse ¶ 

type BareMetalMachineKeySetsListByClusterOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]BareMetalMachineKeySet
}

type BareMetalMachineKeySetsUpdateOperationResponse ¶ 

type BareMetalMachineKeySetsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BareMetalMachineKeySet
}

type BareMetalMachineOperationPredicate ¶ 

type BareMetalMachineOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (BareMetalMachineOperationPredicate) Matches ¶ 

func (p BareMetalMachineOperationPredicate) Matches(input BareMetalMachine) bool

type BareMetalMachinePatchParameters ¶ 

type BareMetalMachinePatchParameters struct {
	Properties *BareMetalMachinePatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string               `json:"tags,omitempty"`
}

type BareMetalMachinePatchProperties ¶ 

type BareMetalMachinePatchProperties struct {
	MachineDetails *string `json:"machineDetails,omitempty"`
}

type BareMetalMachinePowerOffParameters ¶ 

type BareMetalMachinePowerOffParameters struct {
	SkipShutdown *BareMetalMachineSkipShutdown `json:"skipShutdown,omitempty"`
}

type BareMetalMachinePowerState ¶ 

type BareMetalMachinePowerState string
const (
	BareMetalMachinePowerStateOff BareMetalMachinePowerState = "Off"
	BareMetalMachinePowerStateOn  BareMetalMachinePowerState = "On"
)

func (*BareMetalMachinePowerState) UnmarshalJSON ¶ 

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

type BareMetalMachineProperties ¶ 

type BareMetalMachineProperties struct {
	AssociatedResourceIds          *[]string                          `json:"associatedResourceIds,omitempty"`
	BmcConnectionString            string                             `json:"bmcConnectionString"`
	BmcCredentials                 AdministrativeCredentials          `json:"bmcCredentials"`
	BmcMacAddress                  string                             `json:"bmcMacAddress"`
	BootMacAddress                 string                             `json:"bootMacAddress"`
	ClusterId                      *string                            `json:"clusterId,omitempty"`
	CordonStatus                   *BareMetalMachineCordonStatus      `json:"cordonStatus,omitempty"`
	DetailedStatus                 *BareMetalMachineDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage          *string                            `json:"detailedStatusMessage,omitempty"`
	HardwareInventory              *HardwareInventory                 `json:"hardwareInventory,omitempty"`
	HardwareValidationStatus       *HardwareValidationStatus          `json:"hardwareValidationStatus,omitempty"`
	HybridAksClustersAssociatedIds *[]string                          `json:"hybridAksClustersAssociatedIds,omitempty"`
	KubernetesNodeName             *string                            `json:"kubernetesNodeName,omitempty"`
	KubernetesVersion              *string                            `json:"kubernetesVersion,omitempty"`
	MachineDetails                 string                             `json:"machineDetails"`
	MachineName                    string                             `json:"machineName"`
	MachineSkuId                   string                             `json:"machineSkuId"`
	OamIPv4Address                 *string                            `json:"oamIpv4Address,omitempty"`
	OamIPv6Address                 *string                            `json:"oamIpv6Address,omitempty"`
	OsImage                        *string                            `json:"osImage,omitempty"`
	PowerState                     *BareMetalMachinePowerState        `json:"powerState,omitempty"`
	ProvisioningState              *BareMetalMachineProvisioningState `json:"provisioningState,omitempty"`
	RackId                         string                             `json:"rackId"`
	RackSlot                       int64                              `json:"rackSlot"`
	ReadyState                     *BareMetalMachineReadyState        `json:"readyState,omitempty"`
	SerialNumber                   string                             `json:"serialNumber"`
	ServiceTag                     *string                            `json:"serviceTag,omitempty"`
	VirtualMachinesAssociatedIds   *[]string                          `json:"virtualMachinesAssociatedIds,omitempty"`
}

type BareMetalMachineProvisioningState ¶ 

type BareMetalMachineProvisioningState string
const (
	BareMetalMachineProvisioningStateAccepted     BareMetalMachineProvisioningState = "Accepted"
	BareMetalMachineProvisioningStateCanceled     BareMetalMachineProvisioningState = "Canceled"
	BareMetalMachineProvisioningStateFailed       BareMetalMachineProvisioningState = "Failed"
	BareMetalMachineProvisioningStateProvisioning BareMetalMachineProvisioningState = "Provisioning"
	BareMetalMachineProvisioningStateSucceeded    BareMetalMachineProvisioningState = "Succeeded"
)

func (*BareMetalMachineProvisioningState) UnmarshalJSON ¶ 

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

type BareMetalMachineReadyState ¶ 

type BareMetalMachineReadyState string
const (
	BareMetalMachineReadyStateFalse BareMetalMachineReadyState = "False"
	BareMetalMachineReadyStateTrue  BareMetalMachineReadyState = "True"
)

func (*BareMetalMachineReadyState) UnmarshalJSON ¶ 

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

type BareMetalMachineReplaceParameters ¶ 

type BareMetalMachineReplaceParameters struct {
	BmcCredentials *AdministrativeCredentials `json:"bmcCredentials,omitempty"`
	BmcMacAddress  *string                    `json:"bmcMacAddress,omitempty"`
	BootMacAddress *string                    `json:"bootMacAddress,omitempty"`
	MachineName    *string                    `json:"machineName,omitempty"`
	SerialNumber   *string                    `json:"serialNumber,omitempty"`
}

type BareMetalMachineRunCommandParameters ¶ 

type BareMetalMachineRunCommandParameters struct {
	Arguments        *[]string `json:"arguments,omitempty"`
	LimitTimeSeconds int64     `json:"limitTimeSeconds"`
	Script           string    `json:"script"`
}

type BareMetalMachineRunDataExtractsParameters ¶ 

type BareMetalMachineRunDataExtractsParameters struct {
	Commands         []BareMetalMachineCommandSpecification `json:"commands"`
	LimitTimeSeconds int64                                  `json:"limitTimeSeconds"`
}

type BareMetalMachineRunReadCommandsParameters ¶ 

type BareMetalMachineRunReadCommandsParameters struct {
	Commands         []BareMetalMachineCommandSpecification `json:"commands"`
	LimitTimeSeconds int64                                  `json:"limitTimeSeconds"`
}

type BareMetalMachineSkipShutdown ¶ 

type BareMetalMachineSkipShutdown string
const (
	BareMetalMachineSkipShutdownFalse BareMetalMachineSkipShutdown = "False"
	BareMetalMachineSkipShutdownTrue  BareMetalMachineSkipShutdown = "True"
)

func (*BareMetalMachineSkipShutdown) UnmarshalJSON ¶ 

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

type BareMetalMachinesCordonOperationResponse ¶ 

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

type BareMetalMachinesCreateOrUpdateOperationResponse ¶ 

type BareMetalMachinesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BareMetalMachine
}

type BareMetalMachinesDeleteOperationResponse ¶ 

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

type BareMetalMachinesGetOperationResponse ¶ 

type BareMetalMachinesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BareMetalMachine
}

type BareMetalMachinesListByResourceGroupCompleteResult ¶ 

type BareMetalMachinesListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []BareMetalMachine
}

type BareMetalMachinesListByResourceGroupOperationResponse ¶ 

type BareMetalMachinesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]BareMetalMachine
}

type BareMetalMachinesListBySubscriptionCompleteResult ¶ 

type BareMetalMachinesListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []BareMetalMachine
}

type BareMetalMachinesListBySubscriptionOperationResponse ¶ 

type BareMetalMachinesListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]BareMetalMachine
}

type BareMetalMachinesPowerOffOperationResponse ¶ 

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

type BareMetalMachinesReimageOperationResponse ¶ 

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

type BareMetalMachinesReplaceOperationResponse ¶ 

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

type BareMetalMachinesRestartOperationResponse ¶ 

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

type BareMetalMachinesRunCommandOperationResponse ¶ 

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

type BareMetalMachinesRunDataExtractsOperationResponse ¶ 

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

type BareMetalMachinesRunReadCommandsOperationResponse ¶ 

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

type BareMetalMachinesStartOperationResponse ¶ 

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

type BareMetalMachinesUncordonOperationResponse ¶ 

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

type BareMetalMachinesUpdateOperationResponse ¶ 

type BareMetalMachinesUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BareMetalMachine
}

type BfdEnabled ¶ 

type BfdEnabled string
const (
	BfdEnabledFalse BfdEnabled = "False"
	BfdEnabledTrue  BfdEnabled = "True"
)

func (*BfdEnabled) UnmarshalJSON ¶ 

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

type BgpAdvertisement ¶ 

type BgpAdvertisement struct {
	AdvertiseToFabric *AdvertiseToFabric `json:"advertiseToFabric,omitempty"`
	Communities       *[]string          `json:"communities,omitempty"`
	IPAddressPools    []string           `json:"ipAddressPools"`
	Peers             *[]string          `json:"peers,omitempty"`
}

type BgpMultiHop ¶ 

type BgpMultiHop string
const (
	BgpMultiHopFalse BgpMultiHop = "False"
	BgpMultiHopTrue  BgpMultiHop = "True"
)

func (*BgpMultiHop) UnmarshalJSON ¶ 

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

type BgpServiceLoadBalancerConfiguration ¶ 

type BgpServiceLoadBalancerConfiguration struct {
	BgpAdvertisements    *[]BgpAdvertisement           `json:"bgpAdvertisements,omitempty"`
	BgpPeers             *[]ServiceLoadBalancerBgpPeer `json:"bgpPeers,omitempty"`
	FabricPeeringEnabled *FabricPeeringEnabled         `json:"fabricPeeringEnabled,omitempty"`
	IPAddressPools       *[]IPAddressPool              `json:"ipAddressPools,omitempty"`
}

type BmcKeySet ¶ 

type BmcKeySet struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       BmcKeySetProperties    `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type BmcKeySetDetailedStatus ¶ 

type BmcKeySetDetailedStatus string
const (
	BmcKeySetDetailedStatusAllActive   BmcKeySetDetailedStatus = "AllActive"
	BmcKeySetDetailedStatusAllInvalid  BmcKeySetDetailedStatus = "AllInvalid"
	BmcKeySetDetailedStatusSomeInvalid BmcKeySetDetailedStatus = "SomeInvalid"
	BmcKeySetDetailedStatusValidating  BmcKeySetDetailedStatus = "Validating"
)

func (*BmcKeySetDetailedStatus) UnmarshalJSON ¶ 

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

type BmcKeySetId ¶ 

type BmcKeySetId struct {
	SubscriptionId    string
	ResourceGroupName string
	ClusterName       string
	BmcKeySetName     string
}

BmcKeySetId is a struct representing the Resource ID for a Bmc Key Set

func NewBmcKeySetID ¶ 

func NewBmcKeySetID(subscriptionId string, resourceGroupName string, clusterName string, bmcKeySetName string) BmcKeySetId

NewBmcKeySetID returns a new BmcKeySetId struct

func ParseBmcKeySetID ¶ 

func ParseBmcKeySetID(input string) (*BmcKeySetId, error)

ParseBmcKeySetID parses 'input' into a BmcKeySetId

func ParseBmcKeySetIDInsensitively ¶ 

func ParseBmcKeySetIDInsensitively(input string) (*BmcKeySetId, error)

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

func (*BmcKeySetId) FromParseResult ¶ 

func (id *BmcKeySetId) FromParseResult(input resourceids.ParseResult) error

func (BmcKeySetId) ID ¶ 

func (id BmcKeySetId) ID() string

ID returns the formatted Bmc Key Set ID

func (BmcKeySetId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Bmc Key Set ID

func (BmcKeySetId) String ¶ 

func (id BmcKeySetId) String() string

String returns a human-readable description of this Bmc Key Set ID

type BmcKeySetOperationPredicate ¶ 

type BmcKeySetOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (BmcKeySetOperationPredicate) Matches ¶ 

func (p BmcKeySetOperationPredicate) Matches(input BmcKeySet) bool

type BmcKeySetPatchParameters ¶ 

type BmcKeySetPatchParameters struct {
	Properties *BmcKeySetPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string        `json:"tags,omitempty"`
}

type BmcKeySetPatchProperties ¶ 

type BmcKeySetPatchProperties struct {
	Expiration *string       `json:"expiration,omitempty"`
	UserList   *[]KeySetUser `json:"userList,omitempty"`
}

func (*BmcKeySetPatchProperties) GetExpirationAsTime ¶ 

func (o *BmcKeySetPatchProperties) GetExpirationAsTime() (*time.Time, error)

func (*BmcKeySetPatchProperties) SetExpirationAsTime ¶ 

func (o *BmcKeySetPatchProperties) SetExpirationAsTime(input time.Time)

type BmcKeySetPrivilegeLevel ¶ 

type BmcKeySetPrivilegeLevel string
const (
	BmcKeySetPrivilegeLevelAdministrator BmcKeySetPrivilegeLevel = "Administrator"
	BmcKeySetPrivilegeLevelReadOnly      BmcKeySetPrivilegeLevel = "ReadOnly"
)

func (*BmcKeySetPrivilegeLevel) UnmarshalJSON ¶ 

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

type BmcKeySetProperties ¶ 

type BmcKeySetProperties struct {
	AzureGroupId          string                      `json:"azureGroupId"`
	DetailedStatus        *BmcKeySetDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                     `json:"detailedStatusMessage,omitempty"`
	Expiration            string                      `json:"expiration"`
	LastValidation        *string                     `json:"lastValidation,omitempty"`
	PrivilegeLevel        BmcKeySetPrivilegeLevel     `json:"privilegeLevel"`
	ProvisioningState     *BmcKeySetProvisioningState `json:"provisioningState,omitempty"`
	UserList              []KeySetUser                `json:"userList"`
	UserListStatus        *[]KeySetUserStatus         `json:"userListStatus,omitempty"`
}

func (*BmcKeySetProperties) GetExpirationAsTime ¶ 

func (o *BmcKeySetProperties) GetExpirationAsTime() (*time.Time, error)

func (*BmcKeySetProperties) GetLastValidationAsTime ¶ 

func (o *BmcKeySetProperties) GetLastValidationAsTime() (*time.Time, error)

func (*BmcKeySetProperties) SetExpirationAsTime ¶ 

func (o *BmcKeySetProperties) SetExpirationAsTime(input time.Time)

func (*BmcKeySetProperties) SetLastValidationAsTime ¶ 

func (o *BmcKeySetProperties) SetLastValidationAsTime(input time.Time)

type BmcKeySetProvisioningState ¶ 

type BmcKeySetProvisioningState string
const (
	BmcKeySetProvisioningStateAccepted     BmcKeySetProvisioningState = "Accepted"
	BmcKeySetProvisioningStateCanceled     BmcKeySetProvisioningState = "Canceled"
	BmcKeySetProvisioningStateFailed       BmcKeySetProvisioningState = "Failed"
	BmcKeySetProvisioningStateProvisioning BmcKeySetProvisioningState = "Provisioning"
	BmcKeySetProvisioningStateSucceeded    BmcKeySetProvisioningState = "Succeeded"
)

func (*BmcKeySetProvisioningState) UnmarshalJSON ¶ 

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

type BmcKeySetsCreateOrUpdateOperationResponse ¶ 

type BmcKeySetsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BmcKeySet
}

type BmcKeySetsDeleteOperationResponse ¶ 

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

type BmcKeySetsGetOperationResponse ¶ 

type BmcKeySetsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BmcKeySet
}

type BmcKeySetsListByClusterCompleteResult ¶ 

type BmcKeySetsListByClusterCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []BmcKeySet
}

type BmcKeySetsListByClusterOperationResponse ¶ 

type BmcKeySetsListByClusterOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]BmcKeySet
}

type BmcKeySetsUpdateOperationResponse ¶ 

type BmcKeySetsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *BmcKeySet
}

type BootstrapProtocol ¶ 

type BootstrapProtocol string
const (
	BootstrapProtocolPXE BootstrapProtocol = "PXE"
)

func (*BootstrapProtocol) UnmarshalJSON ¶ 

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

type CloudServicesNetwork ¶ 

type CloudServicesNetwork struct {
	ExtendedLocation ExtendedLocation                `json:"extendedLocation"`
	Id               *string                         `json:"id,omitempty"`
	Location         string                          `json:"location"`
	Name             *string                         `json:"name,omitempty"`
	Properties       *CloudServicesNetworkProperties `json:"properties,omitempty"`
	SystemData       *systemdata.SystemData          `json:"systemData,omitempty"`
	Tags             *map[string]string              `json:"tags,omitempty"`
	Type             *string                         `json:"type,omitempty"`
}

type CloudServicesNetworkDetailedStatus ¶ 

type CloudServicesNetworkDetailedStatus string
const (
	CloudServicesNetworkDetailedStatusAvailable    CloudServicesNetworkDetailedStatus = "Available"
	CloudServicesNetworkDetailedStatusError        CloudServicesNetworkDetailedStatus = "Error"
	CloudServicesNetworkDetailedStatusProvisioning CloudServicesNetworkDetailedStatus = "Provisioning"
)

func (*CloudServicesNetworkDetailedStatus) UnmarshalJSON ¶ 

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

type CloudServicesNetworkEnableDefaultEgressEndpoints ¶ 

type CloudServicesNetworkEnableDefaultEgressEndpoints string
const (
	CloudServicesNetworkEnableDefaultEgressEndpointsFalse CloudServicesNetworkEnableDefaultEgressEndpoints = "False"
	CloudServicesNetworkEnableDefaultEgressEndpointsTrue  CloudServicesNetworkEnableDefaultEgressEndpoints = "True"
)

func (*CloudServicesNetworkEnableDefaultEgressEndpoints) UnmarshalJSON ¶ 

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

type CloudServicesNetworkId ¶ 

type CloudServicesNetworkId struct {
	SubscriptionId           string
	ResourceGroupName        string
	CloudServicesNetworkName string
}

CloudServicesNetworkId is a struct representing the Resource ID for a Cloud Services Network

func NewCloudServicesNetworkID ¶ 

func NewCloudServicesNetworkID(subscriptionId string, resourceGroupName string, cloudServicesNetworkName string) CloudServicesNetworkId

NewCloudServicesNetworkID returns a new CloudServicesNetworkId struct

func ParseCloudServicesNetworkID ¶ 

func ParseCloudServicesNetworkID(input string) (*CloudServicesNetworkId, error)

ParseCloudServicesNetworkID parses 'input' into a CloudServicesNetworkId

func ParseCloudServicesNetworkIDInsensitively ¶ 

func ParseCloudServicesNetworkIDInsensitively(input string) (*CloudServicesNetworkId, error)

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

func (*CloudServicesNetworkId) FromParseResult ¶ 

func (id *CloudServicesNetworkId) FromParseResult(input resourceids.ParseResult) error

func (CloudServicesNetworkId) ID ¶ 

func (id CloudServicesNetworkId) ID() string

ID returns the formatted Cloud Services Network ID

func (CloudServicesNetworkId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Cloud Services Network ID

func (CloudServicesNetworkId) String ¶ 

func (id CloudServicesNetworkId) String() string

String returns a human-readable description of this Cloud Services Network ID

type CloudServicesNetworkOperationPredicate ¶ 

type CloudServicesNetworkOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (CloudServicesNetworkOperationPredicate) Matches ¶ 

func (p CloudServicesNetworkOperationPredicate) Matches(input CloudServicesNetwork) bool

type CloudServicesNetworkPatchParameters ¶ 

type CloudServicesNetworkPatchParameters struct {
	Properties *CloudServicesNetworkPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string                   `json:"tags,omitempty"`
}

type CloudServicesNetworkPatchProperties ¶ 

type CloudServicesNetworkPatchProperties struct {
	AdditionalEgressEndpoints    *[]EgressEndpoint                                 `json:"additionalEgressEndpoints,omitempty"`
	EnableDefaultEgressEndpoints *CloudServicesNetworkEnableDefaultEgressEndpoints `json:"enableDefaultEgressEndpoints,omitempty"`
}

type CloudServicesNetworkProperties ¶ 

type CloudServicesNetworkProperties struct {
	AdditionalEgressEndpoints      *[]EgressEndpoint                                 `json:"additionalEgressEndpoints,omitempty"`
	AssociatedResourceIds          *[]string                                         `json:"associatedResourceIds,omitempty"`
	ClusterId                      *string                                           `json:"clusterId,omitempty"`
	DetailedStatus                 *CloudServicesNetworkDetailedStatus               `json:"detailedStatus,omitempty"`
	DetailedStatusMessage          *string                                           `json:"detailedStatusMessage,omitempty"`
	EnableDefaultEgressEndpoints   *CloudServicesNetworkEnableDefaultEgressEndpoints `json:"enableDefaultEgressEndpoints,omitempty"`
	EnabledEgressEndpoints         *[]EgressEndpoint                                 `json:"enabledEgressEndpoints,omitempty"`
	HybridAksClustersAssociatedIds *[]string                                         `json:"hybridAksClustersAssociatedIds,omitempty"`
	InterfaceName                  *string                                           `json:"interfaceName,omitempty"`
	ProvisioningState              *CloudServicesNetworkProvisioningState            `json:"provisioningState,omitempty"`
	VirtualMachinesAssociatedIds   *[]string                                         `json:"virtualMachinesAssociatedIds,omitempty"`
}

type CloudServicesNetworkProvisioningState ¶ 

type CloudServicesNetworkProvisioningState string
const (
	CloudServicesNetworkProvisioningStateAccepted     CloudServicesNetworkProvisioningState = "Accepted"
	CloudServicesNetworkProvisioningStateCanceled     CloudServicesNetworkProvisioningState = "Canceled"
	CloudServicesNetworkProvisioningStateFailed       CloudServicesNetworkProvisioningState = "Failed"
	CloudServicesNetworkProvisioningStateProvisioning CloudServicesNetworkProvisioningState = "Provisioning"
	CloudServicesNetworkProvisioningStateSucceeded    CloudServicesNetworkProvisioningState = "Succeeded"
)

func (*CloudServicesNetworkProvisioningState) UnmarshalJSON ¶ 

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

type CloudServicesNetworksCreateOrUpdateOperationResponse ¶ 

type CloudServicesNetworksCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *CloudServicesNetwork
}

type CloudServicesNetworksDeleteOperationResponse ¶ 

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

type CloudServicesNetworksGetOperationResponse ¶ 

type CloudServicesNetworksGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *CloudServicesNetwork
}

type CloudServicesNetworksListByResourceGroupCompleteResult ¶ 

type CloudServicesNetworksListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []CloudServicesNetwork
}

type CloudServicesNetworksListByResourceGroupOperationResponse ¶ 

type CloudServicesNetworksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]CloudServicesNetwork
}

type CloudServicesNetworksListBySubscriptionCompleteResult ¶ 

type CloudServicesNetworksListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []CloudServicesNetwork
}

type CloudServicesNetworksListBySubscriptionOperationResponse ¶ 

type CloudServicesNetworksListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]CloudServicesNetwork
}

type CloudServicesNetworksUpdateOperationResponse ¶ 

type CloudServicesNetworksUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *CloudServicesNetwork
}

type Cluster ¶ 

type Cluster struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       ClusterProperties      `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type ClusterAvailableUpgradeVersion ¶ 

type ClusterAvailableUpgradeVersion struct {
	ControlImpact        *ControlImpact  `json:"controlImpact,omitempty"`
	ExpectedDuration     *string         `json:"expectedDuration,omitempty"`
	ImpactDescription    *string         `json:"impactDescription,omitempty"`
	SupportExpiryDate    *string         `json:"supportExpiryDate,omitempty"`
	TargetClusterVersion *string         `json:"targetClusterVersion,omitempty"`
	WorkloadImpact       *WorkloadImpact `json:"workloadImpact,omitempty"`
}

type ClusterAvailableVersion ¶ 

type ClusterAvailableVersion struct {
	SupportExpiryDate    *string `json:"supportExpiryDate,omitempty"`
	TargetClusterVersion *string `json:"targetClusterVersion,omitempty"`
}

type ClusterCapacity ¶ 

type ClusterCapacity struct {
	AvailableApplianceStorageGB *int64 `json:"availableApplianceStorageGB,omitempty"`
	AvailableCoreCount          *int64 `json:"availableCoreCount,omitempty"`
	AvailableHostStorageGB      *int64 `json:"availableHostStorageGB,omitempty"`
	AvailableMemoryGB           *int64 `json:"availableMemoryGB,omitempty"`
	TotalApplianceStorageGB     *int64 `json:"totalApplianceStorageGB,omitempty"`
	TotalCoreCount              *int64 `json:"totalCoreCount,omitempty"`
	TotalHostStorageGB          *int64 `json:"totalHostStorageGB,omitempty"`
	TotalMemoryGB               *int64 `json:"totalMemoryGB,omitempty"`
}

type ClusterConnectionStatus ¶ 

type ClusterConnectionStatus string
const (
	ClusterConnectionStatusConnected ClusterConnectionStatus = "Connected"
	ClusterConnectionStatusTimeout   ClusterConnectionStatus = "Timeout"
	ClusterConnectionStatusUndefined ClusterConnectionStatus = "Undefined"
)

func (*ClusterConnectionStatus) UnmarshalJSON ¶ 

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

type ClusterDeployParameters ¶ 

type ClusterDeployParameters struct {
	SkipValidationsForMachines *[]string `json:"skipValidationsForMachines,omitempty"`
}

type ClusterDetailedStatus ¶ 

type ClusterDetailedStatus string
const (
	ClusterDetailedStatusDegraded          ClusterDetailedStatus = "Degraded"
	ClusterDetailedStatusDeleting          ClusterDetailedStatus = "Deleting"
	ClusterDetailedStatusDeploying         ClusterDetailedStatus = "Deploying"
	ClusterDetailedStatusDisconnected      ClusterDetailedStatus = "Disconnected"
	ClusterDetailedStatusFailed            ClusterDetailedStatus = "Failed"
	ClusterDetailedStatusPendingDeployment ClusterDetailedStatus = "PendingDeployment"
	ClusterDetailedStatusRunning           ClusterDetailedStatus = "Running"
	ClusterDetailedStatusUpdating          ClusterDetailedStatus = "Updating"
)

func (*ClusterDetailedStatus) UnmarshalJSON ¶ 

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

type ClusterId ¶ 

type ClusterId struct {
	SubscriptionId    string
	ResourceGroupName string
	ClusterName       string
}

ClusterId is a struct representing the Resource ID for a Cluster

func NewClusterID ¶ 

func NewClusterID(subscriptionId string, resourceGroupName string, clusterName string) ClusterId

NewClusterID returns a new ClusterId struct

func ParseClusterID ¶ 

func ParseClusterID(input string) (*ClusterId, error)

ParseClusterID parses 'input' into a ClusterId

func ParseClusterIDInsensitively ¶ 

func ParseClusterIDInsensitively(input string) (*ClusterId, error)

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

func (*ClusterId) FromParseResult ¶ 

func (id *ClusterId) FromParseResult(input resourceids.ParseResult) error

func (ClusterId) ID ¶ 

func (id ClusterId) ID() string

ID returns the formatted Cluster ID

func (ClusterId) Segments ¶ 

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

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

func (ClusterId) String ¶ 

func (id ClusterId) String() string

String returns a human-readable description of this Cluster ID

type ClusterManager ¶ 

type ClusterManager struct {
	Id         *string                  `json:"id,omitempty"`
	Location   string                   `json:"location"`
	Name       *string                  `json:"name,omitempty"`
	Properties ClusterManagerProperties `json:"properties"`
	SystemData *systemdata.SystemData   `json:"systemData,omitempty"`
	Tags       *map[string]string       `json:"tags,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type ClusterManagerConnectionStatus ¶ 

type ClusterManagerConnectionStatus string
const (
	ClusterManagerConnectionStatusConnected   ClusterManagerConnectionStatus = "Connected"
	ClusterManagerConnectionStatusUnreachable ClusterManagerConnectionStatus = "Unreachable"
)

func (*ClusterManagerConnectionStatus) UnmarshalJSON ¶ 

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

type ClusterManagerDetailedStatus ¶ 

type ClusterManagerDetailedStatus string
const (
	ClusterManagerDetailedStatusAvailable          ClusterManagerDetailedStatus = "Available"
	ClusterManagerDetailedStatusError              ClusterManagerDetailedStatus = "Error"
	ClusterManagerDetailedStatusProvisioning       ClusterManagerDetailedStatus = "Provisioning"
	ClusterManagerDetailedStatusProvisioningFailed ClusterManagerDetailedStatus = "ProvisioningFailed"
	ClusterManagerDetailedStatusUpdateFailed       ClusterManagerDetailedStatus = "UpdateFailed"
	ClusterManagerDetailedStatusUpdating           ClusterManagerDetailedStatus = "Updating"
)

func (*ClusterManagerDetailedStatus) UnmarshalJSON ¶ 

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

type ClusterManagerId ¶ 

type ClusterManagerId struct {
	SubscriptionId     string
	ResourceGroupName  string
	ClusterManagerName string
}

ClusterManagerId is a struct representing the Resource ID for a Cluster Manager

func NewClusterManagerID ¶ 

func NewClusterManagerID(subscriptionId string, resourceGroupName string, clusterManagerName string) ClusterManagerId

NewClusterManagerID returns a new ClusterManagerId struct

func ParseClusterManagerID ¶ 

func ParseClusterManagerID(input string) (*ClusterManagerId, error)

ParseClusterManagerID parses 'input' into a ClusterManagerId

func ParseClusterManagerIDInsensitively ¶ 

func ParseClusterManagerIDInsensitively(input string) (*ClusterManagerId, error)

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

func (*ClusterManagerId) FromParseResult ¶ 

func (id *ClusterManagerId) FromParseResult(input resourceids.ParseResult) error

func (ClusterManagerId) ID ¶ 

func (id ClusterManagerId) ID() string

ID returns the formatted Cluster Manager ID

func (ClusterManagerId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Cluster Manager ID

func (ClusterManagerId) String ¶ 

func (id ClusterManagerId) String() string

String returns a human-readable description of this Cluster Manager ID

type ClusterManagerOperationPredicate ¶ 

type ClusterManagerOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (ClusterManagerOperationPredicate) Matches ¶ 

func (p ClusterManagerOperationPredicate) Matches(input ClusterManager) bool

type ClusterManagerPatchParameters ¶ 

type ClusterManagerPatchParameters struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

type ClusterManagerProperties ¶ 

type ClusterManagerProperties struct {
	AnalyticsWorkspaceId              *string                            `json:"analyticsWorkspaceId,omitempty"`
	AvailabilityZones                 *zones.Schema                      `json:"availabilityZones,omitempty"`
	ClusterVersions                   *[]ClusterAvailableVersion         `json:"clusterVersions,omitempty"`
	DetailedStatus                    *ClusterManagerDetailedStatus      `json:"detailedStatus,omitempty"`
	DetailedStatusMessage             *string                            `json:"detailedStatusMessage,omitempty"`
	FabricControllerId                string                             `json:"fabricControllerId"`
	ManagedResourceGroupConfiguration *ManagedResourceGroupConfiguration `json:"managedResourceGroupConfiguration,omitempty"`
	ManagerExtendedLocation           *ExtendedLocation                  `json:"managerExtendedLocation,omitempty"`
	ProvisioningState                 *ClusterManagerProvisioningState   `json:"provisioningState,omitempty"`
	VMSize                            *string                            `json:"vmSize,omitempty"`
}

type ClusterManagerProvisioningState ¶ 

type ClusterManagerProvisioningState string
const (
	ClusterManagerProvisioningStateAccepted     ClusterManagerProvisioningState = "Accepted"
	ClusterManagerProvisioningStateCanceled     ClusterManagerProvisioningState = "Canceled"
	ClusterManagerProvisioningStateFailed       ClusterManagerProvisioningState = "Failed"
	ClusterManagerProvisioningStateProvisioning ClusterManagerProvisioningState = "Provisioning"
	ClusterManagerProvisioningStateSucceeded    ClusterManagerProvisioningState = "Succeeded"
	ClusterManagerProvisioningStateUpdating     ClusterManagerProvisioningState = "Updating"
)

func (*ClusterManagerProvisioningState) UnmarshalJSON ¶ 

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

type ClusterManagersCreateOrUpdateOperationResponse ¶ 

type ClusterManagersCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *ClusterManager
}

type ClusterManagersDeleteOperationResponse ¶ 

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

type ClusterManagersGetOperationResponse ¶ 

type ClusterManagersGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *ClusterManager
}

type ClusterManagersListByResourceGroupCompleteResult ¶ 

type ClusterManagersListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []ClusterManager
}

type ClusterManagersListByResourceGroupOperationResponse ¶ 

type ClusterManagersListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]ClusterManager
}

type ClusterManagersListBySubscriptionCompleteResult ¶ 

type ClusterManagersListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []ClusterManager
}

type ClusterManagersListBySubscriptionOperationResponse ¶ 

type ClusterManagersListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]ClusterManager
}

type ClusterManagersUpdateOperationResponse ¶ 

type ClusterManagersUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *ClusterManager
}

type ClusterMetricsConfiguration ¶ 

type ClusterMetricsConfiguration struct {
	ExtendedLocation ExtendedLocation                      `json:"extendedLocation"`
	Id               *string                               `json:"id,omitempty"`
	Location         string                                `json:"location"`
	Name             *string                               `json:"name,omitempty"`
	Properties       ClusterMetricsConfigurationProperties `json:"properties"`
	SystemData       *systemdata.SystemData                `json:"systemData,omitempty"`
	Tags             *map[string]string                    `json:"tags,omitempty"`
	Type             *string                               `json:"type,omitempty"`
}

type ClusterMetricsConfigurationDetailedStatus ¶ 

type ClusterMetricsConfigurationDetailedStatus string
const (
	ClusterMetricsConfigurationDetailedStatusApplied    ClusterMetricsConfigurationDetailedStatus = "Applied"
	ClusterMetricsConfigurationDetailedStatusError      ClusterMetricsConfigurationDetailedStatus = "Error"
	ClusterMetricsConfigurationDetailedStatusProcessing ClusterMetricsConfigurationDetailedStatus = "Processing"
)

func (*ClusterMetricsConfigurationDetailedStatus) UnmarshalJSON ¶ 

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

type ClusterMetricsConfigurationOperationPredicate ¶ 

type ClusterMetricsConfigurationOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (ClusterMetricsConfigurationOperationPredicate) Matches ¶ 

func (p ClusterMetricsConfigurationOperationPredicate) Matches(input ClusterMetricsConfiguration) bool

type ClusterMetricsConfigurationPatchParameters ¶ 

type ClusterMetricsConfigurationPatchParameters struct {
	Properties *ClusterMetricsConfigurationPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string                          `json:"tags,omitempty"`
}

type ClusterMetricsConfigurationPatchProperties ¶ 

type ClusterMetricsConfigurationPatchProperties struct {
	CollectionInterval *int64    `json:"collectionInterval,omitempty"`
	EnabledMetrics     *[]string `json:"enabledMetrics,omitempty"`
}

type ClusterMetricsConfigurationProperties ¶ 

type ClusterMetricsConfigurationProperties struct {
	CollectionInterval    int64                                         `json:"collectionInterval"`
	DetailedStatus        *ClusterMetricsConfigurationDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                                       `json:"detailedStatusMessage,omitempty"`
	DisabledMetrics       *[]string                                     `json:"disabledMetrics,omitempty"`
	EnabledMetrics        *[]string                                     `json:"enabledMetrics,omitempty"`
	ProvisioningState     *ClusterMetricsConfigurationProvisioningState `json:"provisioningState,omitempty"`
}

type ClusterMetricsConfigurationProvisioningState ¶ 

type ClusterMetricsConfigurationProvisioningState string
const (
	ClusterMetricsConfigurationProvisioningStateAccepted     ClusterMetricsConfigurationProvisioningState = "Accepted"
	ClusterMetricsConfigurationProvisioningStateCanceled     ClusterMetricsConfigurationProvisioningState = "Canceled"
	ClusterMetricsConfigurationProvisioningStateFailed       ClusterMetricsConfigurationProvisioningState = "Failed"
	ClusterMetricsConfigurationProvisioningStateProvisioning ClusterMetricsConfigurationProvisioningState = "Provisioning"
	ClusterMetricsConfigurationProvisioningStateSucceeded    ClusterMetricsConfigurationProvisioningState = "Succeeded"
)

func (*ClusterMetricsConfigurationProvisioningState) UnmarshalJSON ¶ 

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

type ClusterOperationPredicate ¶ 

type ClusterOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (ClusterOperationPredicate) Matches ¶ 

func (p ClusterOperationPredicate) Matches(input Cluster) bool

type ClusterPatchParameters ¶ 

type ClusterPatchParameters struct {
	Properties *ClusterPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string      `json:"tags,omitempty"`
}

type ClusterPatchProperties ¶ 

type ClusterPatchProperties struct {
	AggregatorOrSingleRackDefinition *RackDefinition              `json:"aggregatorOrSingleRackDefinition,omitempty"`
	ClusterLocation                  *string                      `json:"clusterLocation,omitempty"`
	ClusterServicePrincipal          *ServicePrincipalInformation `json:"clusterServicePrincipal,omitempty"`
	ComputeDeploymentThreshold       *ValidationThreshold         `json:"computeDeploymentThreshold,omitempty"`
	ComputeRackDefinitions           *[]RackDefinition            `json:"computeRackDefinitions,omitempty"`
}

type ClusterProperties ¶ 

type ClusterProperties struct {
	AggregatorOrSingleRackDefinition  RackDefinition                     `json:"aggregatorOrSingleRackDefinition"`
	AnalyticsWorkspaceId              *string                            `json:"analyticsWorkspaceId,omitempty"`
	AvailableUpgradeVersions          *[]ClusterAvailableUpgradeVersion  `json:"availableUpgradeVersions,omitempty"`
	ClusterCapacity                   *ClusterCapacity                   `json:"clusterCapacity,omitempty"`
	ClusterConnectionStatus           *ClusterConnectionStatus           `json:"clusterConnectionStatus,omitempty"`
	ClusterExtendedLocation           *ExtendedLocation                  `json:"clusterExtendedLocation,omitempty"`
	ClusterLocation                   *string                            `json:"clusterLocation,omitempty"`
	ClusterManagerConnectionStatus    *ClusterManagerConnectionStatus    `json:"clusterManagerConnectionStatus,omitempty"`
	ClusterManagerId                  *string                            `json:"clusterManagerId,omitempty"`
	ClusterServicePrincipal           *ServicePrincipalInformation       `json:"clusterServicePrincipal,omitempty"`
	ClusterType                       ClusterType                        `json:"clusterType"`
	ClusterVersion                    string                             `json:"clusterVersion"`
	ComputeDeploymentThreshold        *ValidationThreshold               `json:"computeDeploymentThreshold,omitempty"`
	ComputeRackDefinitions            *[]RackDefinition                  `json:"computeRackDefinitions,omitempty"`
	DetailedStatus                    *ClusterDetailedStatus             `json:"detailedStatus,omitempty"`
	DetailedStatusMessage             *string                            `json:"detailedStatusMessage,omitempty"`
	HybridAksExtendedLocation         *ExtendedLocation                  `json:"hybridAksExtendedLocation,omitempty"`
	ManagedResourceGroupConfiguration *ManagedResourceGroupConfiguration `json:"managedResourceGroupConfiguration,omitempty"`
	ManualActionCount                 *int64                             `json:"manualActionCount,omitempty"`
	NetworkFabricId                   string                             `json:"networkFabricId"`
	ProvisioningState                 *ClusterProvisioningState          `json:"provisioningState,omitempty"`
	SupportExpiryDate                 *string                            `json:"supportExpiryDate,omitempty"`
	WorkloadResourceIds               *[]string                          `json:"workloadResourceIds,omitempty"`
}

type ClusterProvisioningState ¶ 

type ClusterProvisioningState string
const (
	ClusterProvisioningStateAccepted   ClusterProvisioningState = "Accepted"
	ClusterProvisioningStateCanceled   ClusterProvisioningState = "Canceled"
	ClusterProvisioningStateFailed     ClusterProvisioningState = "Failed"
	ClusterProvisioningStateSucceeded  ClusterProvisioningState = "Succeeded"
	ClusterProvisioningStateUpdating   ClusterProvisioningState = "Updating"
	ClusterProvisioningStateValidating ClusterProvisioningState = "Validating"
)

func (*ClusterProvisioningState) UnmarshalJSON ¶ 

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

type ClusterType ¶ 

type ClusterType string
const (
	ClusterTypeMultiRack  ClusterType = "MultiRack"
	ClusterTypeSingleRack ClusterType = "SingleRack"
)

func (*ClusterType) UnmarshalJSON ¶ 

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

type ClusterUpdateVersionParameters ¶ 

type ClusterUpdateVersionParameters struct {
	TargetClusterVersion string `json:"targetClusterVersion"`
}

type ClustersCreateOrUpdateOperationResponse ¶ 

type ClustersCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Cluster
}

type ClustersDeleteOperationResponse ¶ 

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

type ClustersDeployOperationResponse ¶ 

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

type ClustersGetOperationResponse ¶ 

type ClustersGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Cluster
}

type ClustersListByResourceGroupCompleteResult ¶ 

type ClustersListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Cluster
}

type ClustersListByResourceGroupOperationResponse ¶ 

type ClustersListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Cluster
}

type ClustersListBySubscriptionCompleteResult ¶ 

type ClustersListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Cluster
}

type ClustersListBySubscriptionOperationResponse ¶ 

type ClustersListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Cluster
}

type ClustersUpdateOperationResponse ¶ 

type ClustersUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Cluster
}

type ClustersUpdateVersionOperationResponse ¶ 

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

type Console ¶ 

type Console struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       ConsoleProperties      `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type ConsoleDetailedStatus ¶ 

type ConsoleDetailedStatus string
const (
	ConsoleDetailedStatusError ConsoleDetailedStatus = "Error"
	ConsoleDetailedStatusReady ConsoleDetailedStatus = "Ready"
)

func (*ConsoleDetailedStatus) UnmarshalJSON ¶ 

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

type ConsoleEnabled ¶ 

type ConsoleEnabled string
const (
	ConsoleEnabledFalse ConsoleEnabled = "False"
	ConsoleEnabledTrue  ConsoleEnabled = "True"
)

func (*ConsoleEnabled) UnmarshalJSON ¶ 

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

type ConsoleId ¶ 

type ConsoleId struct {
	SubscriptionId     string
	ResourceGroupName  string
	VirtualMachineName string
	ConsoleName        string
}

ConsoleId is a struct representing the Resource ID for a Console

func NewConsoleID ¶ 

func NewConsoleID(subscriptionId string, resourceGroupName string, virtualMachineName string, consoleName string) ConsoleId

NewConsoleID returns a new ConsoleId struct

func ParseConsoleID ¶ 

func ParseConsoleID(input string) (*ConsoleId, error)

ParseConsoleID parses 'input' into a ConsoleId

func ParseConsoleIDInsensitively ¶ 

func ParseConsoleIDInsensitively(input string) (*ConsoleId, error)

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

func (*ConsoleId) FromParseResult ¶ 

func (id *ConsoleId) FromParseResult(input resourceids.ParseResult) error

func (ConsoleId) ID ¶ 

func (id ConsoleId) ID() string

ID returns the formatted Console ID

func (ConsoleId) Segments ¶ 

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

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

func (ConsoleId) String ¶ 

func (id ConsoleId) String() string

String returns a human-readable description of this Console ID

type ConsoleOperationPredicate ¶ 

type ConsoleOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (ConsoleOperationPredicate) Matches ¶ 

func (p ConsoleOperationPredicate) Matches(input Console) bool

type ConsolePatchParameters ¶ 

type ConsolePatchParameters struct {
	Properties *ConsolePatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string      `json:"tags,omitempty"`
}

type ConsolePatchProperties ¶ 

type ConsolePatchProperties struct {
	Enabled      *ConsoleEnabled `json:"enabled,omitempty"`
	Expiration   *string         `json:"expiration,omitempty"`
	SshPublicKey *SshPublicKey   `json:"sshPublicKey,omitempty"`
}

func (*ConsolePatchProperties) GetExpirationAsTime ¶ 

func (o *ConsolePatchProperties) GetExpirationAsTime() (*time.Time, error)

func (*ConsolePatchProperties) SetExpirationAsTime ¶ 

func (o *ConsolePatchProperties) SetExpirationAsTime(input time.Time)

type ConsoleProperties ¶ 

type ConsoleProperties struct {
	DetailedStatus         *ConsoleDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage  *string                   `json:"detailedStatusMessage,omitempty"`
	Enabled                ConsoleEnabled            `json:"enabled"`
	Expiration             *string                   `json:"expiration,omitempty"`
	PrivateLinkServiceId   *string                   `json:"privateLinkServiceId,omitempty"`
	ProvisioningState      *ConsoleProvisioningState `json:"provisioningState,omitempty"`
	SshPublicKey           SshPublicKey              `json:"sshPublicKey"`
	VirtualMachineAccessId *string                   `json:"virtualMachineAccessId,omitempty"`
}

func (*ConsoleProperties) GetExpirationAsTime ¶ 

func (o *ConsoleProperties) GetExpirationAsTime() (*time.Time, error)

func (*ConsoleProperties) SetExpirationAsTime ¶ 

func (o *ConsoleProperties) SetExpirationAsTime(input time.Time)

type ConsoleProvisioningState ¶ 

type ConsoleProvisioningState string
const (
	ConsoleProvisioningStateAccepted     ConsoleProvisioningState = "Accepted"
	ConsoleProvisioningStateCanceled     ConsoleProvisioningState = "Canceled"
	ConsoleProvisioningStateFailed       ConsoleProvisioningState = "Failed"
	ConsoleProvisioningStateProvisioning ConsoleProvisioningState = "Provisioning"
	ConsoleProvisioningStateSucceeded    ConsoleProvisioningState = "Succeeded"
)

func (*ConsoleProvisioningState) UnmarshalJSON ¶ 

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

type ConsolesCreateOrUpdateOperationResponse ¶ 

type ConsolesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Console
}

type ConsolesDeleteOperationResponse ¶ 

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

type ConsolesGetOperationResponse ¶ 

type ConsolesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Console
}

type ConsolesListByVirtualMachineCompleteResult ¶ 

type ConsolesListByVirtualMachineCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Console
}

type ConsolesListByVirtualMachineOperationResponse ¶ 

type ConsolesListByVirtualMachineOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Console
}

type ConsolesUpdateOperationResponse ¶ 

type ConsolesUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Console
}

type ControlImpact ¶ 

type ControlImpact string
const (
	ControlImpactFalse ControlImpact = "False"
	ControlImpactTrue  ControlImpact = "True"
)

func (*ControlImpact) UnmarshalJSON ¶ 

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

type ControlPlaneNodeConfiguration ¶ 

type ControlPlaneNodeConfiguration struct {
	AdministratorConfiguration *AdministratorConfiguration `json:"administratorConfiguration,omitempty"`
	AvailabilityZones          *zones.Schema               `json:"availabilityZones,omitempty"`
	Count                      int64                       `json:"count"`
	VMSkuName                  string                      `json:"vmSkuName"`
}

type ControlPlaneNodePatchConfiguration ¶ 

type ControlPlaneNodePatchConfiguration struct {
	Count *int64 `json:"count,omitempty"`
}

type DefaultGateway ¶ 

type DefaultGateway string
const (
	DefaultGatewayFalse DefaultGateway = "False"
	DefaultGatewayTrue  DefaultGateway = "True"
)

func (*DefaultGateway) UnmarshalJSON ¶ 

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

type DeviceConnectionType ¶ 

type DeviceConnectionType string
const (
	DeviceConnectionTypePCI DeviceConnectionType = "PCI"
)

func (*DeviceConnectionType) UnmarshalJSON ¶ 

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

type DiskType ¶ 

type DiskType string
const (
	DiskTypeHDD DiskType = "HDD"
	DiskTypeSSD DiskType = "SSD"
)

func (*DiskType) UnmarshalJSON ¶ 

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

type EgressEndpoint ¶ 

type EgressEndpoint struct {
	Category  string               `json:"category"`
	Endpoints []EndpointDependency `json:"endpoints"`
}

type EndpointDependency ¶ 

type EndpointDependency struct {
	DomainName string `json:"domainName"`
	Port       *int64 `json:"port,omitempty"`
}

type ExtendedLocation ¶ 

type ExtendedLocation struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type FabricPeeringEnabled ¶ 

type FabricPeeringEnabled string
const (
	FabricPeeringEnabledFalse FabricPeeringEnabled = "False"
	FabricPeeringEnabledTrue  FabricPeeringEnabled = "True"
)

func (*FabricPeeringEnabled) UnmarshalJSON ¶ 

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

type FeatureDetailedStatus ¶ 

type FeatureDetailedStatus string
const (
	FeatureDetailedStatusFailed  FeatureDetailedStatus = "Failed"
	FeatureDetailedStatusRunning FeatureDetailedStatus = "Running"
	FeatureDetailedStatusUnknown FeatureDetailedStatus = "Unknown"
)

func (*FeatureDetailedStatus) UnmarshalJSON ¶ 

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

type FeatureStatus ¶ 

type FeatureStatus struct {
	DetailedStatus        *FeatureDetailedStatus `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                `json:"detailedStatusMessage,omitempty"`
	Name                  *string                `json:"name,omitempty"`
	Version               *string                `json:"version,omitempty"`
}

type HardwareInventory ¶ 

type HardwareInventory struct {
	AdditionalHostInformation *string                              `json:"additionalHostInformation,omitempty"`
	Interfaces                *[]HardwareInventoryNetworkInterface `json:"interfaces,omitempty"`
	Nics                      *[]Nic                               `json:"nics,omitempty"`
}

type HardwareInventoryNetworkInterface ¶ 

type HardwareInventoryNetworkInterface struct {
	LinkStatus         *string `json:"linkStatus,omitempty"`
	MacAddress         *string `json:"macAddress,omitempty"`
	Name               *string `json:"name,omitempty"`
	NetworkInterfaceId *string `json:"networkInterfaceId,omitempty"`
}

type HardwareValidationStatus ¶ 

type HardwareValidationStatus struct {
	LastValidationTime *string                                   `json:"lastValidationTime,omitempty"`
	Result             *BareMetalMachineHardwareValidationResult `json:"result,omitempty"`
}

func (*HardwareValidationStatus) GetLastValidationTimeAsTime ¶ 

func (o *HardwareValidationStatus) GetLastValidationTimeAsTime() (*time.Time, error)

func (*HardwareValidationStatus) SetLastValidationTimeAsTime ¶ 

func (o *HardwareValidationStatus) SetLastValidationTimeAsTime(input time.Time)

type HugepagesSize ¶ 

type HugepagesSize string
const (
	HugepagesSizeOneG HugepagesSize = "1G"
	HugepagesSizeTwoM HugepagesSize = "2M"
)

func (*HugepagesSize) UnmarshalJSON ¶ 

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

type HybridAksIPamEnabled ¶ 

type HybridAksIPamEnabled string
const (
	HybridAksIPamEnabledFalse HybridAksIPamEnabled = "False"
	HybridAksIPamEnabledTrue  HybridAksIPamEnabled = "True"
)

func (*HybridAksIPamEnabled) UnmarshalJSON ¶ 

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

type HybridAksPluginType ¶ 

type HybridAksPluginType string
const (
	HybridAksPluginTypeDPDK     HybridAksPluginType = "DPDK"
	HybridAksPluginTypeOSDevice HybridAksPluginType = "OSDevice"
	HybridAksPluginTypeSRIOV    HybridAksPluginType = "SRIOV"
)

func (*HybridAksPluginType) UnmarshalJSON ¶ 

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

type IPAddressPool ¶ 

type IPAddressPool struct {
	Addresses      []string    `json:"addresses"`
	AutoAssign     *BfdEnabled `json:"autoAssign,omitempty"`
	Name           string      `json:"name"`
	OnlyUseHostIPs *BfdEnabled `json:"onlyUseHostIps,omitempty"`
}

type IPAllocationType ¶ 

type IPAllocationType string
const (
	IPAllocationTypeDualStack IPAllocationType = "DualStack"
	IPAllocationTypeIPVFour   IPAllocationType = "IPV4"
	IPAllocationTypeIPVSix    IPAllocationType = "IPV6"
)

func (*IPAllocationType) UnmarshalJSON ¶ 

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

type ImageRepositoryCredentials ¶ 

type ImageRepositoryCredentials struct {
	Password    string `json:"password"`
	RegistryUrl string `json:"registryUrl"`
	Username    string `json:"username"`
}

type InitialAgentPoolConfiguration ¶ 

type InitialAgentPoolConfiguration struct {
	AdministratorConfiguration   *AdministratorConfiguration   `json:"administratorConfiguration,omitempty"`
	AgentOptions                 *AgentOptions                 `json:"agentOptions,omitempty"`
	AttachedNetworkConfiguration *AttachedNetworkConfiguration `json:"attachedNetworkConfiguration,omitempty"`
	AvailabilityZones            *zones.Schema                 `json:"availabilityZones,omitempty"`
	Count                        int64                         `json:"count"`
	Labels                       *[]KubernetesLabel            `json:"labels,omitempty"`
	Mode                         AgentPoolMode                 `json:"mode"`
	Name                         string                        `json:"name"`
	Taints                       *[]KubernetesLabel            `json:"taints,omitempty"`
	UpgradeSettings              *AgentPoolUpgradeSettings     `json:"upgradeSettings,omitempty"`
	VMSkuName                    string                        `json:"vmSkuName"`
}

type KeySetUser ¶ 

type KeySetUser struct {
	AzureUserName string       `json:"azureUserName"`
	Description   *string      `json:"description,omitempty"`
	SshPublicKey  SshPublicKey `json:"sshPublicKey"`
}

type KeySetUserStatus ¶ 

type KeySetUserStatus struct {
	AzureUserName *string                                `json:"azureUserName,omitempty"`
	Status        *BareMetalMachineKeySetUserSetupStatus `json:"status,omitempty"`
	StatusMessage *string                                `json:"statusMessage,omitempty"`
}

type KubernetesCluster ¶ 

type KubernetesCluster struct {
	ExtendedLocation ExtendedLocation            `json:"extendedLocation"`
	Id               *string                     `json:"id,omitempty"`
	Location         string                      `json:"location"`
	Name             *string                     `json:"name,omitempty"`
	Properties       KubernetesClusterProperties `json:"properties"`
	SystemData       *systemdata.SystemData      `json:"systemData,omitempty"`
	Tags             *map[string]string          `json:"tags,omitempty"`
	Type             *string                     `json:"type,omitempty"`
}

type KubernetesClusterDetailedStatus ¶ 

type KubernetesClusterDetailedStatus string
const (
	KubernetesClusterDetailedStatusAvailable    KubernetesClusterDetailedStatus = "Available"
	KubernetesClusterDetailedStatusError        KubernetesClusterDetailedStatus = "Error"
	KubernetesClusterDetailedStatusProvisioning KubernetesClusterDetailedStatus = "Provisioning"
)

func (*KubernetesClusterDetailedStatus) UnmarshalJSON ¶ 

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

type KubernetesClusterId ¶ 

type KubernetesClusterId struct {
	SubscriptionId        string
	ResourceGroupName     string
	KubernetesClusterName string
}

KubernetesClusterId is a struct representing the Resource ID for a Kubernetes Cluster

func NewKubernetesClusterID ¶ 

func NewKubernetesClusterID(subscriptionId string, resourceGroupName string, kubernetesClusterName string) KubernetesClusterId

NewKubernetesClusterID returns a new KubernetesClusterId struct

func ParseKubernetesClusterID ¶ 

func ParseKubernetesClusterID(input string) (*KubernetesClusterId, error)

ParseKubernetesClusterID parses 'input' into a KubernetesClusterId

func ParseKubernetesClusterIDInsensitively ¶ 

func ParseKubernetesClusterIDInsensitively(input string) (*KubernetesClusterId, error)

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

func (*KubernetesClusterId) FromParseResult ¶ 

func (id *KubernetesClusterId) FromParseResult(input resourceids.ParseResult) error

func (KubernetesClusterId) ID ¶ 

func (id KubernetesClusterId) ID() string

ID returns the formatted Kubernetes Cluster ID

func (KubernetesClusterId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Kubernetes Cluster ID

func (KubernetesClusterId) String ¶ 

func (id KubernetesClusterId) String() string

String returns a human-readable description of this Kubernetes Cluster ID

type KubernetesClusterNode ¶ 

type KubernetesClusterNode struct {
	AgentPoolId           *string                              `json:"agentPoolId,omitempty"`
	AvailabilityZone      *string                              `json:"availabilityZone,omitempty"`
	BareMetalMachineId    *string                              `json:"bareMetalMachineId,omitempty"`
	CpuCores              *int64                               `json:"cpuCores,omitempty"`
	DetailedStatus        *KubernetesClusterNodeDetailedStatus `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                              `json:"detailedStatusMessage,omitempty"`
	DiskSizeGB            *int64                               `json:"diskSizeGB,omitempty"`
	Image                 *string                              `json:"image,omitempty"`
	KubernetesVersion     *string                              `json:"kubernetesVersion,omitempty"`
	Labels                *[]KubernetesLabel                   `json:"labels,omitempty"`
	MemorySizeGB          *int64                               `json:"memorySizeGB,omitempty"`
	Mode                  *AgentPoolMode                       `json:"mode,omitempty"`
	Name                  *string                              `json:"name,omitempty"`
	NetworkAttachments    *[]NetworkAttachment                 `json:"networkAttachments,omitempty"`
	PowerState            *KubernetesNodePowerState            `json:"powerState,omitempty"`
	Role                  *KubernetesNodeRole                  `json:"role,omitempty"`
	Taints                *[]KubernetesLabel                   `json:"taints,omitempty"`
	VMSkuName             *string                              `json:"vmSkuName,omitempty"`
}

type KubernetesClusterNodeDetailedStatus ¶ 

type KubernetesClusterNodeDetailedStatus string
const (
	KubernetesClusterNodeDetailedStatusAvailable    KubernetesClusterNodeDetailedStatus = "Available"
	KubernetesClusterNodeDetailedStatusError        KubernetesClusterNodeDetailedStatus = "Error"
	KubernetesClusterNodeDetailedStatusProvisioning KubernetesClusterNodeDetailedStatus = "Provisioning"
	KubernetesClusterNodeDetailedStatusRunning      KubernetesClusterNodeDetailedStatus = "Running"
	KubernetesClusterNodeDetailedStatusScheduling   KubernetesClusterNodeDetailedStatus = "Scheduling"
	KubernetesClusterNodeDetailedStatusStopped      KubernetesClusterNodeDetailedStatus = "Stopped"
	KubernetesClusterNodeDetailedStatusTerminating  KubernetesClusterNodeDetailedStatus = "Terminating"
	KubernetesClusterNodeDetailedStatusUnknown      KubernetesClusterNodeDetailedStatus = "Unknown"
)

func (*KubernetesClusterNodeDetailedStatus) UnmarshalJSON ¶ 

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

type KubernetesClusterOperationPredicate ¶ 

type KubernetesClusterOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (KubernetesClusterOperationPredicate) Matches ¶ 

func (p KubernetesClusterOperationPredicate) Matches(input KubernetesCluster) bool

type KubernetesClusterPatchParameters ¶ 

type KubernetesClusterPatchParameters struct {
	Properties *KubernetesClusterPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string                `json:"tags,omitempty"`
}

type KubernetesClusterPatchProperties ¶ 

type KubernetesClusterPatchProperties struct {
	ControlPlaneNodeConfiguration *ControlPlaneNodePatchConfiguration `json:"controlPlaneNodeConfiguration,omitempty"`
	KubernetesVersion             *string                             `json:"kubernetesVersion,omitempty"`
}

type KubernetesClusterProperties ¶ 

type KubernetesClusterProperties struct {
	AadConfiguration                  *AadConfiguration                   `json:"aadConfiguration,omitempty"`
	AdministratorConfiguration        *AdministratorConfiguration         `json:"administratorConfiguration,omitempty"`
	AttachedNetworkIds                *[]string                           `json:"attachedNetworkIds,omitempty"`
	AvailableUpgrades                 *[]AvailableUpgrade                 `json:"availableUpgrades,omitempty"`
	ClusterId                         *string                             `json:"clusterId,omitempty"`
	ConnectedClusterId                *string                             `json:"connectedClusterId,omitempty"`
	ControlPlaneKubernetesVersion     *string                             `json:"controlPlaneKubernetesVersion,omitempty"`
	ControlPlaneNodeConfiguration     ControlPlaneNodeConfiguration       `json:"controlPlaneNodeConfiguration"`
	DetailedStatus                    *KubernetesClusterDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage             *string                             `json:"detailedStatusMessage,omitempty"`
	FeatureStatuses                   *[]FeatureStatus                    `json:"featureStatuses,omitempty"`
	InitialAgentPoolConfigurations    []InitialAgentPoolConfiguration     `json:"initialAgentPoolConfigurations"`
	KubernetesVersion                 string                              `json:"kubernetesVersion"`
	ManagedResourceGroupConfiguration *ManagedResourceGroupConfiguration  `json:"managedResourceGroupConfiguration,omitempty"`
	NetworkConfiguration              NetworkConfiguration                `json:"networkConfiguration"`
	Nodes                             *[]KubernetesClusterNode            `json:"nodes,omitempty"`
	ProvisioningState                 *KubernetesClusterProvisioningState `json:"provisioningState,omitempty"`
}

type KubernetesClusterProvisioningState ¶ 

type KubernetesClusterProvisioningState string
const (
	KubernetesClusterProvisioningStateAccepted   KubernetesClusterProvisioningState = "Accepted"
	KubernetesClusterProvisioningStateCanceled   KubernetesClusterProvisioningState = "Canceled"
	KubernetesClusterProvisioningStateCreated    KubernetesClusterProvisioningState = "Created"
	KubernetesClusterProvisioningStateDeleting   KubernetesClusterProvisioningState = "Deleting"
	KubernetesClusterProvisioningStateFailed     KubernetesClusterProvisioningState = "Failed"
	KubernetesClusterProvisioningStateInProgress KubernetesClusterProvisioningState = "InProgress"
	KubernetesClusterProvisioningStateSucceeded  KubernetesClusterProvisioningState = "Succeeded"
	KubernetesClusterProvisioningStateUpdating   KubernetesClusterProvisioningState = "Updating"
)

func (*KubernetesClusterProvisioningState) UnmarshalJSON ¶ 

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

type KubernetesClusterRestartNodeParameters ¶ 

type KubernetesClusterRestartNodeParameters struct {
	NodeName string `json:"nodeName"`
}

type KubernetesClustersCreateOrUpdateOperationResponse ¶ 

type KubernetesClustersCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *KubernetesCluster
}

type KubernetesClustersDeleteOperationResponse ¶ 

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

type KubernetesClustersGetOperationResponse ¶ 

type KubernetesClustersGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *KubernetesCluster
}

type KubernetesClustersListByResourceGroupCompleteResult ¶ 

type KubernetesClustersListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []KubernetesCluster
}

type KubernetesClustersListByResourceGroupOperationResponse ¶ 

type KubernetesClustersListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]KubernetesCluster
}

type KubernetesClustersListBySubscriptionCompleteResult ¶ 

type KubernetesClustersListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []KubernetesCluster
}

type KubernetesClustersListBySubscriptionOperationResponse ¶ 

type KubernetesClustersListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]KubernetesCluster
}

type KubernetesClustersRestartNodeOperationResponse ¶ 

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

type KubernetesClustersUpdateOperationResponse ¶ 

type KubernetesClustersUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *KubernetesCluster
}

type KubernetesLabel ¶ 

type KubernetesLabel struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type KubernetesNodePowerState ¶ 

type KubernetesNodePowerState string
const (
	KubernetesNodePowerStateOff     KubernetesNodePowerState = "Off"
	KubernetesNodePowerStateOn      KubernetesNodePowerState = "On"
	KubernetesNodePowerStateUnknown KubernetesNodePowerState = "Unknown"
)

func (*KubernetesNodePowerState) UnmarshalJSON ¶ 

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

type KubernetesNodeRole ¶ 

type KubernetesNodeRole string
const (
	KubernetesNodeRoleControlPlane KubernetesNodeRole = "ControlPlane"
	KubernetesNodeRoleWorker       KubernetesNodeRole = "Worker"
)

func (*KubernetesNodeRole) UnmarshalJSON ¶ 

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

type KubernetesPluginType ¶ 

type KubernetesPluginType string
const (
	KubernetesPluginTypeDPDK     KubernetesPluginType = "DPDK"
	KubernetesPluginTypeIPVLAN   KubernetesPluginType = "IPVLAN"
	KubernetesPluginTypeMACVLAN  KubernetesPluginType = "MACVLAN"
	KubernetesPluginTypeOSDevice KubernetesPluginType = "OSDevice"
	KubernetesPluginTypeSRIOV    KubernetesPluginType = "SRIOV"
)

func (*KubernetesPluginType) UnmarshalJSON ¶ 

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

type L2Network ¶ 

type L2Network struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       L2NetworkProperties    `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type L2NetworkAttachmentConfiguration ¶ 

type L2NetworkAttachmentConfiguration struct {
	NetworkId  string                `json:"networkId"`
	PluginType *KubernetesPluginType `json:"pluginType,omitempty"`
}

type L2NetworkDetailedStatus ¶ 

type L2NetworkDetailedStatus string
const (
	L2NetworkDetailedStatusAvailable    L2NetworkDetailedStatus = "Available"
	L2NetworkDetailedStatusError        L2NetworkDetailedStatus = "Error"
	L2NetworkDetailedStatusProvisioning L2NetworkDetailedStatus = "Provisioning"
)

func (*L2NetworkDetailedStatus) UnmarshalJSON ¶ 

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

type L2NetworkId ¶ 

type L2NetworkId struct {
	SubscriptionId    string
	ResourceGroupName string
	L2NetworkName     string
}

L2NetworkId is a struct representing the Resource ID for a L 2 Network

func NewL2NetworkID ¶ 

func NewL2NetworkID(subscriptionId string, resourceGroupName string, l2NetworkName string) L2NetworkId

NewL2NetworkID returns a new L2NetworkId struct

func ParseL2NetworkID ¶ 

func ParseL2NetworkID(input string) (*L2NetworkId, error)

ParseL2NetworkID parses 'input' into a L2NetworkId

func ParseL2NetworkIDInsensitively ¶ 

func ParseL2NetworkIDInsensitively(input string) (*L2NetworkId, error)

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

func (*L2NetworkId) FromParseResult ¶ 

func (id *L2NetworkId) FromParseResult(input resourceids.ParseResult) error

func (L2NetworkId) ID ¶ 

func (id L2NetworkId) ID() string

ID returns the formatted L 2 Network ID

func (L2NetworkId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this L 2 Network ID

func (L2NetworkId) String ¶ 

func (id L2NetworkId) String() string

String returns a human-readable description of this L 2 Network ID

type L2NetworkOperationPredicate ¶ 

type L2NetworkOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (L2NetworkOperationPredicate) Matches ¶ 

func (p L2NetworkOperationPredicate) Matches(input L2Network) bool

type L2NetworkPatchParameters ¶ 

type L2NetworkPatchParameters struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

type L2NetworkProperties ¶ 

type L2NetworkProperties struct {
	AssociatedResourceIds          *[]string                   `json:"associatedResourceIds,omitempty"`
	ClusterId                      *string                     `json:"clusterId,omitempty"`
	DetailedStatus                 *L2NetworkDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage          *string                     `json:"detailedStatusMessage,omitempty"`
	HybridAksClustersAssociatedIds *[]string                   `json:"hybridAksClustersAssociatedIds,omitempty"`
	HybridAksPluginType            *HybridAksPluginType        `json:"hybridAksPluginType,omitempty"`
	InterfaceName                  *string                     `json:"interfaceName,omitempty"`
	L2IsolationDomainId            string                      `json:"l2IsolationDomainId"`
	ProvisioningState              *L2NetworkProvisioningState `json:"provisioningState,omitempty"`
	VirtualMachinesAssociatedIds   *[]string                   `json:"virtualMachinesAssociatedIds,omitempty"`
}

type L2NetworkProvisioningState ¶ 

type L2NetworkProvisioningState string
const (
	L2NetworkProvisioningStateAccepted     L2NetworkProvisioningState = "Accepted"
	L2NetworkProvisioningStateCanceled     L2NetworkProvisioningState = "Canceled"
	L2NetworkProvisioningStateFailed       L2NetworkProvisioningState = "Failed"
	L2NetworkProvisioningStateProvisioning L2NetworkProvisioningState = "Provisioning"
	L2NetworkProvisioningStateSucceeded    L2NetworkProvisioningState = "Succeeded"
)

func (*L2NetworkProvisioningState) UnmarshalJSON ¶ 

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

type L2NetworksCreateOrUpdateOperationResponse ¶ 

type L2NetworksCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *L2Network
}

type L2NetworksDeleteOperationResponse ¶ 

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

type L2NetworksGetOperationResponse ¶ 

type L2NetworksGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *L2Network
}

type L2NetworksListByResourceGroupCompleteResult ¶ 

type L2NetworksListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []L2Network
}

type L2NetworksListByResourceGroupOperationResponse ¶ 

type L2NetworksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]L2Network
}

type L2NetworksListBySubscriptionCompleteResult ¶ 

type L2NetworksListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []L2Network
}

type L2NetworksListBySubscriptionOperationResponse ¶ 

type L2NetworksListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]L2Network
}

type L2NetworksUpdateOperationResponse ¶ 

type L2NetworksUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *L2Network
}

type L3Network ¶ 

type L3Network struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       L3NetworkProperties    `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type L3NetworkAttachmentConfiguration ¶ 

type L3NetworkAttachmentConfiguration struct {
	IPamEnabled *L3NetworkConfigurationIPamEnabled `json:"ipamEnabled,omitempty"`
	NetworkId   string                             `json:"networkId"`
	PluginType  *KubernetesPluginType              `json:"pluginType,omitempty"`
}

type L3NetworkConfigurationIPamEnabled ¶ 

type L3NetworkConfigurationIPamEnabled string
const (
	L3NetworkConfigurationIPamEnabledFalse L3NetworkConfigurationIPamEnabled = "False"
	L3NetworkConfigurationIPamEnabledTrue  L3NetworkConfigurationIPamEnabled = "True"
)

func (*L3NetworkConfigurationIPamEnabled) UnmarshalJSON ¶ 

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

type L3NetworkDetailedStatus ¶ 

type L3NetworkDetailedStatus string
const (
	L3NetworkDetailedStatusAvailable    L3NetworkDetailedStatus = "Available"
	L3NetworkDetailedStatusError        L3NetworkDetailedStatus = "Error"
	L3NetworkDetailedStatusProvisioning L3NetworkDetailedStatus = "Provisioning"
)

func (*L3NetworkDetailedStatus) UnmarshalJSON ¶ 

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

type L3NetworkId ¶ 

type L3NetworkId struct {
	SubscriptionId    string
	ResourceGroupName string
	L3NetworkName     string
}

L3NetworkId is a struct representing the Resource ID for a L 3 Network

func NewL3NetworkID ¶ 

func NewL3NetworkID(subscriptionId string, resourceGroupName string, l3NetworkName string) L3NetworkId

NewL3NetworkID returns a new L3NetworkId struct

func ParseL3NetworkID ¶ 

func ParseL3NetworkID(input string) (*L3NetworkId, error)

ParseL3NetworkID parses 'input' into a L3NetworkId

func ParseL3NetworkIDInsensitively ¶ 

func ParseL3NetworkIDInsensitively(input string) (*L3NetworkId, error)

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

func (*L3NetworkId) FromParseResult ¶ 

func (id *L3NetworkId) FromParseResult(input resourceids.ParseResult) error

func (L3NetworkId) ID ¶ 

func (id L3NetworkId) ID() string

ID returns the formatted L 3 Network ID

func (L3NetworkId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this L 3 Network ID

func (L3NetworkId) String ¶ 

func (id L3NetworkId) String() string

String returns a human-readable description of this L 3 Network ID

type L3NetworkOperationPredicate ¶ 

type L3NetworkOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (L3NetworkOperationPredicate) Matches ¶ 

func (p L3NetworkOperationPredicate) Matches(input L3Network) bool

type L3NetworkPatchParameters ¶ 

type L3NetworkPatchParameters struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

type L3NetworkProperties ¶ 

type L3NetworkProperties struct {
	AssociatedResourceIds          *[]string                   `json:"associatedResourceIds,omitempty"`
	ClusterId                      *string                     `json:"clusterId,omitempty"`
	DetailedStatus                 *L3NetworkDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage          *string                     `json:"detailedStatusMessage,omitempty"`
	HybridAksClustersAssociatedIds *[]string                   `json:"hybridAksClustersAssociatedIds,omitempty"`
	HybridAksIPamEnabled           *HybridAksIPamEnabled       `json:"hybridAksIpamEnabled,omitempty"`
	HybridAksPluginType            *HybridAksPluginType        `json:"hybridAksPluginType,omitempty"`
	IPAllocationType               *IPAllocationType           `json:"ipAllocationType,omitempty"`
	IPv4ConnectedPrefix            *string                     `json:"ipv4ConnectedPrefix,omitempty"`
	IPv6ConnectedPrefix            *string                     `json:"ipv6ConnectedPrefix,omitempty"`
	InterfaceName                  *string                     `json:"interfaceName,omitempty"`
	L3IsolationDomainId            string                      `json:"l3IsolationDomainId"`
	ProvisioningState              *L3NetworkProvisioningState `json:"provisioningState,omitempty"`
	VirtualMachinesAssociatedIds   *[]string                   `json:"virtualMachinesAssociatedIds,omitempty"`
	Vlan                           int64                       `json:"vlan"`
}

type L3NetworkProvisioningState ¶ 

type L3NetworkProvisioningState string
const (
	L3NetworkProvisioningStateAccepted     L3NetworkProvisioningState = "Accepted"
	L3NetworkProvisioningStateCanceled     L3NetworkProvisioningState = "Canceled"
	L3NetworkProvisioningStateFailed       L3NetworkProvisioningState = "Failed"
	L3NetworkProvisioningStateProvisioning L3NetworkProvisioningState = "Provisioning"
	L3NetworkProvisioningStateSucceeded    L3NetworkProvisioningState = "Succeeded"
)

func (*L3NetworkProvisioningState) UnmarshalJSON ¶ 

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

type L3NetworksCreateOrUpdateOperationResponse ¶ 

type L3NetworksCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *L3Network
}

type L3NetworksDeleteOperationResponse ¶ 

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

type L3NetworksGetOperationResponse ¶ 

type L3NetworksGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *L3Network
}

type L3NetworksListByResourceGroupCompleteResult ¶ 

type L3NetworksListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []L3Network
}

type L3NetworksListByResourceGroupOperationResponse ¶ 

type L3NetworksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]L3Network
}

type L3NetworksListBySubscriptionCompleteResult ¶ 

type L3NetworksListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []L3Network
}

type L3NetworksListBySubscriptionOperationResponse ¶ 

type L3NetworksListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]L3Network
}

type L3NetworksUpdateOperationResponse ¶ 

type L3NetworksUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *L3Network
}

type LldpNeighbor ¶ 

type LldpNeighbor struct {
	PortDescription   *string `json:"portDescription,omitempty"`
	PortName          *string `json:"portName,omitempty"`
	SystemDescription *string `json:"systemDescription,omitempty"`
	SystemName        *string `json:"systemName,omitempty"`
}

type MachineDisk ¶ 

type MachineDisk struct {
	CapacityGB *int64                        `json:"capacityGB,omitempty"`
	Connection *MachineSkuDiskConnectionType `json:"connection,omitempty"`
	Type       *DiskType                     `json:"type,omitempty"`
}

type MachineSkuDiskConnectionType ¶ 

type MachineSkuDiskConnectionType string
const (
	MachineSkuDiskConnectionTypePCIE MachineSkuDiskConnectionType = "PCIE"
	MachineSkuDiskConnectionTypeRAID MachineSkuDiskConnectionType = "RAID"
	MachineSkuDiskConnectionTypeSAS  MachineSkuDiskConnectionType = "SAS"
	MachineSkuDiskConnectionTypeSATA MachineSkuDiskConnectionType = "SATA"
)

func (*MachineSkuDiskConnectionType) UnmarshalJSON ¶ 

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

type MachineSkuProperties ¶ 

type MachineSkuProperties struct {
	BootstrapProtocol *BootstrapProtocol  `json:"bootstrapProtocol,omitempty"`
	CpuCores          *int64              `json:"cpuCores,omitempty"`
	CpuSockets        *int64              `json:"cpuSockets,omitempty"`
	Disks             *[]MachineDisk      `json:"disks,omitempty"`
	Generation        *string             `json:"generation,omitempty"`
	HardwareVersion   *string             `json:"hardwareVersion,omitempty"`
	MemoryCapacityGB  *int64              `json:"memoryCapacityGB,omitempty"`
	Model             *string             `json:"model,omitempty"`
	NetworkInterfaces *[]NetworkInterface `json:"networkInterfaces,omitempty"`
	TotalThreads      *int64              `json:"totalThreads,omitempty"`
	Vendor            *string             `json:"vendor,omitempty"`
}

type MachineSkuSlot ¶ 

type MachineSkuSlot struct {
	Properties *MachineSkuProperties `json:"properties,omitempty"`
	RackSlot   *int64                `json:"rackSlot,omitempty"`
}

type ManagedResourceGroupConfiguration ¶ 

type ManagedResourceGroupConfiguration struct {
	Location *string `json:"location,omitempty"`
	Name     *string `json:"name,omitempty"`
}

type MetricsConfigurationId ¶ 

type MetricsConfigurationId struct {
	SubscriptionId           string
	ResourceGroupName        string
	ClusterName              string
	MetricsConfigurationName string
}

MetricsConfigurationId is a struct representing the Resource ID for a Metrics Configuration

func NewMetricsConfigurationID ¶ 

func NewMetricsConfigurationID(subscriptionId string, resourceGroupName string, clusterName string, metricsConfigurationName string) MetricsConfigurationId

NewMetricsConfigurationID returns a new MetricsConfigurationId struct

func ParseMetricsConfigurationID ¶ 

func ParseMetricsConfigurationID(input string) (*MetricsConfigurationId, error)

ParseMetricsConfigurationID parses 'input' into a MetricsConfigurationId

func ParseMetricsConfigurationIDInsensitively ¶ 

func ParseMetricsConfigurationIDInsensitively(input string) (*MetricsConfigurationId, error)

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

func (*MetricsConfigurationId) FromParseResult ¶ 

func (id *MetricsConfigurationId) FromParseResult(input resourceids.ParseResult) error

func (MetricsConfigurationId) ID ¶ 

func (id MetricsConfigurationId) ID() string

ID returns the formatted Metrics Configuration ID

func (MetricsConfigurationId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Metrics Configuration ID

func (MetricsConfigurationId) String ¶ 

func (id MetricsConfigurationId) String() string

String returns a human-readable description of this Metrics Configuration ID

type MetricsConfigurationsCreateOrUpdateOperationResponse ¶ 

type MetricsConfigurationsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *ClusterMetricsConfiguration
}

type MetricsConfigurationsDeleteOperationResponse ¶ 

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

type MetricsConfigurationsGetOperationResponse ¶ 

type MetricsConfigurationsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *ClusterMetricsConfiguration
}

type MetricsConfigurationsListByClusterCompleteResult ¶ 

type MetricsConfigurationsListByClusterCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []ClusterMetricsConfiguration
}

type MetricsConfigurationsListByClusterOperationResponse ¶ 

type MetricsConfigurationsListByClusterOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]ClusterMetricsConfiguration
}

type MetricsConfigurationsUpdateOperationResponse ¶ 

type MetricsConfigurationsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *ClusterMetricsConfiguration
}

type NetworkAttachment ¶ 

type NetworkAttachment struct {
	AttachedNetworkId     string                           `json:"attachedNetworkId"`
	DefaultGateway        *DefaultGateway                  `json:"defaultGateway,omitempty"`
	IPAllocationMethod    VirtualMachineIPAllocationMethod `json:"ipAllocationMethod"`
	IPv4Address           *string                          `json:"ipv4Address,omitempty"`
	IPv6Address           *string                          `json:"ipv6Address,omitempty"`
	MacAddress            *string                          `json:"macAddress,omitempty"`
	NetworkAttachmentName *string                          `json:"networkAttachmentName,omitempty"`
}

type NetworkConfiguration ¶ 

type NetworkConfiguration struct {
	AttachedNetworkConfiguration        *AttachedNetworkConfiguration        `json:"attachedNetworkConfiguration,omitempty"`
	BgpServiceLoadBalancerConfiguration *BgpServiceLoadBalancerConfiguration `json:"bgpServiceLoadBalancerConfiguration,omitempty"`
	CloudServicesNetworkId              string                               `json:"cloudServicesNetworkId"`
	CniNetworkId                        string                               `json:"cniNetworkId"`
	DnsServiceIP                        *string                              `json:"dnsServiceIp,omitempty"`
	PodCidrs                            *[]string                            `json:"podCidrs,omitempty"`
	ServiceCidrs                        *[]string                            `json:"serviceCidrs,omitempty"`
}

type NetworkInterface ¶ 

type NetworkInterface struct {
	Address              *string               `json:"address,omitempty"`
	DeviceConnectionType *DeviceConnectionType `json:"deviceConnectionType,omitempty"`
	Model                *string               `json:"model,omitempty"`
	PhysicalSlot         *int64                `json:"physicalSlot,omitempty"`
	PortCount            *int64                `json:"portCount,omitempty"`
	PortSpeed            *int64                `json:"portSpeed,omitempty"`
	Vendor               *string               `json:"vendor,omitempty"`
}

type NetworkcloudsClient ¶ 

type NetworkcloudsClient struct {
	Client *resourcemanager.Client
}

func NewNetworkcloudsClientWithBaseURI ¶ 

func NewNetworkcloudsClientWithBaseURI(sdkApi sdkEnv.Api) (*NetworkcloudsClient, error)

func (NetworkcloudsClient) AgentPoolsCreateOrUpdate ¶ 

func (c NetworkcloudsClient) AgentPoolsCreateOrUpdate(ctx context.Context, id AgentPoolId, input AgentPool) (result AgentPoolsCreateOrUpdateOperationResponse, err error)

AgentPoolsCreateOrUpdate ...

func (NetworkcloudsClient) AgentPoolsCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) AgentPoolsCreateOrUpdateThenPoll(ctx context.Context, id AgentPoolId, input AgentPool) error

AgentPoolsCreateOrUpdateThenPoll performs AgentPoolsCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) AgentPoolsDelete ¶ 

func (c NetworkcloudsClient) AgentPoolsDelete(ctx context.Context, id AgentPoolId) (result AgentPoolsDeleteOperationResponse, err error)

AgentPoolsDelete ...

func (NetworkcloudsClient) AgentPoolsDeleteThenPoll ¶ 

func (c NetworkcloudsClient) AgentPoolsDeleteThenPoll(ctx context.Context, id AgentPoolId) error

AgentPoolsDeleteThenPoll performs AgentPoolsDelete then polls until it's completed

func (NetworkcloudsClient) AgentPoolsGet ¶ 

func (c NetworkcloudsClient) AgentPoolsGet(ctx context.Context, id AgentPoolId) (result AgentPoolsGetOperationResponse, err error)

AgentPoolsGet ...

func (NetworkcloudsClient) AgentPoolsListByKubernetesCluster ¶ 

func (c NetworkcloudsClient) AgentPoolsListByKubernetesCluster(ctx context.Context, id KubernetesClusterId) (result AgentPoolsListByKubernetesClusterOperationResponse, err error)

AgentPoolsListByKubernetesCluster ...

func (NetworkcloudsClient) AgentPoolsListByKubernetesClusterComplete ¶ 

func (c NetworkcloudsClient) AgentPoolsListByKubernetesClusterComplete(ctx context.Context, id KubernetesClusterId) (AgentPoolsListByKubernetesClusterCompleteResult, error)

AgentPoolsListByKubernetesClusterComplete retrieves all the results into a single object

func (NetworkcloudsClient) AgentPoolsListByKubernetesClusterCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) AgentPoolsListByKubernetesClusterCompleteMatchingPredicate(ctx context.Context, id KubernetesClusterId, predicate AgentPoolOperationPredicate) (result AgentPoolsListByKubernetesClusterCompleteResult, err error)

AgentPoolsListByKubernetesClusterCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) AgentPoolsUpdate ¶ 

func (c NetworkcloudsClient) AgentPoolsUpdate(ctx context.Context, id AgentPoolId, input AgentPoolPatchParameters) (result AgentPoolsUpdateOperationResponse, err error)

AgentPoolsUpdate ...

func (NetworkcloudsClient) AgentPoolsUpdateThenPoll ¶ 

func (c NetworkcloudsClient) AgentPoolsUpdateThenPoll(ctx context.Context, id AgentPoolId, input AgentPoolPatchParameters) error

AgentPoolsUpdateThenPoll performs AgentPoolsUpdate then polls until it's completed

func (NetworkcloudsClient) BareMetalMachineKeySetsCreateOrUpdate ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsCreateOrUpdate(ctx context.Context, id BareMetalMachineKeySetId, input BareMetalMachineKeySet) (result BareMetalMachineKeySetsCreateOrUpdateOperationResponse, err error)

BareMetalMachineKeySetsCreateOrUpdate ...

func (NetworkcloudsClient) BareMetalMachineKeySetsCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsCreateOrUpdateThenPoll(ctx context.Context, id BareMetalMachineKeySetId, input BareMetalMachineKeySet) error

BareMetalMachineKeySetsCreateOrUpdateThenPoll performs BareMetalMachineKeySetsCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) BareMetalMachineKeySetsDelete ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsDelete(ctx context.Context, id BareMetalMachineKeySetId) (result BareMetalMachineKeySetsDeleteOperationResponse, err error)

BareMetalMachineKeySetsDelete ...

func (NetworkcloudsClient) BareMetalMachineKeySetsDeleteThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsDeleteThenPoll(ctx context.Context, id BareMetalMachineKeySetId) error

BareMetalMachineKeySetsDeleteThenPoll performs BareMetalMachineKeySetsDelete then polls until it's completed

func (NetworkcloudsClient) BareMetalMachineKeySetsGet ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsGet(ctx context.Context, id BareMetalMachineKeySetId) (result BareMetalMachineKeySetsGetOperationResponse, err error)

BareMetalMachineKeySetsGet ...

func (NetworkcloudsClient) BareMetalMachineKeySetsListByCluster ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsListByCluster(ctx context.Context, id ClusterId) (result BareMetalMachineKeySetsListByClusterOperationResponse, err error)

BareMetalMachineKeySetsListByCluster ...

func (NetworkcloudsClient) BareMetalMachineKeySetsListByClusterComplete ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsListByClusterComplete(ctx context.Context, id ClusterId) (BareMetalMachineKeySetsListByClusterCompleteResult, error)

BareMetalMachineKeySetsListByClusterComplete retrieves all the results into a single object

func (NetworkcloudsClient) BareMetalMachineKeySetsListByClusterCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsListByClusterCompleteMatchingPredicate(ctx context.Context, id ClusterId, predicate BareMetalMachineKeySetOperationPredicate) (result BareMetalMachineKeySetsListByClusterCompleteResult, err error)

BareMetalMachineKeySetsListByClusterCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) BareMetalMachineKeySetsUpdate ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsUpdate(ctx context.Context, id BareMetalMachineKeySetId, input BareMetalMachineKeySetPatchParameters) (result BareMetalMachineKeySetsUpdateOperationResponse, err error)

BareMetalMachineKeySetsUpdate ...

func (NetworkcloudsClient) BareMetalMachineKeySetsUpdateThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachineKeySetsUpdateThenPoll(ctx context.Context, id BareMetalMachineKeySetId, input BareMetalMachineKeySetPatchParameters) error

BareMetalMachineKeySetsUpdateThenPoll performs BareMetalMachineKeySetsUpdate then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesCordon ¶ 

func (c NetworkcloudsClient) BareMetalMachinesCordon(ctx context.Context, id BareMetalMachineId, input BareMetalMachineCordonParameters) (result BareMetalMachinesCordonOperationResponse, err error)

BareMetalMachinesCordon ...

func (NetworkcloudsClient) BareMetalMachinesCordonThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesCordonThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachineCordonParameters) error

BareMetalMachinesCordonThenPoll performs BareMetalMachinesCordon then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesCreateOrUpdate ¶ 

func (c NetworkcloudsClient) BareMetalMachinesCreateOrUpdate(ctx context.Context, id BareMetalMachineId, input BareMetalMachine) (result BareMetalMachinesCreateOrUpdateOperationResponse, err error)

BareMetalMachinesCreateOrUpdate ...

func (NetworkcloudsClient) BareMetalMachinesCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesCreateOrUpdateThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachine) error

BareMetalMachinesCreateOrUpdateThenPoll performs BareMetalMachinesCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesDelete ¶ 

func (c NetworkcloudsClient) BareMetalMachinesDelete(ctx context.Context, id BareMetalMachineId) (result BareMetalMachinesDeleteOperationResponse, err error)

BareMetalMachinesDelete ...

func (NetworkcloudsClient) BareMetalMachinesDeleteThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesDeleteThenPoll(ctx context.Context, id BareMetalMachineId) error

BareMetalMachinesDeleteThenPoll performs BareMetalMachinesDelete then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesGet ¶ 

func (c NetworkcloudsClient) BareMetalMachinesGet(ctx context.Context, id BareMetalMachineId) (result BareMetalMachinesGetOperationResponse, err error)

BareMetalMachinesGet ...

func (NetworkcloudsClient) BareMetalMachinesListByResourceGroup ¶ 

func (c NetworkcloudsClient) BareMetalMachinesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result BareMetalMachinesListByResourceGroupOperationResponse, err error)

BareMetalMachinesListByResourceGroup ...

func (NetworkcloudsClient) BareMetalMachinesListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) BareMetalMachinesListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (BareMetalMachinesListByResourceGroupCompleteResult, error)

BareMetalMachinesListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) BareMetalMachinesListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) BareMetalMachinesListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate BareMetalMachineOperationPredicate) (result BareMetalMachinesListByResourceGroupCompleteResult, err error)

BareMetalMachinesListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) BareMetalMachinesListBySubscription ¶ 

func (c NetworkcloudsClient) BareMetalMachinesListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result BareMetalMachinesListBySubscriptionOperationResponse, err error)

BareMetalMachinesListBySubscription ...

func (NetworkcloudsClient) BareMetalMachinesListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) BareMetalMachinesListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (BareMetalMachinesListBySubscriptionCompleteResult, error)

BareMetalMachinesListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) BareMetalMachinesListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) BareMetalMachinesListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate BareMetalMachineOperationPredicate) (result BareMetalMachinesListBySubscriptionCompleteResult, err error)

BareMetalMachinesListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) BareMetalMachinesPowerOff ¶ 

func (c NetworkcloudsClient) BareMetalMachinesPowerOff(ctx context.Context, id BareMetalMachineId, input BareMetalMachinePowerOffParameters) (result BareMetalMachinesPowerOffOperationResponse, err error)

BareMetalMachinesPowerOff ...

func (NetworkcloudsClient) BareMetalMachinesPowerOffThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesPowerOffThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachinePowerOffParameters) error

BareMetalMachinesPowerOffThenPoll performs BareMetalMachinesPowerOff then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesReimage ¶ 

func (c NetworkcloudsClient) BareMetalMachinesReimage(ctx context.Context, id BareMetalMachineId) (result BareMetalMachinesReimageOperationResponse, err error)

BareMetalMachinesReimage ...

func (NetworkcloudsClient) BareMetalMachinesReimageThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesReimageThenPoll(ctx context.Context, id BareMetalMachineId) error

BareMetalMachinesReimageThenPoll performs BareMetalMachinesReimage then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesReplace ¶ 

func (c NetworkcloudsClient) BareMetalMachinesReplace(ctx context.Context, id BareMetalMachineId, input BareMetalMachineReplaceParameters) (result BareMetalMachinesReplaceOperationResponse, err error)

BareMetalMachinesReplace ...

func (NetworkcloudsClient) BareMetalMachinesReplaceThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesReplaceThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachineReplaceParameters) error

BareMetalMachinesReplaceThenPoll performs BareMetalMachinesReplace then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesRestart ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRestart(ctx context.Context, id BareMetalMachineId) (result BareMetalMachinesRestartOperationResponse, err error)

BareMetalMachinesRestart ...

func (NetworkcloudsClient) BareMetalMachinesRestartThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRestartThenPoll(ctx context.Context, id BareMetalMachineId) error

BareMetalMachinesRestartThenPoll performs BareMetalMachinesRestart then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesRunCommand ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRunCommand(ctx context.Context, id BareMetalMachineId, input BareMetalMachineRunCommandParameters) (result BareMetalMachinesRunCommandOperationResponse, err error)

BareMetalMachinesRunCommand ...

func (NetworkcloudsClient) BareMetalMachinesRunCommandThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRunCommandThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachineRunCommandParameters) error

BareMetalMachinesRunCommandThenPoll performs BareMetalMachinesRunCommand then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesRunDataExtracts ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRunDataExtracts(ctx context.Context, id BareMetalMachineId, input BareMetalMachineRunDataExtractsParameters) (result BareMetalMachinesRunDataExtractsOperationResponse, err error)

BareMetalMachinesRunDataExtracts ...

func (NetworkcloudsClient) BareMetalMachinesRunDataExtractsThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRunDataExtractsThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachineRunDataExtractsParameters) error

BareMetalMachinesRunDataExtractsThenPoll performs BareMetalMachinesRunDataExtracts then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesRunReadCommands ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRunReadCommands(ctx context.Context, id BareMetalMachineId, input BareMetalMachineRunReadCommandsParameters) (result BareMetalMachinesRunReadCommandsOperationResponse, err error)

BareMetalMachinesRunReadCommands ...

func (NetworkcloudsClient) BareMetalMachinesRunReadCommandsThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesRunReadCommandsThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachineRunReadCommandsParameters) error

BareMetalMachinesRunReadCommandsThenPoll performs BareMetalMachinesRunReadCommands then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesStart ¶ 

func (c NetworkcloudsClient) BareMetalMachinesStart(ctx context.Context, id BareMetalMachineId) (result BareMetalMachinesStartOperationResponse, err error)

BareMetalMachinesStart ...

func (NetworkcloudsClient) BareMetalMachinesStartThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesStartThenPoll(ctx context.Context, id BareMetalMachineId) error

BareMetalMachinesStartThenPoll performs BareMetalMachinesStart then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesUncordon ¶ 

func (c NetworkcloudsClient) BareMetalMachinesUncordon(ctx context.Context, id BareMetalMachineId) (result BareMetalMachinesUncordonOperationResponse, err error)

BareMetalMachinesUncordon ...

func (NetworkcloudsClient) BareMetalMachinesUncordonThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesUncordonThenPoll(ctx context.Context, id BareMetalMachineId) error

BareMetalMachinesUncordonThenPoll performs BareMetalMachinesUncordon then polls until it's completed

func (NetworkcloudsClient) BareMetalMachinesUpdate ¶ 

func (c NetworkcloudsClient) BareMetalMachinesUpdate(ctx context.Context, id BareMetalMachineId, input BareMetalMachinePatchParameters) (result BareMetalMachinesUpdateOperationResponse, err error)

BareMetalMachinesUpdate ...

func (NetworkcloudsClient) BareMetalMachinesUpdateThenPoll ¶ 

func (c NetworkcloudsClient) BareMetalMachinesUpdateThenPoll(ctx context.Context, id BareMetalMachineId, input BareMetalMachinePatchParameters) error

BareMetalMachinesUpdateThenPoll performs BareMetalMachinesUpdate then polls until it's completed

func (NetworkcloudsClient) BmcKeySetsCreateOrUpdate ¶ 

func (c NetworkcloudsClient) BmcKeySetsCreateOrUpdate(ctx context.Context, id BmcKeySetId, input BmcKeySet) (result BmcKeySetsCreateOrUpdateOperationResponse, err error)

BmcKeySetsCreateOrUpdate ...

func (NetworkcloudsClient) BmcKeySetsCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) BmcKeySetsCreateOrUpdateThenPoll(ctx context.Context, id BmcKeySetId, input BmcKeySet) error

BmcKeySetsCreateOrUpdateThenPoll performs BmcKeySetsCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) BmcKeySetsDelete ¶ 

func (c NetworkcloudsClient) BmcKeySetsDelete(ctx context.Context, id BmcKeySetId) (result BmcKeySetsDeleteOperationResponse, err error)

BmcKeySetsDelete ...

func (NetworkcloudsClient) BmcKeySetsDeleteThenPoll ¶ 

func (c NetworkcloudsClient) BmcKeySetsDeleteThenPoll(ctx context.Context, id BmcKeySetId) error

BmcKeySetsDeleteThenPoll performs BmcKeySetsDelete then polls until it's completed

func (NetworkcloudsClient) BmcKeySetsGet ¶ 

func (c NetworkcloudsClient) BmcKeySetsGet(ctx context.Context, id BmcKeySetId) (result BmcKeySetsGetOperationResponse, err error)

BmcKeySetsGet ...

func (NetworkcloudsClient) BmcKeySetsListByCluster ¶ 

func (c NetworkcloudsClient) BmcKeySetsListByCluster(ctx context.Context, id ClusterId) (result BmcKeySetsListByClusterOperationResponse, err error)

BmcKeySetsListByCluster ...

func (NetworkcloudsClient) BmcKeySetsListByClusterComplete ¶ 

func (c NetworkcloudsClient) BmcKeySetsListByClusterComplete(ctx context.Context, id ClusterId) (BmcKeySetsListByClusterCompleteResult, error)

BmcKeySetsListByClusterComplete retrieves all the results into a single object

func (NetworkcloudsClient) BmcKeySetsListByClusterCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) BmcKeySetsListByClusterCompleteMatchingPredicate(ctx context.Context, id ClusterId, predicate BmcKeySetOperationPredicate) (result BmcKeySetsListByClusterCompleteResult, err error)

BmcKeySetsListByClusterCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) BmcKeySetsUpdate ¶ 

func (c NetworkcloudsClient) BmcKeySetsUpdate(ctx context.Context, id BmcKeySetId, input BmcKeySetPatchParameters) (result BmcKeySetsUpdateOperationResponse, err error)

BmcKeySetsUpdate ...

func (NetworkcloudsClient) BmcKeySetsUpdateThenPoll ¶ 

func (c NetworkcloudsClient) BmcKeySetsUpdateThenPoll(ctx context.Context, id BmcKeySetId, input BmcKeySetPatchParameters) error

BmcKeySetsUpdateThenPoll performs BmcKeySetsUpdate then polls until it's completed

func (NetworkcloudsClient) CloudServicesNetworksCreateOrUpdate ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksCreateOrUpdate(ctx context.Context, id CloudServicesNetworkId, input CloudServicesNetwork) (result CloudServicesNetworksCreateOrUpdateOperationResponse, err error)

CloudServicesNetworksCreateOrUpdate ...

func (NetworkcloudsClient) CloudServicesNetworksCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksCreateOrUpdateThenPoll(ctx context.Context, id CloudServicesNetworkId, input CloudServicesNetwork) error

CloudServicesNetworksCreateOrUpdateThenPoll performs CloudServicesNetworksCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) CloudServicesNetworksDelete ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksDelete(ctx context.Context, id CloudServicesNetworkId) (result CloudServicesNetworksDeleteOperationResponse, err error)

CloudServicesNetworksDelete ...

func (NetworkcloudsClient) CloudServicesNetworksDeleteThenPoll ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksDeleteThenPoll(ctx context.Context, id CloudServicesNetworkId) error

CloudServicesNetworksDeleteThenPoll performs CloudServicesNetworksDelete then polls until it's completed

func (NetworkcloudsClient) CloudServicesNetworksGet ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksGet(ctx context.Context, id CloudServicesNetworkId) (result CloudServicesNetworksGetOperationResponse, err error)

CloudServicesNetworksGet ...

func (NetworkcloudsClient) CloudServicesNetworksListByResourceGroup ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result CloudServicesNetworksListByResourceGroupOperationResponse, err error)

CloudServicesNetworksListByResourceGroup ...

func (NetworkcloudsClient) CloudServicesNetworksListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (CloudServicesNetworksListByResourceGroupCompleteResult, error)

CloudServicesNetworksListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) CloudServicesNetworksListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate CloudServicesNetworkOperationPredicate) (result CloudServicesNetworksListByResourceGroupCompleteResult, err error)

CloudServicesNetworksListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) CloudServicesNetworksListBySubscription ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result CloudServicesNetworksListBySubscriptionOperationResponse, err error)

CloudServicesNetworksListBySubscription ...

func (NetworkcloudsClient) CloudServicesNetworksListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (CloudServicesNetworksListBySubscriptionCompleteResult, error)

CloudServicesNetworksListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) CloudServicesNetworksListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate CloudServicesNetworkOperationPredicate) (result CloudServicesNetworksListBySubscriptionCompleteResult, err error)

CloudServicesNetworksListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) CloudServicesNetworksUpdate ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksUpdate(ctx context.Context, id CloudServicesNetworkId, input CloudServicesNetworkPatchParameters) (result CloudServicesNetworksUpdateOperationResponse, err error)

CloudServicesNetworksUpdate ...

func (NetworkcloudsClient) CloudServicesNetworksUpdateThenPoll ¶ 

func (c NetworkcloudsClient) CloudServicesNetworksUpdateThenPoll(ctx context.Context, id CloudServicesNetworkId, input CloudServicesNetworkPatchParameters) error

CloudServicesNetworksUpdateThenPoll performs CloudServicesNetworksUpdate then polls until it's completed

func (NetworkcloudsClient) ClusterManagersCreateOrUpdate ¶ 

func (c NetworkcloudsClient) ClusterManagersCreateOrUpdate(ctx context.Context, id ClusterManagerId, input ClusterManager) (result ClusterManagersCreateOrUpdateOperationResponse, err error)

ClusterManagersCreateOrUpdate ...

func (NetworkcloudsClient) ClusterManagersCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) ClusterManagersCreateOrUpdateThenPoll(ctx context.Context, id ClusterManagerId, input ClusterManager) error

ClusterManagersCreateOrUpdateThenPoll performs ClusterManagersCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) ClusterManagersDelete ¶ 

func (c NetworkcloudsClient) ClusterManagersDelete(ctx context.Context, id ClusterManagerId) (result ClusterManagersDeleteOperationResponse, err error)

ClusterManagersDelete ...

func (NetworkcloudsClient) ClusterManagersDeleteThenPoll ¶ 

func (c NetworkcloudsClient) ClusterManagersDeleteThenPoll(ctx context.Context, id ClusterManagerId) error

ClusterManagersDeleteThenPoll performs ClusterManagersDelete then polls until it's completed

func (NetworkcloudsClient) ClusterManagersGet ¶ 

func (c NetworkcloudsClient) ClusterManagersGet(ctx context.Context, id ClusterManagerId) (result ClusterManagersGetOperationResponse, err error)

ClusterManagersGet ...

func (NetworkcloudsClient) ClusterManagersListByResourceGroup ¶ 

func (c NetworkcloudsClient) ClusterManagersListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result ClusterManagersListByResourceGroupOperationResponse, err error)

ClusterManagersListByResourceGroup ...

func (NetworkcloudsClient) ClusterManagersListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) ClusterManagersListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (ClusterManagersListByResourceGroupCompleteResult, error)

ClusterManagersListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) ClusterManagersListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) ClusterManagersListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate ClusterManagerOperationPredicate) (result ClusterManagersListByResourceGroupCompleteResult, err error)

ClusterManagersListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) ClusterManagersListBySubscription ¶ 

func (c NetworkcloudsClient) ClusterManagersListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result ClusterManagersListBySubscriptionOperationResponse, err error)

ClusterManagersListBySubscription ...

func (NetworkcloudsClient) ClusterManagersListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) ClusterManagersListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (ClusterManagersListBySubscriptionCompleteResult, error)

ClusterManagersListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) ClusterManagersListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) ClusterManagersListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate ClusterManagerOperationPredicate) (result ClusterManagersListBySubscriptionCompleteResult, err error)

ClusterManagersListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) ClusterManagersUpdate ¶ 

func (c NetworkcloudsClient) ClusterManagersUpdate(ctx context.Context, id ClusterManagerId, input ClusterManagerPatchParameters) (result ClusterManagersUpdateOperationResponse, err error)

ClusterManagersUpdate ...

func (NetworkcloudsClient) ClustersCreateOrUpdate ¶ 

func (c NetworkcloudsClient) ClustersCreateOrUpdate(ctx context.Context, id ClusterId, input Cluster) (result ClustersCreateOrUpdateOperationResponse, err error)

ClustersCreateOrUpdate ...

func (NetworkcloudsClient) ClustersCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) ClustersCreateOrUpdateThenPoll(ctx context.Context, id ClusterId, input Cluster) error

ClustersCreateOrUpdateThenPoll performs ClustersCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) ClustersDelete ¶ 

func (c NetworkcloudsClient) ClustersDelete(ctx context.Context, id ClusterId) (result ClustersDeleteOperationResponse, err error)

ClustersDelete ...

func (NetworkcloudsClient) ClustersDeleteThenPoll ¶ 

func (c NetworkcloudsClient) ClustersDeleteThenPoll(ctx context.Context, id ClusterId) error

ClustersDeleteThenPoll performs ClustersDelete then polls until it's completed

func (NetworkcloudsClient) ClustersDeploy ¶ 

func (c NetworkcloudsClient) ClustersDeploy(ctx context.Context, id ClusterId, input ClusterDeployParameters) (result ClustersDeployOperationResponse, err error)

ClustersDeploy ...

func (NetworkcloudsClient) ClustersDeployThenPoll ¶ 

func (c NetworkcloudsClient) ClustersDeployThenPoll(ctx context.Context, id ClusterId, input ClusterDeployParameters) error

ClustersDeployThenPoll performs ClustersDeploy then polls until it's completed

func (NetworkcloudsClient) ClustersGet ¶ 

func (c NetworkcloudsClient) ClustersGet(ctx context.Context, id ClusterId) (result ClustersGetOperationResponse, err error)

ClustersGet ...

func (NetworkcloudsClient) ClustersListByResourceGroup ¶ 

func (c NetworkcloudsClient) ClustersListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result ClustersListByResourceGroupOperationResponse, err error)

ClustersListByResourceGroup ...

func (NetworkcloudsClient) ClustersListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) ClustersListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (ClustersListByResourceGroupCompleteResult, error)

ClustersListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) ClustersListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) ClustersListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate ClusterOperationPredicate) (result ClustersListByResourceGroupCompleteResult, err error)

ClustersListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) ClustersListBySubscription ¶ 

func (c NetworkcloudsClient) ClustersListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result ClustersListBySubscriptionOperationResponse, err error)

ClustersListBySubscription ...

func (NetworkcloudsClient) ClustersListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) ClustersListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (ClustersListBySubscriptionCompleteResult, error)

ClustersListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) ClustersListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) ClustersListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate ClusterOperationPredicate) (result ClustersListBySubscriptionCompleteResult, err error)

ClustersListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) ClustersUpdate ¶ 

func (c NetworkcloudsClient) ClustersUpdate(ctx context.Context, id ClusterId, input ClusterPatchParameters) (result ClustersUpdateOperationResponse, err error)

ClustersUpdate ...

func (NetworkcloudsClient) ClustersUpdateThenPoll ¶ 

func (c NetworkcloudsClient) ClustersUpdateThenPoll(ctx context.Context, id ClusterId, input ClusterPatchParameters) error

ClustersUpdateThenPoll performs ClustersUpdate then polls until it's completed

func (NetworkcloudsClient) ClustersUpdateVersion ¶ 

func (c NetworkcloudsClient) ClustersUpdateVersion(ctx context.Context, id ClusterId, input ClusterUpdateVersionParameters) (result ClustersUpdateVersionOperationResponse, err error)

ClustersUpdateVersion ...

func (NetworkcloudsClient) ClustersUpdateVersionThenPoll ¶ 

func (c NetworkcloudsClient) ClustersUpdateVersionThenPoll(ctx context.Context, id ClusterId, input ClusterUpdateVersionParameters) error

ClustersUpdateVersionThenPoll performs ClustersUpdateVersion then polls until it's completed

func (NetworkcloudsClient) ConsolesCreateOrUpdate ¶ 

func (c NetworkcloudsClient) ConsolesCreateOrUpdate(ctx context.Context, id ConsoleId, input Console) (result ConsolesCreateOrUpdateOperationResponse, err error)

ConsolesCreateOrUpdate ...

func (NetworkcloudsClient) ConsolesCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) ConsolesCreateOrUpdateThenPoll(ctx context.Context, id ConsoleId, input Console) error

ConsolesCreateOrUpdateThenPoll performs ConsolesCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) ConsolesDelete ¶ 

func (c NetworkcloudsClient) ConsolesDelete(ctx context.Context, id ConsoleId) (result ConsolesDeleteOperationResponse, err error)

ConsolesDelete ...

func (NetworkcloudsClient) ConsolesDeleteThenPoll ¶ 

func (c NetworkcloudsClient) ConsolesDeleteThenPoll(ctx context.Context, id ConsoleId) error

ConsolesDeleteThenPoll performs ConsolesDelete then polls until it's completed

func (NetworkcloudsClient) ConsolesGet ¶ 

func (c NetworkcloudsClient) ConsolesGet(ctx context.Context, id ConsoleId) (result ConsolesGetOperationResponse, err error)

ConsolesGet ...

func (NetworkcloudsClient) ConsolesListByVirtualMachine ¶ 

func (c NetworkcloudsClient) ConsolesListByVirtualMachine(ctx context.Context, id VirtualMachineId) (result ConsolesListByVirtualMachineOperationResponse, err error)

ConsolesListByVirtualMachine ...

func (NetworkcloudsClient) ConsolesListByVirtualMachineComplete ¶ 

func (c NetworkcloudsClient) ConsolesListByVirtualMachineComplete(ctx context.Context, id VirtualMachineId) (ConsolesListByVirtualMachineCompleteResult, error)

ConsolesListByVirtualMachineComplete retrieves all the results into a single object

func (NetworkcloudsClient) ConsolesListByVirtualMachineCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) ConsolesListByVirtualMachineCompleteMatchingPredicate(ctx context.Context, id VirtualMachineId, predicate ConsoleOperationPredicate) (result ConsolesListByVirtualMachineCompleteResult, err error)

ConsolesListByVirtualMachineCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) ConsolesUpdate ¶ 

func (c NetworkcloudsClient) ConsolesUpdate(ctx context.Context, id ConsoleId, input ConsolePatchParameters) (result ConsolesUpdateOperationResponse, err error)

ConsolesUpdate ...

func (NetworkcloudsClient) ConsolesUpdateThenPoll ¶ 

func (c NetworkcloudsClient) ConsolesUpdateThenPoll(ctx context.Context, id ConsoleId, input ConsolePatchParameters) error

ConsolesUpdateThenPoll performs ConsolesUpdate then polls until it's completed

func (NetworkcloudsClient) KubernetesClustersCreateOrUpdate ¶ 

func (c NetworkcloudsClient) KubernetesClustersCreateOrUpdate(ctx context.Context, id KubernetesClusterId, input KubernetesCluster) (result KubernetesClustersCreateOrUpdateOperationResponse, err error)

KubernetesClustersCreateOrUpdate ...

func (NetworkcloudsClient) KubernetesClustersCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) KubernetesClustersCreateOrUpdateThenPoll(ctx context.Context, id KubernetesClusterId, input KubernetesCluster) error

KubernetesClustersCreateOrUpdateThenPoll performs KubernetesClustersCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) KubernetesClustersDelete ¶ 

func (c NetworkcloudsClient) KubernetesClustersDelete(ctx context.Context, id KubernetesClusterId) (result KubernetesClustersDeleteOperationResponse, err error)

KubernetesClustersDelete ...

func (NetworkcloudsClient) KubernetesClustersDeleteThenPoll ¶ 

func (c NetworkcloudsClient) KubernetesClustersDeleteThenPoll(ctx context.Context, id KubernetesClusterId) error

KubernetesClustersDeleteThenPoll performs KubernetesClustersDelete then polls until it's completed

func (NetworkcloudsClient) KubernetesClustersGet ¶ 

func (c NetworkcloudsClient) KubernetesClustersGet(ctx context.Context, id KubernetesClusterId) (result KubernetesClustersGetOperationResponse, err error)

KubernetesClustersGet ...

func (NetworkcloudsClient) KubernetesClustersListByResourceGroup ¶ 

func (c NetworkcloudsClient) KubernetesClustersListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result KubernetesClustersListByResourceGroupOperationResponse, err error)

KubernetesClustersListByResourceGroup ...

func (NetworkcloudsClient) KubernetesClustersListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) KubernetesClustersListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (KubernetesClustersListByResourceGroupCompleteResult, error)

KubernetesClustersListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) KubernetesClustersListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) KubernetesClustersListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate KubernetesClusterOperationPredicate) (result KubernetesClustersListByResourceGroupCompleteResult, err error)

KubernetesClustersListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) KubernetesClustersListBySubscription ¶ 

func (c NetworkcloudsClient) KubernetesClustersListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result KubernetesClustersListBySubscriptionOperationResponse, err error)

KubernetesClustersListBySubscription ...

func (NetworkcloudsClient) KubernetesClustersListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) KubernetesClustersListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (KubernetesClustersListBySubscriptionCompleteResult, error)

KubernetesClustersListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) KubernetesClustersListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) KubernetesClustersListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate KubernetesClusterOperationPredicate) (result KubernetesClustersListBySubscriptionCompleteResult, err error)

KubernetesClustersListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) KubernetesClustersRestartNode ¶ 

func (c NetworkcloudsClient) KubernetesClustersRestartNode(ctx context.Context, id KubernetesClusterId, input KubernetesClusterRestartNodeParameters) (result KubernetesClustersRestartNodeOperationResponse, err error)

KubernetesClustersRestartNode ...

func (NetworkcloudsClient) KubernetesClustersRestartNodeThenPoll ¶ 

func (c NetworkcloudsClient) KubernetesClustersRestartNodeThenPoll(ctx context.Context, id KubernetesClusterId, input KubernetesClusterRestartNodeParameters) error

KubernetesClustersRestartNodeThenPoll performs KubernetesClustersRestartNode then polls until it's completed

func (NetworkcloudsClient) KubernetesClustersUpdate ¶ 

func (c NetworkcloudsClient) KubernetesClustersUpdate(ctx context.Context, id KubernetesClusterId, input KubernetesClusterPatchParameters) (result KubernetesClustersUpdateOperationResponse, err error)

KubernetesClustersUpdate ...

func (NetworkcloudsClient) KubernetesClustersUpdateThenPoll ¶ 

func (c NetworkcloudsClient) KubernetesClustersUpdateThenPoll(ctx context.Context, id KubernetesClusterId, input KubernetesClusterPatchParameters) error

KubernetesClustersUpdateThenPoll performs KubernetesClustersUpdate then polls until it's completed

func (NetworkcloudsClient) L2NetworksCreateOrUpdate ¶ 

func (c NetworkcloudsClient) L2NetworksCreateOrUpdate(ctx context.Context, id L2NetworkId, input L2Network) (result L2NetworksCreateOrUpdateOperationResponse, err error)

L2NetworksCreateOrUpdate ...

func (NetworkcloudsClient) L2NetworksCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) L2NetworksCreateOrUpdateThenPoll(ctx context.Context, id L2NetworkId, input L2Network) error

L2NetworksCreateOrUpdateThenPoll performs L2NetworksCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) L2NetworksDelete ¶ 

func (c NetworkcloudsClient) L2NetworksDelete(ctx context.Context, id L2NetworkId) (result L2NetworksDeleteOperationResponse, err error)

L2NetworksDelete ...

func (NetworkcloudsClient) L2NetworksDeleteThenPoll ¶ 

func (c NetworkcloudsClient) L2NetworksDeleteThenPoll(ctx context.Context, id L2NetworkId) error

L2NetworksDeleteThenPoll performs L2NetworksDelete then polls until it's completed

func (NetworkcloudsClient) L2NetworksGet ¶ 

func (c NetworkcloudsClient) L2NetworksGet(ctx context.Context, id L2NetworkId) (result L2NetworksGetOperationResponse, err error)

L2NetworksGet ...

func (NetworkcloudsClient) L2NetworksListByResourceGroup ¶ 

func (c NetworkcloudsClient) L2NetworksListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result L2NetworksListByResourceGroupOperationResponse, err error)

L2NetworksListByResourceGroup ...

func (NetworkcloudsClient) L2NetworksListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) L2NetworksListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (L2NetworksListByResourceGroupCompleteResult, error)

L2NetworksListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) L2NetworksListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) L2NetworksListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate L2NetworkOperationPredicate) (result L2NetworksListByResourceGroupCompleteResult, err error)

L2NetworksListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) L2NetworksListBySubscription ¶ 

func (c NetworkcloudsClient) L2NetworksListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result L2NetworksListBySubscriptionOperationResponse, err error)

L2NetworksListBySubscription ...

func (NetworkcloudsClient) L2NetworksListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) L2NetworksListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (L2NetworksListBySubscriptionCompleteResult, error)

L2NetworksListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) L2NetworksListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) L2NetworksListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate L2NetworkOperationPredicate) (result L2NetworksListBySubscriptionCompleteResult, err error)

L2NetworksListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) L2NetworksUpdate ¶ 

func (c NetworkcloudsClient) L2NetworksUpdate(ctx context.Context, id L2NetworkId, input L2NetworkPatchParameters) (result L2NetworksUpdateOperationResponse, err error)

L2NetworksUpdate ...

func (NetworkcloudsClient) L3NetworksCreateOrUpdate ¶ 

func (c NetworkcloudsClient) L3NetworksCreateOrUpdate(ctx context.Context, id L3NetworkId, input L3Network) (result L3NetworksCreateOrUpdateOperationResponse, err error)

L3NetworksCreateOrUpdate ...

func (NetworkcloudsClient) L3NetworksCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) L3NetworksCreateOrUpdateThenPoll(ctx context.Context, id L3NetworkId, input L3Network) error

L3NetworksCreateOrUpdateThenPoll performs L3NetworksCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) L3NetworksDelete ¶ 

func (c NetworkcloudsClient) L3NetworksDelete(ctx context.Context, id L3NetworkId) (result L3NetworksDeleteOperationResponse, err error)

L3NetworksDelete ...

func (NetworkcloudsClient) L3NetworksDeleteThenPoll ¶ 

func (c NetworkcloudsClient) L3NetworksDeleteThenPoll(ctx context.Context, id L3NetworkId) error

L3NetworksDeleteThenPoll performs L3NetworksDelete then polls until it's completed

func (NetworkcloudsClient) L3NetworksGet ¶ 

func (c NetworkcloudsClient) L3NetworksGet(ctx context.Context, id L3NetworkId) (result L3NetworksGetOperationResponse, err error)

L3NetworksGet ...

func (NetworkcloudsClient) L3NetworksListByResourceGroup ¶ 

func (c NetworkcloudsClient) L3NetworksListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result L3NetworksListByResourceGroupOperationResponse, err error)

L3NetworksListByResourceGroup ...

func (NetworkcloudsClient) L3NetworksListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) L3NetworksListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (L3NetworksListByResourceGroupCompleteResult, error)

L3NetworksListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) L3NetworksListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) L3NetworksListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate L3NetworkOperationPredicate) (result L3NetworksListByResourceGroupCompleteResult, err error)

L3NetworksListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) L3NetworksListBySubscription ¶ 

func (c NetworkcloudsClient) L3NetworksListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result L3NetworksListBySubscriptionOperationResponse, err error)

L3NetworksListBySubscription ...

func (NetworkcloudsClient) L3NetworksListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) L3NetworksListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (L3NetworksListBySubscriptionCompleteResult, error)

L3NetworksListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) L3NetworksListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) L3NetworksListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate L3NetworkOperationPredicate) (result L3NetworksListBySubscriptionCompleteResult, err error)

L3NetworksListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) L3NetworksUpdate ¶ 

func (c NetworkcloudsClient) L3NetworksUpdate(ctx context.Context, id L3NetworkId, input L3NetworkPatchParameters) (result L3NetworksUpdateOperationResponse, err error)

L3NetworksUpdate ...

func (NetworkcloudsClient) MetricsConfigurationsCreateOrUpdate ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsCreateOrUpdate(ctx context.Context, id MetricsConfigurationId, input ClusterMetricsConfiguration) (result MetricsConfigurationsCreateOrUpdateOperationResponse, err error)

MetricsConfigurationsCreateOrUpdate ...

func (NetworkcloudsClient) MetricsConfigurationsCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsCreateOrUpdateThenPoll(ctx context.Context, id MetricsConfigurationId, input ClusterMetricsConfiguration) error

MetricsConfigurationsCreateOrUpdateThenPoll performs MetricsConfigurationsCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) MetricsConfigurationsDelete ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsDelete(ctx context.Context, id MetricsConfigurationId) (result MetricsConfigurationsDeleteOperationResponse, err error)

MetricsConfigurationsDelete ...

func (NetworkcloudsClient) MetricsConfigurationsDeleteThenPoll ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsDeleteThenPoll(ctx context.Context, id MetricsConfigurationId) error

MetricsConfigurationsDeleteThenPoll performs MetricsConfigurationsDelete then polls until it's completed

func (NetworkcloudsClient) MetricsConfigurationsGet ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsGet(ctx context.Context, id MetricsConfigurationId) (result MetricsConfigurationsGetOperationResponse, err error)

MetricsConfigurationsGet ...

func (NetworkcloudsClient) MetricsConfigurationsListByCluster ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsListByCluster(ctx context.Context, id ClusterId) (result MetricsConfigurationsListByClusterOperationResponse, err error)

MetricsConfigurationsListByCluster ...

func (NetworkcloudsClient) MetricsConfigurationsListByClusterComplete ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsListByClusterComplete(ctx context.Context, id ClusterId) (MetricsConfigurationsListByClusterCompleteResult, error)

MetricsConfigurationsListByClusterComplete retrieves all the results into a single object

func (NetworkcloudsClient) MetricsConfigurationsListByClusterCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsListByClusterCompleteMatchingPredicate(ctx context.Context, id ClusterId, predicate ClusterMetricsConfigurationOperationPredicate) (result MetricsConfigurationsListByClusterCompleteResult, err error)

MetricsConfigurationsListByClusterCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) MetricsConfigurationsUpdate ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsUpdate(ctx context.Context, id MetricsConfigurationId, input ClusterMetricsConfigurationPatchParameters) (result MetricsConfigurationsUpdateOperationResponse, err error)

MetricsConfigurationsUpdate ...

func (NetworkcloudsClient) MetricsConfigurationsUpdateThenPoll ¶ 

func (c NetworkcloudsClient) MetricsConfigurationsUpdateThenPoll(ctx context.Context, id MetricsConfigurationId, input ClusterMetricsConfigurationPatchParameters) error

MetricsConfigurationsUpdateThenPoll performs MetricsConfigurationsUpdate then polls until it's completed

func (NetworkcloudsClient) RackSkusGet ¶ 

func (c NetworkcloudsClient) RackSkusGet(ctx context.Context, id RackSkuId) (result RackSkusGetOperationResponse, err error)

RackSkusGet ...

func (NetworkcloudsClient) RackSkusListBySubscription ¶ 

func (c NetworkcloudsClient) RackSkusListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result RackSkusListBySubscriptionOperationResponse, err error)

RackSkusListBySubscription ...

func (NetworkcloudsClient) RackSkusListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) RackSkusListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (RackSkusListBySubscriptionCompleteResult, error)

RackSkusListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) RackSkusListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) RackSkusListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate RackSkuOperationPredicate) (result RackSkusListBySubscriptionCompleteResult, err error)

RackSkusListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) RacksCreateOrUpdate ¶ 

func (c NetworkcloudsClient) RacksCreateOrUpdate(ctx context.Context, id RackId, input Rack) (result RacksCreateOrUpdateOperationResponse, err error)

RacksCreateOrUpdate ...

func (NetworkcloudsClient) RacksCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) RacksCreateOrUpdateThenPoll(ctx context.Context, id RackId, input Rack) error

RacksCreateOrUpdateThenPoll performs RacksCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) RacksDelete ¶ 

func (c NetworkcloudsClient) RacksDelete(ctx context.Context, id RackId) (result RacksDeleteOperationResponse, err error)

RacksDelete ...

func (NetworkcloudsClient) RacksDeleteThenPoll ¶ 

func (c NetworkcloudsClient) RacksDeleteThenPoll(ctx context.Context, id RackId) error

RacksDeleteThenPoll performs RacksDelete then polls until it's completed

func (NetworkcloudsClient) RacksGet ¶ 

func (c NetworkcloudsClient) RacksGet(ctx context.Context, id RackId) (result RacksGetOperationResponse, err error)

RacksGet ...

func (NetworkcloudsClient) RacksListByResourceGroup ¶ 

func (c NetworkcloudsClient) RacksListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result RacksListByResourceGroupOperationResponse, err error)

RacksListByResourceGroup ...

func (NetworkcloudsClient) RacksListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) RacksListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (RacksListByResourceGroupCompleteResult, error)

RacksListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) RacksListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) RacksListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate RackOperationPredicate) (result RacksListByResourceGroupCompleteResult, err error)

RacksListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) RacksListBySubscription ¶ 

func (c NetworkcloudsClient) RacksListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result RacksListBySubscriptionOperationResponse, err error)

RacksListBySubscription ...

func (NetworkcloudsClient) RacksListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) RacksListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (RacksListBySubscriptionCompleteResult, error)

RacksListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) RacksListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) RacksListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate RackOperationPredicate) (result RacksListBySubscriptionCompleteResult, err error)

RacksListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) RacksUpdate ¶ 

func (c NetworkcloudsClient) RacksUpdate(ctx context.Context, id RackId, input RackPatchParameters) (result RacksUpdateOperationResponse, err error)

RacksUpdate ...

func (NetworkcloudsClient) RacksUpdateThenPoll ¶ 

func (c NetworkcloudsClient) RacksUpdateThenPoll(ctx context.Context, id RackId, input RackPatchParameters) error

RacksUpdateThenPoll performs RacksUpdate then polls until it's completed

func (NetworkcloudsClient) StorageAppliancesCreateOrUpdate ¶ 

func (c NetworkcloudsClient) StorageAppliancesCreateOrUpdate(ctx context.Context, id StorageApplianceId, input StorageAppliance) (result StorageAppliancesCreateOrUpdateOperationResponse, err error)

StorageAppliancesCreateOrUpdate ...

func (NetworkcloudsClient) StorageAppliancesCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) StorageAppliancesCreateOrUpdateThenPoll(ctx context.Context, id StorageApplianceId, input StorageAppliance) error

StorageAppliancesCreateOrUpdateThenPoll performs StorageAppliancesCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) StorageAppliancesDelete ¶ 

func (c NetworkcloudsClient) StorageAppliancesDelete(ctx context.Context, id StorageApplianceId) (result StorageAppliancesDeleteOperationResponse, err error)

StorageAppliancesDelete ...

func (NetworkcloudsClient) StorageAppliancesDeleteThenPoll ¶ 

func (c NetworkcloudsClient) StorageAppliancesDeleteThenPoll(ctx context.Context, id StorageApplianceId) error

StorageAppliancesDeleteThenPoll performs StorageAppliancesDelete then polls until it's completed

func (NetworkcloudsClient) StorageAppliancesDisableRemoteVendorManagement ¶ 

func (c NetworkcloudsClient) StorageAppliancesDisableRemoteVendorManagement(ctx context.Context, id StorageApplianceId) (result StorageAppliancesDisableRemoteVendorManagementOperationResponse, err error)

StorageAppliancesDisableRemoteVendorManagement ...

func (NetworkcloudsClient) StorageAppliancesDisableRemoteVendorManagementThenPoll ¶ 

func (c NetworkcloudsClient) StorageAppliancesDisableRemoteVendorManagementThenPoll(ctx context.Context, id StorageApplianceId) error

StorageAppliancesDisableRemoteVendorManagementThenPoll performs StorageAppliancesDisableRemoteVendorManagement then polls until it's completed

func (NetworkcloudsClient) StorageAppliancesEnableRemoteVendorManagement ¶ 

func (c NetworkcloudsClient) StorageAppliancesEnableRemoteVendorManagement(ctx context.Context, id StorageApplianceId, input StorageApplianceEnableRemoteVendorManagementParameters) (result StorageAppliancesEnableRemoteVendorManagementOperationResponse, err error)

StorageAppliancesEnableRemoteVendorManagement ...

func (NetworkcloudsClient) StorageAppliancesEnableRemoteVendorManagementThenPoll ¶ 

func (c NetworkcloudsClient) StorageAppliancesEnableRemoteVendorManagementThenPoll(ctx context.Context, id StorageApplianceId, input StorageApplianceEnableRemoteVendorManagementParameters) error

StorageAppliancesEnableRemoteVendorManagementThenPoll performs StorageAppliancesEnableRemoteVendorManagement then polls until it's completed

func (NetworkcloudsClient) StorageAppliancesGet ¶ 

func (c NetworkcloudsClient) StorageAppliancesGet(ctx context.Context, id StorageApplianceId) (result StorageAppliancesGetOperationResponse, err error)

StorageAppliancesGet ...

func (NetworkcloudsClient) StorageAppliancesListByResourceGroup ¶ 

func (c NetworkcloudsClient) StorageAppliancesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result StorageAppliancesListByResourceGroupOperationResponse, err error)

StorageAppliancesListByResourceGroup ...

func (NetworkcloudsClient) StorageAppliancesListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) StorageAppliancesListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (StorageAppliancesListByResourceGroupCompleteResult, error)

StorageAppliancesListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) StorageAppliancesListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) StorageAppliancesListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate StorageApplianceOperationPredicate) (result StorageAppliancesListByResourceGroupCompleteResult, err error)

StorageAppliancesListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) StorageAppliancesListBySubscription ¶ 

func (c NetworkcloudsClient) StorageAppliancesListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result StorageAppliancesListBySubscriptionOperationResponse, err error)

StorageAppliancesListBySubscription ...

func (NetworkcloudsClient) StorageAppliancesListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) StorageAppliancesListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (StorageAppliancesListBySubscriptionCompleteResult, error)

StorageAppliancesListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) StorageAppliancesListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) StorageAppliancesListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate StorageApplianceOperationPredicate) (result StorageAppliancesListBySubscriptionCompleteResult, err error)

StorageAppliancesListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) StorageAppliancesUpdate ¶ 

func (c NetworkcloudsClient) StorageAppliancesUpdate(ctx context.Context, id StorageApplianceId, input StorageAppliancePatchParameters) (result StorageAppliancesUpdateOperationResponse, err error)

StorageAppliancesUpdate ...

func (NetworkcloudsClient) StorageAppliancesUpdateThenPoll ¶ 

func (c NetworkcloudsClient) StorageAppliancesUpdateThenPoll(ctx context.Context, id StorageApplianceId, input StorageAppliancePatchParameters) error

StorageAppliancesUpdateThenPoll performs StorageAppliancesUpdate then polls until it's completed

func (NetworkcloudsClient) TrunkedNetworksCreateOrUpdate ¶ 

func (c NetworkcloudsClient) TrunkedNetworksCreateOrUpdate(ctx context.Context, id TrunkedNetworkId, input TrunkedNetwork) (result TrunkedNetworksCreateOrUpdateOperationResponse, err error)

TrunkedNetworksCreateOrUpdate ...

func (NetworkcloudsClient) TrunkedNetworksCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) TrunkedNetworksCreateOrUpdateThenPoll(ctx context.Context, id TrunkedNetworkId, input TrunkedNetwork) error

TrunkedNetworksCreateOrUpdateThenPoll performs TrunkedNetworksCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) TrunkedNetworksDelete ¶ 

func (c NetworkcloudsClient) TrunkedNetworksDelete(ctx context.Context, id TrunkedNetworkId) (result TrunkedNetworksDeleteOperationResponse, err error)

TrunkedNetworksDelete ...

func (NetworkcloudsClient) TrunkedNetworksDeleteThenPoll ¶ 

func (c NetworkcloudsClient) TrunkedNetworksDeleteThenPoll(ctx context.Context, id TrunkedNetworkId) error

TrunkedNetworksDeleteThenPoll performs TrunkedNetworksDelete then polls until it's completed

func (NetworkcloudsClient) TrunkedNetworksGet ¶ 

func (c NetworkcloudsClient) TrunkedNetworksGet(ctx context.Context, id TrunkedNetworkId) (result TrunkedNetworksGetOperationResponse, err error)

TrunkedNetworksGet ...

func (NetworkcloudsClient) TrunkedNetworksListByResourceGroup ¶ 

func (c NetworkcloudsClient) TrunkedNetworksListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result TrunkedNetworksListByResourceGroupOperationResponse, err error)

TrunkedNetworksListByResourceGroup ...

func (NetworkcloudsClient) TrunkedNetworksListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) TrunkedNetworksListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (TrunkedNetworksListByResourceGroupCompleteResult, error)

TrunkedNetworksListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) TrunkedNetworksListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) TrunkedNetworksListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate TrunkedNetworkOperationPredicate) (result TrunkedNetworksListByResourceGroupCompleteResult, err error)

TrunkedNetworksListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) TrunkedNetworksListBySubscription ¶ 

func (c NetworkcloudsClient) TrunkedNetworksListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result TrunkedNetworksListBySubscriptionOperationResponse, err error)

TrunkedNetworksListBySubscription ...

func (NetworkcloudsClient) TrunkedNetworksListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) TrunkedNetworksListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (TrunkedNetworksListBySubscriptionCompleteResult, error)

TrunkedNetworksListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) TrunkedNetworksListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) TrunkedNetworksListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate TrunkedNetworkOperationPredicate) (result TrunkedNetworksListBySubscriptionCompleteResult, err error)

TrunkedNetworksListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) TrunkedNetworksUpdate ¶ 

func (c NetworkcloudsClient) TrunkedNetworksUpdate(ctx context.Context, id TrunkedNetworkId, input TrunkedNetworkPatchParameters) (result TrunkedNetworksUpdateOperationResponse, err error)

TrunkedNetworksUpdate ...

func (NetworkcloudsClient) VirtualMachinesCreateOrUpdate ¶ 

func (c NetworkcloudsClient) VirtualMachinesCreateOrUpdate(ctx context.Context, id VirtualMachineId, input VirtualMachine) (result VirtualMachinesCreateOrUpdateOperationResponse, err error)

VirtualMachinesCreateOrUpdate ...

func (NetworkcloudsClient) VirtualMachinesCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesCreateOrUpdateThenPoll(ctx context.Context, id VirtualMachineId, input VirtualMachine) error

VirtualMachinesCreateOrUpdateThenPoll performs VirtualMachinesCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) VirtualMachinesDelete ¶ 

func (c NetworkcloudsClient) VirtualMachinesDelete(ctx context.Context, id VirtualMachineId) (result VirtualMachinesDeleteOperationResponse, err error)

VirtualMachinesDelete ...

func (NetworkcloudsClient) VirtualMachinesDeleteThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesDeleteThenPoll(ctx context.Context, id VirtualMachineId) error

VirtualMachinesDeleteThenPoll performs VirtualMachinesDelete then polls until it's completed

func (NetworkcloudsClient) VirtualMachinesGet ¶ 

func (c NetworkcloudsClient) VirtualMachinesGet(ctx context.Context, id VirtualMachineId) (result VirtualMachinesGetOperationResponse, err error)

VirtualMachinesGet ...

func (NetworkcloudsClient) VirtualMachinesListByResourceGroup ¶ 

func (c NetworkcloudsClient) VirtualMachinesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VirtualMachinesListByResourceGroupOperationResponse, err error)

VirtualMachinesListByResourceGroup ...

func (NetworkcloudsClient) VirtualMachinesListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) VirtualMachinesListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VirtualMachinesListByResourceGroupCompleteResult, error)

VirtualMachinesListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) VirtualMachinesListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) VirtualMachinesListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VirtualMachineOperationPredicate) (result VirtualMachinesListByResourceGroupCompleteResult, err error)

VirtualMachinesListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) VirtualMachinesListBySubscription ¶ 

func (c NetworkcloudsClient) VirtualMachinesListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result VirtualMachinesListBySubscriptionOperationResponse, err error)

VirtualMachinesListBySubscription ...

func (NetworkcloudsClient) VirtualMachinesListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) VirtualMachinesListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (VirtualMachinesListBySubscriptionCompleteResult, error)

VirtualMachinesListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) VirtualMachinesListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) VirtualMachinesListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VirtualMachineOperationPredicate) (result VirtualMachinesListBySubscriptionCompleteResult, err error)

VirtualMachinesListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) VirtualMachinesPowerOff ¶ 

func (c NetworkcloudsClient) VirtualMachinesPowerOff(ctx context.Context, id VirtualMachineId, input VirtualMachinePowerOffParameters) (result VirtualMachinesPowerOffOperationResponse, err error)

VirtualMachinesPowerOff ...

func (NetworkcloudsClient) VirtualMachinesPowerOffThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesPowerOffThenPoll(ctx context.Context, id VirtualMachineId, input VirtualMachinePowerOffParameters) error

VirtualMachinesPowerOffThenPoll performs VirtualMachinesPowerOff then polls until it's completed

func (NetworkcloudsClient) VirtualMachinesReimage ¶ 

func (c NetworkcloudsClient) VirtualMachinesReimage(ctx context.Context, id VirtualMachineId) (result VirtualMachinesReimageOperationResponse, err error)

VirtualMachinesReimage ...

func (NetworkcloudsClient) VirtualMachinesReimageThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesReimageThenPoll(ctx context.Context, id VirtualMachineId) error

VirtualMachinesReimageThenPoll performs VirtualMachinesReimage then polls until it's completed

func (NetworkcloudsClient) VirtualMachinesRestart ¶ 

func (c NetworkcloudsClient) VirtualMachinesRestart(ctx context.Context, id VirtualMachineId) (result VirtualMachinesRestartOperationResponse, err error)

VirtualMachinesRestart ...

func (NetworkcloudsClient) VirtualMachinesRestartThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesRestartThenPoll(ctx context.Context, id VirtualMachineId) error

VirtualMachinesRestartThenPoll performs VirtualMachinesRestart then polls until it's completed

func (NetworkcloudsClient) VirtualMachinesStart ¶ 

func (c NetworkcloudsClient) VirtualMachinesStart(ctx context.Context, id VirtualMachineId) (result VirtualMachinesStartOperationResponse, err error)

VirtualMachinesStart ...

func (NetworkcloudsClient) VirtualMachinesStartThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesStartThenPoll(ctx context.Context, id VirtualMachineId) error

VirtualMachinesStartThenPoll performs VirtualMachinesStart then polls until it's completed

func (NetworkcloudsClient) VirtualMachinesUpdate ¶ 

func (c NetworkcloudsClient) VirtualMachinesUpdate(ctx context.Context, id VirtualMachineId, input VirtualMachinePatchParameters) (result VirtualMachinesUpdateOperationResponse, err error)

VirtualMachinesUpdate ...

func (NetworkcloudsClient) VirtualMachinesUpdateThenPoll ¶ 

func (c NetworkcloudsClient) VirtualMachinesUpdateThenPoll(ctx context.Context, id VirtualMachineId, input VirtualMachinePatchParameters) error

VirtualMachinesUpdateThenPoll performs VirtualMachinesUpdate then polls until it's completed

func (NetworkcloudsClient) VolumesCreateOrUpdate ¶ 

func (c NetworkcloudsClient) VolumesCreateOrUpdate(ctx context.Context, id VolumeId, input Volume) (result VolumesCreateOrUpdateOperationResponse, err error)

VolumesCreateOrUpdate ...

func (NetworkcloudsClient) VolumesCreateOrUpdateThenPoll ¶ 

func (c NetworkcloudsClient) VolumesCreateOrUpdateThenPoll(ctx context.Context, id VolumeId, input Volume) error

VolumesCreateOrUpdateThenPoll performs VolumesCreateOrUpdate then polls until it's completed

func (NetworkcloudsClient) VolumesDelete ¶ 

func (c NetworkcloudsClient) VolumesDelete(ctx context.Context, id VolumeId) (result VolumesDeleteOperationResponse, err error)

VolumesDelete ...

func (NetworkcloudsClient) VolumesDeleteThenPoll ¶ 

func (c NetworkcloudsClient) VolumesDeleteThenPoll(ctx context.Context, id VolumeId) error

VolumesDeleteThenPoll performs VolumesDelete then polls until it's completed

func (NetworkcloudsClient) VolumesGet ¶ 

func (c NetworkcloudsClient) VolumesGet(ctx context.Context, id VolumeId) (result VolumesGetOperationResponse, err error)

VolumesGet ...

func (NetworkcloudsClient) VolumesListByResourceGroup ¶ 

func (c NetworkcloudsClient) VolumesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result VolumesListByResourceGroupOperationResponse, err error)

VolumesListByResourceGroup ...

func (NetworkcloudsClient) VolumesListByResourceGroupComplete ¶ 

func (c NetworkcloudsClient) VolumesListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (VolumesListByResourceGroupCompleteResult, error)

VolumesListByResourceGroupComplete retrieves all the results into a single object

func (NetworkcloudsClient) VolumesListByResourceGroupCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) VolumesListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate VolumeOperationPredicate) (result VolumesListByResourceGroupCompleteResult, err error)

VolumesListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) VolumesListBySubscription ¶ 

func (c NetworkcloudsClient) VolumesListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result VolumesListBySubscriptionOperationResponse, err error)

VolumesListBySubscription ...

func (NetworkcloudsClient) VolumesListBySubscriptionComplete ¶ 

func (c NetworkcloudsClient) VolumesListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (VolumesListBySubscriptionCompleteResult, error)

VolumesListBySubscriptionComplete retrieves all the results into a single object

func (NetworkcloudsClient) VolumesListBySubscriptionCompleteMatchingPredicate ¶ 

func (c NetworkcloudsClient) VolumesListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate VolumeOperationPredicate) (result VolumesListBySubscriptionCompleteResult, err error)

VolumesListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (NetworkcloudsClient) VolumesUpdate ¶ 

func (c NetworkcloudsClient) VolumesUpdate(ctx context.Context, id VolumeId, input VolumePatchParameters) (result VolumesUpdateOperationResponse, err error)

VolumesUpdate ...

type Nic ¶ 

type Nic struct {
	LldpNeighbor *LldpNeighbor `json:"lldpNeighbor,omitempty"`
	MacAddress   *string       `json:"macAddress,omitempty"`
	Name         *string       `json:"name,omitempty"`
}

type OsDisk ¶ 

type OsDisk struct {
	CreateOption *OsDiskCreateOption `json:"createOption,omitempty"`
	DeleteOption *OsDiskDeleteOption `json:"deleteOption,omitempty"`
	DiskSizeGB   int64               `json:"diskSizeGB"`
}

type OsDiskCreateOption ¶ 

type OsDiskCreateOption string
const (
	OsDiskCreateOptionEphemeral OsDiskCreateOption = "Ephemeral"
)

func (*OsDiskCreateOption) UnmarshalJSON ¶ 

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

type OsDiskDeleteOption ¶ 

type OsDiskDeleteOption string
const (
	OsDiskDeleteOptionDelete OsDiskDeleteOption = "Delete"
)

func (*OsDiskDeleteOption) UnmarshalJSON ¶ 

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

type Rack ¶ 

type Rack struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       RackProperties         `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type RackDefinition ¶ 

type RackDefinition struct {
	AvailabilityZone                  *string                              `json:"availabilityZone,omitempty"`
	BareMetalMachineConfigurationData *[]BareMetalMachineConfigurationData `json:"bareMetalMachineConfigurationData,omitempty"`
	NetworkRackId                     string                               `json:"networkRackId"`
	RackLocation                      *string                              `json:"rackLocation,omitempty"`
	RackSerialNumber                  string                               `json:"rackSerialNumber"`
	RackSkuId                         string                               `json:"rackSkuId"`
	StorageApplianceConfigurationData *[]StorageApplianceConfigurationData `json:"storageApplianceConfigurationData,omitempty"`
}

type RackDetailedStatus ¶ 

type RackDetailedStatus string
const (
	RackDetailedStatusAvailable    RackDetailedStatus = "Available"
	RackDetailedStatusError        RackDetailedStatus = "Error"
	RackDetailedStatusProvisioning RackDetailedStatus = "Provisioning"
)

func (*RackDetailedStatus) UnmarshalJSON ¶ 

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

type RackId ¶ 

type RackId struct {
	SubscriptionId    string
	ResourceGroupName string
	RackName          string
}

RackId is a struct representing the Resource ID for a Rack

func NewRackID ¶ 

func NewRackID(subscriptionId string, resourceGroupName string, rackName string) RackId

NewRackID returns a new RackId struct

func ParseRackID ¶ 

func ParseRackID(input string) (*RackId, error)

ParseRackID parses 'input' into a RackId

func ParseRackIDInsensitively ¶ 

func ParseRackIDInsensitively(input string) (*RackId, error)

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

func (*RackId) FromParseResult ¶ 

func (id *RackId) FromParseResult(input resourceids.ParseResult) error

func (RackId) ID ¶ 

func (id RackId) ID() string

ID returns the formatted Rack ID

func (RackId) Segments ¶ 

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

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

func (RackId) String ¶ 

func (id RackId) String() string

String returns a human-readable description of this Rack ID

type RackOperationPredicate ¶ 

type RackOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (RackOperationPredicate) Matches ¶ 

func (p RackOperationPredicate) Matches(input Rack) bool

type RackPatchParameters ¶ 

type RackPatchParameters struct {
	Properties *RacksPatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string    `json:"tags,omitempty"`
}

type RackProperties ¶ 

type RackProperties struct {
	AvailabilityZone      string                 `json:"availabilityZone"`
	ClusterId             *string                `json:"clusterId,omitempty"`
	DetailedStatus        *RackDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                `json:"detailedStatusMessage,omitempty"`
	ProvisioningState     *RackProvisioningState `json:"provisioningState,omitempty"`
	RackLocation          string                 `json:"rackLocation"`
	RackSerialNumber      string                 `json:"rackSerialNumber"`
	RackSkuId             string                 `json:"rackSkuId"`
}

type RackProvisioningState ¶ 

type RackProvisioningState string
const (
	RackProvisioningStateAccepted     RackProvisioningState = "Accepted"
	RackProvisioningStateCanceled     RackProvisioningState = "Canceled"
	RackProvisioningStateFailed       RackProvisioningState = "Failed"
	RackProvisioningStateProvisioning RackProvisioningState = "Provisioning"
	RackProvisioningStateSucceeded    RackProvisioningState = "Succeeded"
)

func (*RackProvisioningState) UnmarshalJSON ¶ 

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

type RackSku ¶ 

type RackSku struct {
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties RackSkuProperties      `json:"properties"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type RackSkuId ¶ 

type RackSkuId struct {
	SubscriptionId string
	RackSkuName    string
}

RackSkuId is a struct representing the Resource ID for a Rack Sku

func NewRackSkuID ¶ 

func NewRackSkuID(subscriptionId string, rackSkuName string) RackSkuId

NewRackSkuID returns a new RackSkuId struct

func ParseRackSkuID ¶ 

func ParseRackSkuID(input string) (*RackSkuId, error)

ParseRackSkuID parses 'input' into a RackSkuId

func ParseRackSkuIDInsensitively ¶ 

func ParseRackSkuIDInsensitively(input string) (*RackSkuId, error)

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

func (*RackSkuId) FromParseResult ¶ 

func (id *RackSkuId) FromParseResult(input resourceids.ParseResult) error

func (RackSkuId) ID ¶ 

func (id RackSkuId) ID() string

ID returns the formatted Rack Sku ID

func (RackSkuId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Rack Sku ID

func (RackSkuId) String ¶ 

func (id RackSkuId) String() string

String returns a human-readable description of this Rack Sku ID

type RackSkuOperationPredicate ¶ 

type RackSkuOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (RackSkuOperationPredicate) Matches ¶ 

func (p RackSkuOperationPredicate) Matches(input RackSku) bool

type RackSkuProperties ¶ 

type RackSkuProperties struct {
	ComputeMachines     *[]MachineSkuSlot          `json:"computeMachines,omitempty"`
	ControllerMachines  *[]MachineSkuSlot          `json:"controllerMachines,omitempty"`
	Description         *string                    `json:"description,omitempty"`
	MaxClusterSlots     *int64                     `json:"maxClusterSlots,omitempty"`
	ProvisioningState   *RackSkuProvisioningState  `json:"provisioningState,omitempty"`
	RackType            *RackSkuType               `json:"rackType,omitempty"`
	StorageAppliances   *[]StorageApplianceSkuSlot `json:"storageAppliances,omitempty"`
	SupportedRackSkuIds *[]string                  `json:"supportedRackSkuIds,omitempty"`
}

type RackSkuProvisioningState ¶ 

type RackSkuProvisioningState string
const (
	RackSkuProvisioningStateSucceeded RackSkuProvisioningState = "Succeeded"
)

func (*RackSkuProvisioningState) UnmarshalJSON ¶ 

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

type RackSkuType ¶ 

type RackSkuType string
const (
	RackSkuTypeAggregator RackSkuType = "Aggregator"
	RackSkuTypeCompute    RackSkuType = "Compute"
	RackSkuTypeSingle     RackSkuType = "Single"
)

func (*RackSkuType) UnmarshalJSON ¶ 

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

type RackSkusGetOperationResponse ¶ 

type RackSkusGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *RackSku
}

type RackSkusListBySubscriptionCompleteResult ¶ 

type RackSkusListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []RackSku
}

type RackSkusListBySubscriptionOperationResponse ¶ 

type RackSkusListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]RackSku
}

type RacksCreateOrUpdateOperationResponse ¶ 

type RacksCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Rack
}

type RacksDeleteOperationResponse ¶ 

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

type RacksGetOperationResponse ¶ 

type RacksGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Rack
}

type RacksListByResourceGroupCompleteResult ¶ 

type RacksListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Rack
}

type RacksListByResourceGroupOperationResponse ¶ 

type RacksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Rack
}

type RacksListBySubscriptionCompleteResult ¶ 

type RacksListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Rack
}

type RacksListBySubscriptionOperationResponse ¶ 

type RacksListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Rack
}

type RacksPatchProperties ¶ 

type RacksPatchProperties struct {
	RackLocation     *string `json:"rackLocation,omitempty"`
	RackSerialNumber *string `json:"rackSerialNumber,omitempty"`
}

type RacksUpdateOperationResponse ¶ 

type RacksUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Rack
}

type RemoteVendorManagementFeature ¶ 

type RemoteVendorManagementFeature string
const (
	RemoteVendorManagementFeatureSupported   RemoteVendorManagementFeature = "Supported"
	RemoteVendorManagementFeatureUnsupported RemoteVendorManagementFeature = "Unsupported"
)

func (*RemoteVendorManagementFeature) UnmarshalJSON ¶ 

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

type RemoteVendorManagementStatus ¶ 

type RemoteVendorManagementStatus string
const (
	RemoteVendorManagementStatusDisabled    RemoteVendorManagementStatus = "Disabled"
	RemoteVendorManagementStatusEnabled     RemoteVendorManagementStatus = "Enabled"
	RemoteVendorManagementStatusUnsupported RemoteVendorManagementStatus = "Unsupported"
)

func (*RemoteVendorManagementStatus) UnmarshalJSON ¶ 

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

type ServiceLoadBalancerBgpPeer ¶ 

type ServiceLoadBalancerBgpPeer struct {
	BfdEnabled    *BfdEnabled  `json:"bfdEnabled,omitempty"`
	BgpMultiHop   *BgpMultiHop `json:"bgpMultiHop,omitempty"`
	HoldTime      *string      `json:"holdTime,omitempty"`
	KeepAliveTime *string      `json:"keepAliveTime,omitempty"`
	MyAsn         *int64       `json:"myAsn,omitempty"`
	Name          string       `json:"name"`
	Password      *string      `json:"password,omitempty"`
	PeerAddress   string       `json:"peerAddress"`
	PeerAsn       int64        `json:"peerAsn"`
	PeerPort      *int64       `json:"peerPort,omitempty"`
}

type ServicePrincipalInformation ¶ 

type ServicePrincipalInformation struct {
	ApplicationId string `json:"applicationId"`
	Password      string `json:"password"`
	PrincipalId   string `json:"principalId"`
	TenantId      string `json:"tenantId"`
}

type SkipShutdown ¶ 

type SkipShutdown string
const (
	SkipShutdownFalse SkipShutdown = "False"
	SkipShutdownTrue  SkipShutdown = "True"
)

func (*SkipShutdown) UnmarshalJSON ¶ 

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

type SshPublicKey ¶ 

type SshPublicKey struct {
	KeyData string `json:"keyData"`
}

type StorageAppliance ¶ 

type StorageAppliance struct {
	ExtendedLocation ExtendedLocation           `json:"extendedLocation"`
	Id               *string                    `json:"id,omitempty"`
	Location         string                     `json:"location"`
	Name             *string                    `json:"name,omitempty"`
	Properties       StorageApplianceProperties `json:"properties"`
	SystemData       *systemdata.SystemData     `json:"systemData,omitempty"`
	Tags             *map[string]string         `json:"tags,omitempty"`
	Type             *string                    `json:"type,omitempty"`
}

type StorageApplianceConfigurationData ¶ 

type StorageApplianceConfigurationData struct {
	AdminCredentials     AdministrativeCredentials `json:"adminCredentials"`
	RackSlot             int64                     `json:"rackSlot"`
	SerialNumber         string                    `json:"serialNumber"`
	StorageApplianceName *string                   `json:"storageApplianceName,omitempty"`
}

type StorageApplianceDetailedStatus ¶ 

type StorageApplianceDetailedStatus string
const (
	StorageApplianceDetailedStatusAvailable    StorageApplianceDetailedStatus = "Available"
	StorageApplianceDetailedStatusError        StorageApplianceDetailedStatus = "Error"
	StorageApplianceDetailedStatusProvisioning StorageApplianceDetailedStatus = "Provisioning"
)

func (*StorageApplianceDetailedStatus) UnmarshalJSON ¶ 

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

type StorageApplianceEnableRemoteVendorManagementParameters ¶ 

type StorageApplianceEnableRemoteVendorManagementParameters struct {
	SupportEndpoints *[]string `json:"supportEndpoints,omitempty"`
}

type StorageApplianceId ¶ 

type StorageApplianceId struct {
	SubscriptionId       string
	ResourceGroupName    string
	StorageApplianceName string
}

StorageApplianceId is a struct representing the Resource ID for a Storage Appliance

func NewStorageApplianceID ¶ 

func NewStorageApplianceID(subscriptionId string, resourceGroupName string, storageApplianceName string) StorageApplianceId

NewStorageApplianceID returns a new StorageApplianceId struct

func ParseStorageApplianceID ¶ 

func ParseStorageApplianceID(input string) (*StorageApplianceId, error)

ParseStorageApplianceID parses 'input' into a StorageApplianceId

func ParseStorageApplianceIDInsensitively ¶ 

func ParseStorageApplianceIDInsensitively(input string) (*StorageApplianceId, error)

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

func (*StorageApplianceId) FromParseResult ¶ 

func (id *StorageApplianceId) FromParseResult(input resourceids.ParseResult) error

func (StorageApplianceId) ID ¶ 

func (id StorageApplianceId) ID() string

ID returns the formatted Storage Appliance ID

func (StorageApplianceId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Storage Appliance ID

func (StorageApplianceId) String ¶ 

func (id StorageApplianceId) String() string

String returns a human-readable description of this Storage Appliance ID

type StorageApplianceOperationPredicate ¶ 

type StorageApplianceOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (StorageApplianceOperationPredicate) Matches ¶ 

func (p StorageApplianceOperationPredicate) Matches(input StorageAppliance) bool

type StorageAppliancePatchParameters ¶ 

type StorageAppliancePatchParameters struct {
	Properties *StorageAppliancePatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string               `json:"tags,omitempty"`
}

type StorageAppliancePatchProperties ¶ 

type StorageAppliancePatchProperties struct {
	SerialNumber *string `json:"serialNumber,omitempty"`
}

type StorageApplianceProperties ¶ 

type StorageApplianceProperties struct {
	AdministratorCredentials      AdministrativeCredentials          `json:"administratorCredentials"`
	Capacity                      *int64                             `json:"capacity,omitempty"`
	CapacityUsed                  *int64                             `json:"capacityUsed,omitempty"`
	ClusterId                     *string                            `json:"clusterId,omitempty"`
	DetailedStatus                *StorageApplianceDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage         *string                            `json:"detailedStatusMessage,omitempty"`
	ManagementIPv4Address         *string                            `json:"managementIpv4Address,omitempty"`
	ProvisioningState             *StorageApplianceProvisioningState `json:"provisioningState,omitempty"`
	RackId                        string                             `json:"rackId"`
	RackSlot                      int64                              `json:"rackSlot"`
	RemoteVendorManagementFeature *RemoteVendorManagementFeature     `json:"remoteVendorManagementFeature,omitempty"`
	RemoteVendorManagementStatus  *RemoteVendorManagementStatus      `json:"remoteVendorManagementStatus,omitempty"`
	SerialNumber                  string                             `json:"serialNumber"`
	StorageApplianceSkuId         string                             `json:"storageApplianceSkuId"`
}

type StorageApplianceProvisioningState ¶ 

type StorageApplianceProvisioningState string
const (
	StorageApplianceProvisioningStateAccepted     StorageApplianceProvisioningState = "Accepted"
	StorageApplianceProvisioningStateCanceled     StorageApplianceProvisioningState = "Canceled"
	StorageApplianceProvisioningStateFailed       StorageApplianceProvisioningState = "Failed"
	StorageApplianceProvisioningStateProvisioning StorageApplianceProvisioningState = "Provisioning"
	StorageApplianceProvisioningStateSucceeded    StorageApplianceProvisioningState = "Succeeded"
)

func (*StorageApplianceProvisioningState) UnmarshalJSON ¶ 

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

type StorageApplianceSkuProperties ¶ 

type StorageApplianceSkuProperties struct {
	CapacityGB *int64  `json:"capacityGB,omitempty"`
	Model      *string `json:"model,omitempty"`
}

type StorageApplianceSkuSlot ¶ 

type StorageApplianceSkuSlot struct {
	Properties *StorageApplianceSkuProperties `json:"properties,omitempty"`
	RackSlot   *int64                         `json:"rackSlot,omitempty"`
}

type StorageAppliancesCreateOrUpdateOperationResponse ¶ 

type StorageAppliancesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *StorageAppliance
}

type StorageAppliancesDeleteOperationResponse ¶ 

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

type StorageAppliancesDisableRemoteVendorManagementOperationResponse ¶ 

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

type StorageAppliancesEnableRemoteVendorManagementOperationResponse ¶ 

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

type StorageAppliancesGetOperationResponse ¶ 

type StorageAppliancesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *StorageAppliance
}

type StorageAppliancesListByResourceGroupCompleteResult ¶ 

type StorageAppliancesListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []StorageAppliance
}

type StorageAppliancesListByResourceGroupOperationResponse ¶ 

type StorageAppliancesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]StorageAppliance
}

type StorageAppliancesListBySubscriptionCompleteResult ¶ 

type StorageAppliancesListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []StorageAppliance
}

type StorageAppliancesListBySubscriptionOperationResponse ¶ 

type StorageAppliancesListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]StorageAppliance
}

type StorageAppliancesUpdateOperationResponse ¶ 

type StorageAppliancesUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *StorageAppliance
}

type StorageProfile ¶ 

type StorageProfile struct {
	OsDisk            OsDisk    `json:"osDisk"`
	VolumeAttachments *[]string `json:"volumeAttachments,omitempty"`
}

type TrunkedNetwork ¶ 

type TrunkedNetwork struct {
	ExtendedLocation ExtendedLocation         `json:"extendedLocation"`
	Id               *string                  `json:"id,omitempty"`
	Location         string                   `json:"location"`
	Name             *string                  `json:"name,omitempty"`
	Properties       TrunkedNetworkProperties `json:"properties"`
	SystemData       *systemdata.SystemData   `json:"systemData,omitempty"`
	Tags             *map[string]string       `json:"tags,omitempty"`
	Type             *string                  `json:"type,omitempty"`
}

type TrunkedNetworkAttachmentConfiguration ¶ 

type TrunkedNetworkAttachmentConfiguration struct {
	NetworkId  string                `json:"networkId"`
	PluginType *KubernetesPluginType `json:"pluginType,omitempty"`
}

type TrunkedNetworkDetailedStatus ¶ 

type TrunkedNetworkDetailedStatus string
const (
	TrunkedNetworkDetailedStatusAvailable    TrunkedNetworkDetailedStatus = "Available"
	TrunkedNetworkDetailedStatusError        TrunkedNetworkDetailedStatus = "Error"
	TrunkedNetworkDetailedStatusProvisioning TrunkedNetworkDetailedStatus = "Provisioning"
)

func (*TrunkedNetworkDetailedStatus) UnmarshalJSON ¶ 

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

type TrunkedNetworkId ¶ 

type TrunkedNetworkId struct {
	SubscriptionId     string
	ResourceGroupName  string
	TrunkedNetworkName string
}

TrunkedNetworkId is a struct representing the Resource ID for a Trunked Network

func NewTrunkedNetworkID ¶ 

func NewTrunkedNetworkID(subscriptionId string, resourceGroupName string, trunkedNetworkName string) TrunkedNetworkId

NewTrunkedNetworkID returns a new TrunkedNetworkId struct

func ParseTrunkedNetworkID ¶ 

func ParseTrunkedNetworkID(input string) (*TrunkedNetworkId, error)

ParseTrunkedNetworkID parses 'input' into a TrunkedNetworkId

func ParseTrunkedNetworkIDInsensitively ¶ 

func ParseTrunkedNetworkIDInsensitively(input string) (*TrunkedNetworkId, error)

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

func (*TrunkedNetworkId) FromParseResult ¶ 

func (id *TrunkedNetworkId) FromParseResult(input resourceids.ParseResult) error

func (TrunkedNetworkId) ID ¶ 

func (id TrunkedNetworkId) ID() string

ID returns the formatted Trunked Network ID

func (TrunkedNetworkId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Trunked Network ID

func (TrunkedNetworkId) String ¶ 

func (id TrunkedNetworkId) String() string

String returns a human-readable description of this Trunked Network ID

type TrunkedNetworkOperationPredicate ¶ 

type TrunkedNetworkOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (TrunkedNetworkOperationPredicate) Matches ¶ 

func (p TrunkedNetworkOperationPredicate) Matches(input TrunkedNetwork) bool

type TrunkedNetworkPatchParameters ¶ 

type TrunkedNetworkPatchParameters struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

type TrunkedNetworkProperties ¶ 

type TrunkedNetworkProperties struct {
	AssociatedResourceIds          *[]string                        `json:"associatedResourceIds,omitempty"`
	ClusterId                      *string                          `json:"clusterId,omitempty"`
	DetailedStatus                 *TrunkedNetworkDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage          *string                          `json:"detailedStatusMessage,omitempty"`
	HybridAksClustersAssociatedIds *[]string                        `json:"hybridAksClustersAssociatedIds,omitempty"`
	HybridAksPluginType            *HybridAksPluginType             `json:"hybridAksPluginType,omitempty"`
	InterfaceName                  *string                          `json:"interfaceName,omitempty"`
	IsolationDomainIds             []string                         `json:"isolationDomainIds"`
	ProvisioningState              *TrunkedNetworkProvisioningState `json:"provisioningState,omitempty"`
	VirtualMachinesAssociatedIds   *[]string                        `json:"virtualMachinesAssociatedIds,omitempty"`
	Vlans                          []int64                          `json:"vlans"`
}

type TrunkedNetworkProvisioningState ¶ 

type TrunkedNetworkProvisioningState string
const (
	TrunkedNetworkProvisioningStateAccepted     TrunkedNetworkProvisioningState = "Accepted"
	TrunkedNetworkProvisioningStateCanceled     TrunkedNetworkProvisioningState = "Canceled"
	TrunkedNetworkProvisioningStateFailed       TrunkedNetworkProvisioningState = "Failed"
	TrunkedNetworkProvisioningStateProvisioning TrunkedNetworkProvisioningState = "Provisioning"
	TrunkedNetworkProvisioningStateSucceeded    TrunkedNetworkProvisioningState = "Succeeded"
)

func (*TrunkedNetworkProvisioningState) UnmarshalJSON ¶ 

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

type TrunkedNetworksCreateOrUpdateOperationResponse ¶ 

type TrunkedNetworksCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *TrunkedNetwork
}

type TrunkedNetworksDeleteOperationResponse ¶ 

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

type TrunkedNetworksGetOperationResponse ¶ 

type TrunkedNetworksGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *TrunkedNetwork
}

type TrunkedNetworksListByResourceGroupCompleteResult ¶ 

type TrunkedNetworksListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []TrunkedNetwork
}

type TrunkedNetworksListByResourceGroupOperationResponse ¶ 

type TrunkedNetworksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]TrunkedNetwork
}

type TrunkedNetworksListBySubscriptionCompleteResult ¶ 

type TrunkedNetworksListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []TrunkedNetwork
}

type TrunkedNetworksListBySubscriptionOperationResponse ¶ 

type TrunkedNetworksListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]TrunkedNetwork
}

type TrunkedNetworksUpdateOperationResponse ¶ 

type TrunkedNetworksUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *TrunkedNetwork
}

type ValidationThreshold ¶ 

type ValidationThreshold struct {
	Grouping ValidationThresholdGrouping `json:"grouping"`
	Type     ValidationThresholdType     `json:"type"`
	Value    int64                       `json:"value"`
}

type ValidationThresholdGrouping ¶ 

type ValidationThresholdGrouping string
const (
	ValidationThresholdGroupingPerCluster ValidationThresholdGrouping = "PerCluster"
	ValidationThresholdGroupingPerRack    ValidationThresholdGrouping = "PerRack"
)

func (*ValidationThresholdGrouping) UnmarshalJSON ¶ 

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

type ValidationThresholdType ¶ 

type ValidationThresholdType string
const (
	ValidationThresholdTypeCountSuccess   ValidationThresholdType = "CountSuccess"
	ValidationThresholdTypePercentSuccess ValidationThresholdType = "PercentSuccess"
)

func (*ValidationThresholdType) UnmarshalJSON ¶ 

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

type VirtualMachine ¶ 

type VirtualMachine struct {
	ExtendedLocation ExtendedLocation         `json:"extendedLocation"`
	Id               *string                  `json:"id,omitempty"`
	Location         string                   `json:"location"`
	Name             *string                  `json:"name,omitempty"`
	Properties       VirtualMachineProperties `json:"properties"`
	SystemData       *systemdata.SystemData   `json:"systemData,omitempty"`
	Tags             *map[string]string       `json:"tags,omitempty"`
	Type             *string                  `json:"type,omitempty"`
}

type VirtualMachineBootMethod ¶ 

type VirtualMachineBootMethod string
const (
	VirtualMachineBootMethodBIOS VirtualMachineBootMethod = "BIOS"
	VirtualMachineBootMethodUEFI VirtualMachineBootMethod = "UEFI"
)

func (*VirtualMachineBootMethod) UnmarshalJSON ¶ 

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

type VirtualMachineDetailedStatus ¶ 

type VirtualMachineDetailedStatus string
const (
	VirtualMachineDetailedStatusAvailable    VirtualMachineDetailedStatus = "Available"
	VirtualMachineDetailedStatusError        VirtualMachineDetailedStatus = "Error"
	VirtualMachineDetailedStatusProvisioning VirtualMachineDetailedStatus = "Provisioning"
	VirtualMachineDetailedStatusRunning      VirtualMachineDetailedStatus = "Running"
	VirtualMachineDetailedStatusScheduling   VirtualMachineDetailedStatus = "Scheduling"
	VirtualMachineDetailedStatusStopped      VirtualMachineDetailedStatus = "Stopped"
	VirtualMachineDetailedStatusTerminating  VirtualMachineDetailedStatus = "Terminating"
	VirtualMachineDetailedStatusUnknown      VirtualMachineDetailedStatus = "Unknown"
)

func (*VirtualMachineDetailedStatus) UnmarshalJSON ¶ 

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

type VirtualMachineDeviceModelType ¶ 

type VirtualMachineDeviceModelType string
const (
	VirtualMachineDeviceModelTypeTOne VirtualMachineDeviceModelType = "T1"
	VirtualMachineDeviceModelTypeTTwo VirtualMachineDeviceModelType = "T2"
)

func (*VirtualMachineDeviceModelType) UnmarshalJSON ¶ 

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

type VirtualMachineIPAllocationMethod ¶ 

type VirtualMachineIPAllocationMethod string
const (
	VirtualMachineIPAllocationMethodDisabled VirtualMachineIPAllocationMethod = "Disabled"
	VirtualMachineIPAllocationMethodDynamic  VirtualMachineIPAllocationMethod = "Dynamic"
	VirtualMachineIPAllocationMethodStatic   VirtualMachineIPAllocationMethod = "Static"
)

func (*VirtualMachineIPAllocationMethod) UnmarshalJSON ¶ 

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

type VirtualMachineId ¶ 

type VirtualMachineId struct {
	SubscriptionId     string
	ResourceGroupName  string
	VirtualMachineName string
}

VirtualMachineId is a struct representing the Resource ID for a Virtual Machine

func NewVirtualMachineID ¶ 

func NewVirtualMachineID(subscriptionId string, resourceGroupName string, virtualMachineName string) VirtualMachineId

NewVirtualMachineID returns a new VirtualMachineId struct

func ParseVirtualMachineID ¶ 

func ParseVirtualMachineID(input string) (*VirtualMachineId, error)

ParseVirtualMachineID parses 'input' into a VirtualMachineId

func ParseVirtualMachineIDInsensitively ¶ 

func ParseVirtualMachineIDInsensitively(input string) (*VirtualMachineId, error)

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

func (*VirtualMachineId) FromParseResult ¶ 

func (id *VirtualMachineId) FromParseResult(input resourceids.ParseResult) error

func (VirtualMachineId) ID ¶ 

func (id VirtualMachineId) ID() string

ID returns the formatted Virtual Machine ID

func (VirtualMachineId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Virtual Machine ID

func (VirtualMachineId) String ¶ 

func (id VirtualMachineId) String() string

String returns a human-readable description of this Virtual Machine ID

type VirtualMachineIsolateEmulatorThread ¶ 

type VirtualMachineIsolateEmulatorThread string
const (
	VirtualMachineIsolateEmulatorThreadFalse VirtualMachineIsolateEmulatorThread = "False"
	VirtualMachineIsolateEmulatorThreadTrue  VirtualMachineIsolateEmulatorThread = "True"
)

func (*VirtualMachineIsolateEmulatorThread) UnmarshalJSON ¶ 

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

type VirtualMachineOperationPredicate ¶ 

type VirtualMachineOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (VirtualMachineOperationPredicate) Matches ¶ 

func (p VirtualMachineOperationPredicate) Matches(input VirtualMachine) bool

type VirtualMachinePatchParameters ¶ 

type VirtualMachinePatchParameters struct {
	Properties *VirtualMachinePatchProperties `json:"properties,omitempty"`
	Tags       *map[string]string             `json:"tags,omitempty"`
}

type VirtualMachinePatchProperties ¶ 

type VirtualMachinePatchProperties struct {
	VMImageRepositoryCredentials *ImageRepositoryCredentials `json:"vmImageRepositoryCredentials,omitempty"`
}

type VirtualMachinePlacementHint ¶ 

type VirtualMachinePlacementHint struct {
	HintType            VirtualMachinePlacementHintType             `json:"hintType"`
	ResourceId          string                                      `json:"resourceId"`
	SchedulingExecution VirtualMachineSchedulingExecution           `json:"schedulingExecution"`
	Scope               VirtualMachinePlacementHintPodAffinityScope `json:"scope"`
}

type VirtualMachinePlacementHintPodAffinityScope ¶ 

type VirtualMachinePlacementHintPodAffinityScope string
const (
	VirtualMachinePlacementHintPodAffinityScopeMachine VirtualMachinePlacementHintPodAffinityScope = "Machine"
	VirtualMachinePlacementHintPodAffinityScopeRack    VirtualMachinePlacementHintPodAffinityScope = "Rack"
)

func (*VirtualMachinePlacementHintPodAffinityScope) UnmarshalJSON ¶ 

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

type VirtualMachinePlacementHintType ¶ 

type VirtualMachinePlacementHintType string
const (
	VirtualMachinePlacementHintTypeAffinity     VirtualMachinePlacementHintType = "Affinity"
	VirtualMachinePlacementHintTypeAntiAffinity VirtualMachinePlacementHintType = "AntiAffinity"
)

func (*VirtualMachinePlacementHintType) UnmarshalJSON ¶ 

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

type VirtualMachinePowerOffParameters ¶ 

type VirtualMachinePowerOffParameters struct {
	SkipShutdown *SkipShutdown `json:"skipShutdown,omitempty"`
}

type VirtualMachinePowerState ¶ 

type VirtualMachinePowerState string
const (
	VirtualMachinePowerStateOff     VirtualMachinePowerState = "Off"
	VirtualMachinePowerStateOn      VirtualMachinePowerState = "On"
	VirtualMachinePowerStateUnknown VirtualMachinePowerState = "Unknown"
)

func (*VirtualMachinePowerState) UnmarshalJSON ¶ 

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

type VirtualMachineProperties ¶ 

type VirtualMachineProperties struct {
	AdminUsername                  string                               `json:"adminUsername"`
	AvailabilityZone               *string                              `json:"availabilityZone,omitempty"`
	BareMetalMachineId             *string                              `json:"bareMetalMachineId,omitempty"`
	BootMethod                     *VirtualMachineBootMethod            `json:"bootMethod,omitempty"`
	CloudServicesNetworkAttachment NetworkAttachment                    `json:"cloudServicesNetworkAttachment"`
	ClusterId                      *string                              `json:"clusterId,omitempty"`
	CpuCores                       int64                                `json:"cpuCores"`
	DetailedStatus                 *VirtualMachineDetailedStatus        `json:"detailedStatus,omitempty"`
	DetailedStatusMessage          *string                              `json:"detailedStatusMessage,omitempty"`
	IsolateEmulatorThread          *VirtualMachineIsolateEmulatorThread `json:"isolateEmulatorThread,omitempty"`
	MemorySizeGB                   int64                                `json:"memorySizeGB"`
	NetworkAttachments             *[]NetworkAttachment                 `json:"networkAttachments,omitempty"`
	NetworkData                    *string                              `json:"networkData,omitempty"`
	PlacementHints                 *[]VirtualMachinePlacementHint       `json:"placementHints,omitempty"`
	PowerState                     *VirtualMachinePowerState            `json:"powerState,omitempty"`
	ProvisioningState              *VirtualMachineProvisioningState     `json:"provisioningState,omitempty"`
	SshPublicKeys                  *[]SshPublicKey                      `json:"sshPublicKeys,omitempty"`
	StorageProfile                 StorageProfile                       `json:"storageProfile"`
	UserData                       *string                              `json:"userData,omitempty"`
	VMDeviceModel                  *VirtualMachineDeviceModelType       `json:"vmDeviceModel,omitempty"`
	VMImageRepositoryCredentials   *ImageRepositoryCredentials          `json:"vmImageRepositoryCredentials,omitempty"`
	VirtioInterface                *VirtualMachineVirtioInterfaceType   `json:"virtioInterface,omitempty"`
	VmImage                        string                               `json:"vmImage"`
	Volumes                        *[]string                            `json:"volumes,omitempty"`
}

type VirtualMachineProvisioningState ¶ 

type VirtualMachineProvisioningState string
const (
	VirtualMachineProvisioningStateAccepted     VirtualMachineProvisioningState = "Accepted"
	VirtualMachineProvisioningStateCanceled     VirtualMachineProvisioningState = "Canceled"
	VirtualMachineProvisioningStateFailed       VirtualMachineProvisioningState = "Failed"
	VirtualMachineProvisioningStateProvisioning VirtualMachineProvisioningState = "Provisioning"
	VirtualMachineProvisioningStateSucceeded    VirtualMachineProvisioningState = "Succeeded"
)

func (*VirtualMachineProvisioningState) UnmarshalJSON ¶ 

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

type VirtualMachineSchedulingExecution ¶ 

type VirtualMachineSchedulingExecution string
const (
	VirtualMachineSchedulingExecutionHard VirtualMachineSchedulingExecution = "Hard"
	VirtualMachineSchedulingExecutionSoft VirtualMachineSchedulingExecution = "Soft"
)

func (*VirtualMachineSchedulingExecution) UnmarshalJSON ¶ 

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

type VirtualMachineVirtioInterfaceType ¶ 

type VirtualMachineVirtioInterfaceType string
const (
	VirtualMachineVirtioInterfaceTypeModern       VirtualMachineVirtioInterfaceType = "Modern"
	VirtualMachineVirtioInterfaceTypeTransitional VirtualMachineVirtioInterfaceType = "Transitional"
)

func (*VirtualMachineVirtioInterfaceType) UnmarshalJSON ¶ 

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

type VirtualMachinesCreateOrUpdateOperationResponse ¶ 

type VirtualMachinesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualMachine
}

type VirtualMachinesDeleteOperationResponse ¶ 

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

type VirtualMachinesGetOperationResponse ¶ 

type VirtualMachinesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualMachine
}

type VirtualMachinesListByResourceGroupCompleteResult ¶ 

type VirtualMachinesListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualMachine
}

type VirtualMachinesListByResourceGroupOperationResponse ¶ 

type VirtualMachinesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualMachine
}

type VirtualMachinesListBySubscriptionCompleteResult ¶ 

type VirtualMachinesListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []VirtualMachine
}

type VirtualMachinesListBySubscriptionOperationResponse ¶ 

type VirtualMachinesListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualMachine
}

type VirtualMachinesPowerOffOperationResponse ¶ 

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

type VirtualMachinesReimageOperationResponse ¶ 

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

type VirtualMachinesRestartOperationResponse ¶ 

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

type VirtualMachinesStartOperationResponse ¶ 

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

type VirtualMachinesUpdateOperationResponse ¶ 

type VirtualMachinesUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *VirtualMachine
}

type Volume ¶ 

type Volume struct {
	ExtendedLocation ExtendedLocation       `json:"extendedLocation"`
	Id               *string                `json:"id,omitempty"`
	Location         string                 `json:"location"`
	Name             *string                `json:"name,omitempty"`
	Properties       VolumeProperties       `json:"properties"`
	SystemData       *systemdata.SystemData `json:"systemData,omitempty"`
	Tags             *map[string]string     `json:"tags,omitempty"`
	Type             *string                `json:"type,omitempty"`
}

type VolumeDetailedStatus ¶ 

type VolumeDetailedStatus string
const (
	VolumeDetailedStatusActive       VolumeDetailedStatus = "Active"
	VolumeDetailedStatusError        VolumeDetailedStatus = "Error"
	VolumeDetailedStatusProvisioning VolumeDetailedStatus = "Provisioning"
)

func (*VolumeDetailedStatus) UnmarshalJSON ¶ 

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

type VolumeId ¶ 

type VolumeId struct {
	SubscriptionId    string
	ResourceGroupName string
	VolumeName        string
}

VolumeId is a struct representing the Resource ID for a Volume

func NewVolumeID ¶ 

func NewVolumeID(subscriptionId string, resourceGroupName string, volumeName string) VolumeId

NewVolumeID returns a new VolumeId struct

func ParseVolumeID ¶ 

func ParseVolumeID(input string) (*VolumeId, error)

ParseVolumeID parses 'input' into a VolumeId

func ParseVolumeIDInsensitively ¶ 

func ParseVolumeIDInsensitively(input string) (*VolumeId, error)

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

func (*VolumeId) FromParseResult ¶ 

func (id *VolumeId) FromParseResult(input resourceids.ParseResult) error

func (VolumeId) ID ¶ 

func (id VolumeId) ID() string

ID returns the formatted Volume ID

func (VolumeId) Segments ¶ 

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

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

func (VolumeId) String ¶ 

func (id VolumeId) String() string

String returns a human-readable description of this Volume ID

type VolumeOperationPredicate ¶ 

type VolumeOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (VolumeOperationPredicate) Matches ¶ 

func (p VolumeOperationPredicate) Matches(input Volume) bool

type VolumePatchParameters ¶ 

type VolumePatchParameters struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

type VolumeProperties ¶ 

type VolumeProperties struct {
	AttachedTo            *[]string                `json:"attachedTo,omitempty"`
	DetailedStatus        *VolumeDetailedStatus    `json:"detailedStatus,omitempty"`
	DetailedStatusMessage *string                  `json:"detailedStatusMessage,omitempty"`
	ProvisioningState     *VolumeProvisioningState `json:"provisioningState,omitempty"`
	SerialNumber          *string                  `json:"serialNumber,omitempty"`
	SizeMiB               int64                    `json:"sizeMiB"`
}

type VolumeProvisioningState ¶ 

type VolumeProvisioningState string
const (
	VolumeProvisioningStateAccepted     VolumeProvisioningState = "Accepted"
	VolumeProvisioningStateCanceled     VolumeProvisioningState = "Canceled"
	VolumeProvisioningStateFailed       VolumeProvisioningState = "Failed"
	VolumeProvisioningStateProvisioning VolumeProvisioningState = "Provisioning"
	VolumeProvisioningStateSucceeded    VolumeProvisioningState = "Succeeded"
)

func (*VolumeProvisioningState) UnmarshalJSON ¶ 

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

type VolumesCreateOrUpdateOperationResponse ¶ 

type VolumesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Volume
}

type VolumesDeleteOperationResponse ¶ 

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

type VolumesGetOperationResponse ¶ 

type VolumesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Volume
}

type VolumesListByResourceGroupCompleteResult ¶ 

type VolumesListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Volume
}

type VolumesListByResourceGroupOperationResponse ¶ 

type VolumesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Volume
}

type VolumesListBySubscriptionCompleteResult ¶ 

type VolumesListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Volume
}

type VolumesListBySubscriptionOperationResponse ¶ 

type VolumesListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Volume
}

type VolumesUpdateOperationResponse ¶ 

type VolumesUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Volume
}

type WorkloadImpact ¶ 

type WorkloadImpact string
const (
	WorkloadImpactFalse WorkloadImpact = "False"
	WorkloadImpactTrue  WorkloadImpact = "True"
)

func (*WorkloadImpact) UnmarshalJSON ¶ 

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

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

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