networkclouds

package
v0.20230915.1163220 Latest Latest
Warning

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

Go to latest
Published: Sep 15, 2023 License: MPL-2.0 Imports: 16 Imported by: 1

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-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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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 := networkclouds.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) 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
}

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 {
	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
}

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

ID returns the formatted Bare Metal Machine Key Set ID

func (BareMetalMachineKeySetId) Segments ¶

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 ¶

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
}

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 {
	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
}

type BareMetalMachineOperationPredicate ¶

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

func (BareMetalMachineOperationPredicate) Matches ¶

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
}

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 {
	Items []BareMetalMachine
}

type BareMetalMachinesListByResourceGroupOperationResponse ¶

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

type BareMetalMachinesListBySubscriptionCompleteResult ¶

type BareMetalMachinesListBySubscriptionCompleteResult struct {
	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
}

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) 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
}

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 {
	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
}

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 ¶

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

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 ¶

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
}

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 {
	Items []CloudServicesNetwork
}

type CloudServicesNetworksListByResourceGroupOperationResponse ¶

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

type CloudServicesNetworksListBySubscriptionCompleteResult ¶

type CloudServicesNetworksListBySubscriptionCompleteResult struct {
	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
}

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

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
}

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 {
	Items []ClusterManager
}

type ClusterManagersListByResourceGroupOperationResponse ¶

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

type ClusterManagersListBySubscriptionCompleteResult ¶

type ClusterManagersListBySubscriptionCompleteResult struct {
	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 ¶

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
}

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 {
	Items []Cluster
}

type ClustersListByResourceGroupOperationResponse ¶

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

type ClustersListBySubscriptionCompleteResult ¶

type ClustersListBySubscriptionCompleteResult struct {
	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
}

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) 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
}

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 {
	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
}

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

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
}

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 {
	Items []KubernetesCluster
}

type KubernetesClustersListByResourceGroupOperationResponse ¶

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

type KubernetesClustersListBySubscriptionCompleteResult ¶

type KubernetesClustersListBySubscriptionCompleteResult struct {
	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
}

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) 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
}

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 {
	Items []L2Network
}

type L2NetworksListByResourceGroupOperationResponse ¶

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

type L2NetworksListBySubscriptionCompleteResult ¶

type L2NetworksListBySubscriptionCompleteResult struct {
	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) 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
}

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 {
	Items []L3Network
}

type L3NetworksListByResourceGroupOperationResponse ¶

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

type L3NetworksListBySubscriptionCompleteResult ¶

type L3NetworksListBySubscriptionCompleteResult struct {
	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) ID ¶

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
}

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 {
	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
}

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

BareMetalMachinesGet ...

func (NetworkcloudsClient) BareMetalMachinesListByResourceGroup ¶

func (c NetworkcloudsClient) BareMetalMachinesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result BareMetalMachinesListByResourceGroupOperationResponse, err error)

BareMetalMachinesListByResourceGroup ...

func (NetworkcloudsClient) BareMetalMachinesListByResourceGroupComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

ClusterManagersGet ...

func (NetworkcloudsClient) ClusterManagersListByResourceGroup ¶

ClusterManagersListByResourceGroup ...

func (NetworkcloudsClient) ClusterManagersListByResourceGroupComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

ClustersListByResourceGroup ...

func (NetworkcloudsClient) ClustersListByResourceGroupComplete ¶

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 ¶

ClustersListBySubscription ...

func (NetworkcloudsClient) ClustersListBySubscriptionComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

KubernetesClustersGet ...

func (NetworkcloudsClient) KubernetesClustersListByResourceGroup ¶

func (c NetworkcloudsClient) KubernetesClustersListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result KubernetesClustersListByResourceGroupOperationResponse, err error)

KubernetesClustersListByResourceGroup ...

func (NetworkcloudsClient) KubernetesClustersListByResourceGroupComplete ¶

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 ¶

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 ¶

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 ¶

L2NetworksListByResourceGroup ...

func (NetworkcloudsClient) L2NetworksListByResourceGroupComplete ¶

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 ¶

L2NetworksListBySubscription ...

func (NetworkcloudsClient) L2NetworksListBySubscriptionComplete ¶

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 ¶

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 ¶

L3NetworksListByResourceGroup ...

func (NetworkcloudsClient) L3NetworksListByResourceGroupComplete ¶

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 ¶

L3NetworksListBySubscription ...

func (NetworkcloudsClient) L3NetworksListBySubscriptionComplete ¶

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 ¶

L3NetworksUpdate ...

func (NetworkcloudsClient) MetricsConfigurationsCreateOrUpdate ¶

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 ¶

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 ¶

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 ¶

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 ¶

RackSkusListBySubscription ...

func (NetworkcloudsClient) RackSkusListBySubscriptionComplete ¶

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 ¶

RacksListByResourceGroup ...

func (NetworkcloudsClient) RacksListByResourceGroupComplete ¶

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 ¶

RacksListBySubscription ...

func (NetworkcloudsClient) RacksListBySubscriptionComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

StorageAppliancesGet ...

func (NetworkcloudsClient) StorageAppliancesListByResourceGroup ¶

func (c NetworkcloudsClient) StorageAppliancesListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result StorageAppliancesListByResourceGroupOperationResponse, err error)

StorageAppliancesListByResourceGroup ...

func (NetworkcloudsClient) StorageAppliancesListByResourceGroupComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

TrunkedNetworksGet ...

func (NetworkcloudsClient) TrunkedNetworksListByResourceGroup ¶

TrunkedNetworksListByResourceGroup ...

func (NetworkcloudsClient) TrunkedNetworksListByResourceGroupComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

VirtualMachinesGet ...

func (NetworkcloudsClient) VirtualMachinesListByResourceGroup ¶

VirtualMachinesListByResourceGroup ...

func (NetworkcloudsClient) VirtualMachinesListByResourceGroupComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

VolumesListByResourceGroup ...

func (NetworkcloudsClient) VolumesListByResourceGroupComplete ¶

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 ¶

VolumesListBySubscription ...

func (NetworkcloudsClient) VolumesListBySubscriptionComplete ¶

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 ¶

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) 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) 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 {
	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
}

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 {
	Items []Rack
}

type RacksListByResourceGroupOperationResponse ¶

type RacksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Rack
}

type RacksListBySubscriptionCompleteResult ¶

type RacksListBySubscriptionCompleteResult struct {
	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
}

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

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
}

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 {
	Items []StorageAppliance
}

type StorageAppliancesListByResourceGroupOperationResponse ¶

type StorageAppliancesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]StorageAppliance
}

type StorageAppliancesListBySubscriptionCompleteResult ¶

type StorageAppliancesListBySubscriptionCompleteResult struct {
	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
}

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

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
}

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 {
	Items []TrunkedNetwork
}

type TrunkedNetworksListByResourceGroupOperationResponse ¶

type TrunkedNetworksListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]TrunkedNetwork
}

type TrunkedNetworksListBySubscriptionCompleteResult ¶

type TrunkedNetworksListBySubscriptionCompleteResult struct {
	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) 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 ¶

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
}

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 {
	Items []VirtualMachine
}

type VirtualMachinesListByResourceGroupOperationResponse ¶

type VirtualMachinesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]VirtualMachine
}

type VirtualMachinesListBySubscriptionCompleteResult ¶

type VirtualMachinesListBySubscriptionCompleteResult struct {
	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
}

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) 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
}

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 {
	Items []Volume
}

type VolumesListByResourceGroupOperationResponse ¶

type VolumesListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Volume
}

type VolumesListBySubscriptionCompleteResult ¶

type VolumesListBySubscriptionCompleteResult struct {
	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 ¶

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL