Merge pull request #1013 from hashicorp/auto-pr/86a67fe1

Auto PR: Regenerating the Go SDK (dbf7e82)

resource-manager/elasticsan/2024-05-01/client.go

@@ -0,0 +1,91 @@
+package v2024_05_01
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/elasticsan"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/elasticsans"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/elasticsanskus"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/privateendpointconnections"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/privatelinkresources"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/snapshots"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/volumegroups"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/volumes"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
+	sdkEnv "github.com/hashicorp/go-azure-sdk/sdk/environments"
+)
+
+type Client struct {
+	ElasticSan                 *elasticsan.ElasticSanClient
+	ElasticSanSkus             *elasticsanskus.ElasticSanSkusClient
+	ElasticSans                *elasticsans.ElasticSansClient
+	PrivateEndpointConnections *privateendpointconnections.PrivateEndpointConnectionsClient
+	PrivateLinkResources       *privatelinkresources.PrivateLinkResourcesClient
+	Snapshots                  *snapshots.SnapshotsClient
+	VolumeGroups               *volumegroups.VolumeGroupsClient
+	Volumes                    *volumes.VolumesClient
+}
+
+func NewClientWithBaseURI(sdkApi sdkEnv.Api, configureFunc func(c *resourcemanager.Client)) (*Client, error) {
+	elasticSanClient, err := elasticsan.NewElasticSanClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building ElasticSan client: %+v", err)
+	}
+	configureFunc(elasticSanClient.Client)
+
+	elasticSanSkusClient, err := elasticsanskus.NewElasticSanSkusClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building ElasticSanSkus client: %+v", err)
+	}
+	configureFunc(elasticSanSkusClient.Client)
+
+	elasticSansClient, err := elasticsans.NewElasticSansClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building ElasticSans client: %+v", err)
+	}
+	configureFunc(elasticSansClient.Client)
+
+	privateEndpointConnectionsClient, err := privateendpointconnections.NewPrivateEndpointConnectionsClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building PrivateEndpointConnections client: %+v", err)
+	}
+	configureFunc(privateEndpointConnectionsClient.Client)
+
+	privateLinkResourcesClient, err := privatelinkresources.NewPrivateLinkResourcesClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building PrivateLinkResources client: %+v", err)
+	}
+	configureFunc(privateLinkResourcesClient.Client)
+
+	snapshotsClient, err := snapshots.NewSnapshotsClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building Snapshots client: %+v", err)
+	}
+	configureFunc(snapshotsClient.Client)
+
+	volumeGroupsClient, err := volumegroups.NewVolumeGroupsClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building VolumeGroups client: %+v", err)
+	}
+	configureFunc(volumeGroupsClient.Client)
+
+	volumesClient, err := volumes.NewVolumesClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building Volumes client: %+v", err)
+	}
+	configureFunc(volumesClient.Client)
+
+	return &Client{
+		ElasticSan:                 elasticSanClient,
+		ElasticSanSkus:             elasticSanSkusClient,
+		ElasticSans:                elasticSansClient,
+		PrivateEndpointConnections: privateEndpointConnectionsClient,
+		PrivateLinkResources:       privateLinkResourcesClient,
+		Snapshots:                  snapshotsClient,
+		VolumeGroups:               volumeGroupsClient,
+		Volumes:                    volumesClient,
+	}, nil
+}

resource-manager/elasticsan/2024-05-01/elasticsan/README.md

@@ -0,0 +1,38 @@
+
+## `github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/elasticsan` Documentation
+
+The `elasticsan` SDK allows for interaction with the Azure Resource Manager Service `elasticsan` (API Version `2024-05-01`).
+
+This readme covers example usages, but further information on [using this SDK can be found in the project root](https://github.com/hashicorp/go-azure-sdk/tree/main/docs).
+
+### Import Path
+
+```go
+import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+import "github.com/hashicorp/go-azure-sdk/resource-manager/elasticsan/2024-05-01/elasticsan"
+```
+
+
+### Client Initialization
+
+```go
+client := elasticsan.NewElasticSanClientWithBaseURI("https://management.azure.com")
+client.Client.Authorizer = authorizer
+```
+
+
+### Example Usage: `ElasticSanClient.ListByResourceGroup`
+
+```go
+ctx := context.TODO()
+id := commonids.NewResourceGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group")
+
+// alternatively `client.ListByResourceGroup(ctx, id)` can be used to do batched pagination
+items, err := client.ListByResourceGroupComplete(ctx, id)
+if err != nil {
+	// handle the error
+}
+for _, item := range items {
+	// do something
+}
+```

resource-manager/elasticsan/2024-05-01/elasticsan/client.go

@@ -0,0 +1,26 @@
+package elasticsan
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
+	sdkEnv "github.com/hashicorp/go-azure-sdk/sdk/environments"
+)
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type ElasticSanClient struct {
+	Client *resourcemanager.Client
+}
+
+func NewElasticSanClientWithBaseURI(sdkApi sdkEnv.Api) (*ElasticSanClient, error) {
+	client, err := resourcemanager.NewResourceManagerClient(sdkApi, "elasticsan", defaultApiVersion)
+	if err != nil {
+		return nil, fmt.Errorf("instantiating ElasticSanClient: %+v", err)
+	}
+
+	return &ElasticSanClient{
+		Client: client,
+	}, nil
+}

resource-manager/elasticsan/2024-05-01/elasticsan/constants.go

@@ -0,0 +1,236 @@
+package elasticsan
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type PrivateEndpointServiceConnectionStatus string
+
+const (
+	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
+	PrivateEndpointServiceConnectionStatusFailed   PrivateEndpointServiceConnectionStatus = "Failed"
+	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = "Pending"
+	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
+)
+
+func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string {
+	return []string{
+		string(PrivateEndpointServiceConnectionStatusApproved),
+		string(PrivateEndpointServiceConnectionStatusFailed),
+		string(PrivateEndpointServiceConnectionStatusPending),
+		string(PrivateEndpointServiceConnectionStatusRejected),
+	}
+}
+
+func (s *PrivateEndpointServiceConnectionStatus) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parsePrivateEndpointServiceConnectionStatus(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
+func parsePrivateEndpointServiceConnectionStatus(input string) (*PrivateEndpointServiceConnectionStatus, error) {
+	vals := map[string]PrivateEndpointServiceConnectionStatus{
+		"approved": PrivateEndpointServiceConnectionStatusApproved,
+		"failed":   PrivateEndpointServiceConnectionStatusFailed,
+		"pending":  PrivateEndpointServiceConnectionStatusPending,
+		"rejected": PrivateEndpointServiceConnectionStatusRejected,
+	}
+	if v, ok := vals[strings.ToLower(input)]; ok {
+		return &v, nil
+	}
+
+	// otherwise presume it's an undefined value and best-effort it
+	out := PrivateEndpointServiceConnectionStatus(input)
+	return &out, nil
+}
+
+type ProvisioningStates string
+
+const (
+	ProvisioningStatesCanceled  ProvisioningStates = "Canceled"
+	ProvisioningStatesCreating  ProvisioningStates = "Creating"
+	ProvisioningStatesDeleting  ProvisioningStates = "Deleting"
+	ProvisioningStatesFailed    ProvisioningStates = "Failed"
+	ProvisioningStatesInvalid   ProvisioningStates = "Invalid"
+	ProvisioningStatesPending   ProvisioningStates = "Pending"
+	ProvisioningStatesSucceeded ProvisioningStates = "Succeeded"
+	ProvisioningStatesUpdating  ProvisioningStates = "Updating"
+)
+
+func PossibleValuesForProvisioningStates() []string {
+	return []string{
+		string(ProvisioningStatesCanceled),
+		string(ProvisioningStatesCreating),
+		string(ProvisioningStatesDeleting),
+		string(ProvisioningStatesFailed),
+		string(ProvisioningStatesInvalid),
+		string(ProvisioningStatesPending),
+		string(ProvisioningStatesSucceeded),
+		string(ProvisioningStatesUpdating),
+	}
+}
+
+func (s *ProvisioningStates) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseProvisioningStates(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
+func parseProvisioningStates(input string) (*ProvisioningStates, error) {
+	vals := map[string]ProvisioningStates{
+		"canceled":  ProvisioningStatesCanceled,
+		"creating":  ProvisioningStatesCreating,
+		"deleting":  ProvisioningStatesDeleting,
+		"failed":    ProvisioningStatesFailed,
+		"invalid":   ProvisioningStatesInvalid,
+		"pending":   ProvisioningStatesPending,
+		"succeeded": ProvisioningStatesSucceeded,
+		"updating":  ProvisioningStatesUpdating,
+	}
+	if v, ok := vals[strings.ToLower(input)]; ok {
+		return &v, nil
+	}
+
+	// otherwise presume it's an undefined value and best-effort it
+	out := ProvisioningStates(input)
+	return &out, nil
+}
+
+type PublicNetworkAccess string
+
+const (
+	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
+	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
+)
+
+func PossibleValuesForPublicNetworkAccess() []string {
+	return []string{
+		string(PublicNetworkAccessDisabled),
+		string(PublicNetworkAccessEnabled),
+	}
+}
+
+func (s *PublicNetworkAccess) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parsePublicNetworkAccess(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
+func parsePublicNetworkAccess(input string) (*PublicNetworkAccess, error) {
+	vals := map[string]PublicNetworkAccess{
+		"disabled": PublicNetworkAccessDisabled,
+		"enabled":  PublicNetworkAccessEnabled,
+	}
+	if v, ok := vals[strings.ToLower(input)]; ok {
+		return &v, nil
+	}
+
+	// otherwise presume it's an undefined value and best-effort it
+	out := PublicNetworkAccess(input)
+	return &out, nil
+}
+
+type SkuName string
+
+const (
+	SkuNamePremiumLRS SkuName = "Premium_LRS"
+	SkuNamePremiumZRS SkuName = "Premium_ZRS"
+)
+
+func PossibleValuesForSkuName() []string {
+	return []string{
+		string(SkuNamePremiumLRS),
+		string(SkuNamePremiumZRS),
+	}
+}
+
+func (s *SkuName) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseSkuName(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
+func parseSkuName(input string) (*SkuName, error) {
+	vals := map[string]SkuName{
+		"premium_lrs": SkuNamePremiumLRS,
+		"premium_zrs": SkuNamePremiumZRS,
+	}
+	if v, ok := vals[strings.ToLower(input)]; ok {
+		return &v, nil
+	}
+
+	// otherwise presume it's an undefined value and best-effort it
+	out := SkuName(input)
+	return &out, nil
+}
+
+type SkuTier string
+
+const (
+	SkuTierPremium SkuTier = "Premium"
+)
+
+func PossibleValuesForSkuTier() []string {
+	return []string{
+		string(SkuTierPremium),
+	}
+}
+
+func (s *SkuTier) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseSkuTier(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
+func parseSkuTier(input string) (*SkuTier, error) {
+	vals := map[string]SkuTier{
+		"premium": SkuTierPremium,
+	}
+	if v, ok := vals[strings.ToLower(input)]; ok {
+		return &v, nil
+	}
+
+	// otherwise presume it's an undefined value and best-effort it
+	out := SkuTier(input)
+	return &out, nil
+}