armnetapp

package module
v6.0.0 Latest Latest
Warning

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

 Go to latest Published: Mar 21, 2024 License: MIT Imports: 15 Imported by: 0

README

Azure NetApp Files Module for Go

PkgGoDev

The armnetapp module provides operations for working with Azure NetApp Files.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure NetApp Files module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp/v6

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure NetApp Files. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure NetApp Files module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armnetapp.NewClientFactory(<subscription ID>, cred, nil)

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

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

Clients

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

client := clientFactory.NewAccountsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Major Version Upgrade

Go uses semantic import versioning to ensure a good backward compatibility for modules. For Azure Go management SDK, we usually upgrade module version according to cooresponding service's API version. Regarding it could be a complicated experience for major version upgrade, we will try our best to keep the SDK API stable and release new version in backward compatible way. However, if any unavoidable breaking changes and a new major version releases for SDK modules, you could use these commands under your module folder to upgrade:

go install github.com/icholy/gomajor@latest
gomajor get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute@latest

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the NetApp Files label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Account 

type Account struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// The identity used for the resource.
	Identity *ManagedServiceIdentity

	// NetApp Account properties
	Properties *AccountProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

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

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

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

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

Account - NetApp account resource

func (Account) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Account.

func (*Account) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Account.

type AccountEncryption 

type AccountEncryption struct {
	// Identity used to authenticate to KeyVault. Applicable if keySource is 'Microsoft.KeyVault'.
	Identity *EncryptionIdentity

	// The encryption keySource (provider). Possible values (case-insensitive): Microsoft.NetApp, Microsoft.KeyVault
	KeySource *KeySource

	// Properties provided by KeVault. Applicable if keySource is 'Microsoft.KeyVault'.
	KeyVaultProperties *KeyVaultProperties
}

AccountEncryption - Encryption settings

func (AccountEncryption) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountEncryption.

func (*AccountEncryption) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountEncryption.

type AccountList 

type AccountList struct {
	// URL to get the next set of results.
	NextLink *string

	// Multiple NetApp accounts
	Value []*Account
}

AccountList - List of NetApp account resources

func (AccountList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountList.

func (*AccountList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountList.

type AccountPatch 

type AccountPatch struct {
	// The identity used for the resource.
	Identity *ManagedServiceIdentity

	// Resource location
	Location *string

	// NetApp Account properties
	Properties *AccountProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

AccountPatch - NetApp account patch resource

func (AccountPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountPatch.

func (*AccountPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountPatch.

type AccountProperties 

type AccountProperties struct {
	// Active Directories
	ActiveDirectories []*ActiveDirectory

	// Encryption settings
	Encryption *AccountEncryption

	// READ-ONLY; Shows the status of disableShowmount for all volumes under the subscription, null equals false
	DisableShowmount *bool

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string
}

AccountProperties - NetApp account properties

func (AccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountProperties.

func (*AccountProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountProperties.

type AccountsClient 

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

AccountsClient contains the methods for the Accounts group. Don't use this type directly, use NewAccountsClient() instead.

func NewAccountsClient 

func NewAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AccountsClient, error)

NewAccountsClient creates a new instance of AccountsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AccountsClient) BeginCreateOrUpdate 

func (client *AccountsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, body Account, options *AccountsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AccountsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the specified NetApp account within the resource group If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • body - NetApp Account object supplied in the body of the operation.
  • options - AccountsClientBeginCreateOrUpdateOptions contains the optional parameters for the AccountsClient.BeginCreateOrUpdate method.
Example (AccountsCreateOrUpdate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAccountsClient().BeginCreateOrUpdate(ctx, "myRG", "account1", armnetapp.Account{
	Location:   to.Ptr("eastus"),
	Properties: &armnetapp.AccountProperties{},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Account = armnetapp.Account{
// 	Name: to.Ptr("account1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.AccountProperties{
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:
Example (AccountsCreateOrUpdateWithActiveDirectory)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_CreateOrUpdateAD.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAccountsClient().BeginCreateOrUpdate(ctx, "myRG", "account1", armnetapp.Account{
	Location: to.Ptr("eastus"),
	Properties: &armnetapp.AccountProperties{
		ActiveDirectories: []*armnetapp.ActiveDirectory{
			{
				AesEncryption:      to.Ptr(true),
				DNS:                to.Ptr("10.10.10.3"),
				Domain:             to.Ptr("10.10.10.3"),
				LdapOverTLS:        to.Ptr(false),
				LdapSigning:        to.Ptr(false),
				OrganizationalUnit: to.Ptr("OU=Engineering"),
				Password:           to.Ptr("ad_password"),
				Site:               to.Ptr("SiteName"),
				SmbServerName:      to.Ptr("SMBServer"),
				Username:           to.Ptr("ad_user_name"),
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Account = armnetapp.Account{
// 	Name: to.Ptr("account1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.AccountProperties{
// 		ActiveDirectories: []*armnetapp.ActiveDirectory{
// 			{
// 				ActiveDirectoryID: to.Ptr("503d38f9-f17c-f92d-ef26-b0d46374534b"),
// 				AesEncryption: to.Ptr(true),
// 				DNS: to.Ptr("10.10.10.3"),
// 				Domain: to.Ptr("10.10.10.3"),
// 				LdapOverTLS: to.Ptr(false),
// 				LdapSigning: to.Ptr(false),
// 				OrganizationalUnit: to.Ptr("OU=Engineering"),
// 				Site: to.Ptr("SiteName"),
// 				SmbServerName: to.Ptr("SMBServer"),
// 				Username: to.Ptr("ad_user_name"),
// 		}},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:

func (*AccountsClient) BeginDelete 

func (client *AccountsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientBeginDeleteOptions) (*runtime.Poller[AccountsClientDeleteResponse], error)

BeginDelete - Delete the specified NetApp account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - AccountsClientBeginDeleteOptions contains the optional parameters for the AccountsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAccountsClient().BeginDelete(ctx, "myRG", "account1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AccountsClient) BeginRenewCredentials 

func (client *AccountsClient) BeginRenewCredentials(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientBeginRenewCredentialsOptions) (*runtime.Poller[AccountsClientRenewCredentialsResponse], error)

BeginRenewCredentials - Renew identity credentials that are used to authenticate to key vault, for customer-managed key encryption. If encryption.identity.principalId does not match identity.principalId, running this operation will fix it. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - AccountsClientBeginRenewCredentialsOptions contains the optional parameters for the AccountsClient.BeginRenewCredentials method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_RenewCredentials.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAccountsClient().BeginRenewCredentials(ctx, "myRG", "account1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AccountsClient) BeginUpdate 

func (client *AccountsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, body AccountPatch, options *AccountsClientBeginUpdateOptions) (*runtime.Poller[AccountsClientUpdateResponse], error)

BeginUpdate - Patch the specified NetApp account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • body - NetApp Account object supplied in the body of the operation.
  • options - AccountsClientBeginUpdateOptions contains the optional parameters for the AccountsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAccountsClient().BeginUpdate(ctx, "myRG", "account1", armnetapp.AccountPatch{
	Tags: map[string]*string{
		"Tag1": to.Ptr("Value1"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Account = armnetapp.Account{
// 	Name: to.Ptr("account1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.AccountProperties{
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:

func (*AccountsClient) Get 

func (client *AccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientGetOptions) (AccountsClientGetResponse, error)

Get - Get the NetApp account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAccountsClient().Get(ctx, "myRG", "account1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Account = armnetapp.Account{
// 	Name: to.Ptr("account1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.AccountProperties{
// 		ActiveDirectories: []*armnetapp.ActiveDirectory{
// 			{
// 				ActiveDirectoryID: to.Ptr("02da3711-6c58-2d64-098a-e3af7afaf936"),
// 				AesEncryption: to.Ptr(true),
// 				DNS: to.Ptr("10.10.10.3"),
// 				Domain: to.Ptr("10.10.10.3"),
// 				LdapSigning: to.Ptr(true),
// 				OrganizationalUnit: to.Ptr("OU=Engineering"),
// 				Site: to.Ptr("SiteName"),
// 				SmbServerName: to.Ptr("SMBServer"),
// 				Status: to.Ptr(armnetapp.ActiveDirectoryStatusInUse),
// 				StatusDetails: to.Ptr("Status Details"),
// 				Username: to.Ptr("ad_user_name"),
// 		}},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:

func (*AccountsClient) NewListBySubscriptionPager 

func (client *AccountsClient) NewListBySubscriptionPager(options *AccountsClientListBySubscriptionOptions) *runtime.Pager[AccountsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List and describe all NetApp accounts in the subscription.

Generated from API version 2023-07-01

  • options - AccountsClientListBySubscriptionOptions contains the optional parameters for the AccountsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Accounts_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAccountsClient().NewListBySubscriptionPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.AccountList = armnetapp.AccountList{
	// 	Value: []*armnetapp.Account{
	// 		{
	// 			Name: to.Ptr("account1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.AccountProperties{
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 			},
	// 	}},
	// }
}

Output:

func (*AccountsClient) NewListPager 

func (client *AccountsClient) NewListPager(resourceGroupName string, options *AccountsClientListOptions) *runtime.Pager[AccountsClientListResponse]

NewListPager - List and describe all NetApp accounts in the resource group.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - AccountsClientListOptions contains the optional parameters for the AccountsClient.NewListPager method.

type AccountsClientBeginCreateOrUpdateOptions 

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

AccountsClientBeginCreateOrUpdateOptions contains the optional parameters for the AccountsClient.BeginCreateOrUpdate method.

type AccountsClientBeginDeleteOptions 

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

AccountsClientBeginDeleteOptions contains the optional parameters for the AccountsClient.BeginDelete method.

type AccountsClientBeginRenewCredentialsOptions 

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

AccountsClientBeginRenewCredentialsOptions contains the optional parameters for the AccountsClient.BeginRenewCredentials method.

type AccountsClientBeginUpdateOptions 

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

AccountsClientBeginUpdateOptions contains the optional parameters for the AccountsClient.BeginUpdate method.

type AccountsClientCreateOrUpdateResponse 

type AccountsClientCreateOrUpdateResponse struct {
	// NetApp account resource
	Account
}

AccountsClientCreateOrUpdateResponse contains the response from method AccountsClient.BeginCreateOrUpdate.

type AccountsClientDeleteResponse 

type AccountsClientDeleteResponse struct {
}

AccountsClientDeleteResponse contains the response from method AccountsClient.BeginDelete.

type AccountsClientGetOptions 

type AccountsClientGetOptions struct {
}

AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.

type AccountsClientGetResponse 

type AccountsClientGetResponse struct {
	// NetApp account resource
	Account
}

AccountsClientGetResponse contains the response from method AccountsClient.Get.

type AccountsClientListBySubscriptionOptions 

type AccountsClientListBySubscriptionOptions struct {
}

AccountsClientListBySubscriptionOptions contains the optional parameters for the AccountsClient.NewListBySubscriptionPager method.

type AccountsClientListBySubscriptionResponse 

type AccountsClientListBySubscriptionResponse struct {
	// List of NetApp account resources
	AccountList
}

AccountsClientListBySubscriptionResponse contains the response from method AccountsClient.NewListBySubscriptionPager.

type AccountsClientListOptions 

type AccountsClientListOptions struct {
}

AccountsClientListOptions contains the optional parameters for the AccountsClient.NewListPager method.

type AccountsClientListResponse 

type AccountsClientListResponse struct {
	// List of NetApp account resources
	AccountList
}

AccountsClientListResponse contains the response from method AccountsClient.NewListPager.

type AccountsClientRenewCredentialsResponse 

type AccountsClientRenewCredentialsResponse struct {
}

AccountsClientRenewCredentialsResponse contains the response from method AccountsClient.BeginRenewCredentials.

type AccountsClientUpdateResponse 

type AccountsClientUpdateResponse struct {
	// NetApp account resource
	Account
}

AccountsClientUpdateResponse contains the response from method AccountsClient.BeginUpdate.

type ActiveDirectory 

type ActiveDirectory struct {
	// Id of the Active Directory
	ActiveDirectoryID *string

	// Name of the active directory machine. This optional parameter is used only while creating kerberos volume
	AdName *string

	// Users to be added to the Built-in Administrators active directory group. A list of unique usernames without domain specifier
	Administrators []*string

	// If enabled, AES encryption will be enabled for SMB communication.
	AesEncryption *bool

	// If enabled, NFS client local users can also (in addition to LDAP users) access the NFS volumes.
	AllowLocalNfsUsersWithLdap *bool

	// Users to be added to the Built-in Backup Operator active directory group. A list of unique usernames without domain specifier
	BackupOperators []*string

	// Comma separated list of DNS server IP addresses (IPv4 only) for the Active Directory domain
	DNS *string

	// Name of the Active Directory domain
	Domain *string

	// If enabled, Traffic between the SMB server to Domain Controller (DC) will be encrypted.
	EncryptDCConnections *bool

	// kdc server IP addresses for the active directory machine. This optional parameter is used only while creating kerberos
	// volume.
	KdcIP *string

	// Specifies whether or not the LDAP traffic needs to be secured via TLS.
	LdapOverTLS *bool

	// LDAP Search scope options
	LdapSearchScope *LdapSearchScopeOpt

	// Specifies whether or not the LDAP traffic needs to be signed.
	LdapSigning *bool

	// The Organizational Unit (OU) within the Windows Active Directory
	OrganizationalUnit *string

	// Plain text password of Active Directory domain administrator, value is masked in the response
	Password *string

	// Comma separated list of IPv4 addresses of preferred servers for LDAP client. At most two comma separated IPv4 addresses
	// can be passed.
	PreferredServersForLdapClient *string

	// Domain Users in the Active directory to be given SeSecurityPrivilege privilege (Needed for SMB Continuously available shares
	// for SQL). A list of unique usernames without domain specifier
	SecurityOperators []*string

	// When LDAP over SSL/TLS is enabled, the LDAP client is required to have base64 encoded Active Directory Certificate Service's
	// self-signed root CA certificate, this optional parameter is used only for
	// dual protocol with LDAP user-mapping volumes.
	ServerRootCACertificate *string

	// The Active Directory site the service will limit Domain Controller discovery to
	Site *string

	// NetBIOS name of the SMB server. This name will be registered as a computer account in the AD and used to mount volumes
	SmbServerName *string

	// A domain user account with permission to create machine accounts
	Username *string

	// READ-ONLY; Status of the Active Directory
	Status *ActiveDirectoryStatus

	// READ-ONLY; Any details in regards to the Status of the Active Directory
	StatusDetails *string
}

ActiveDirectory - Active Directory

func (ActiveDirectory) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ActiveDirectory.

func (*ActiveDirectory) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveDirectory.

type ActiveDirectoryStatus 

type ActiveDirectoryStatus string

ActiveDirectoryStatus - Status of the Active Directory 

const (
	// ActiveDirectoryStatusCreated - Active Directory created but not in use
	ActiveDirectoryStatusCreated ActiveDirectoryStatus = "Created"
	// ActiveDirectoryStatusDeleted - Active Directory Deleted
	ActiveDirectoryStatusDeleted ActiveDirectoryStatus = "Deleted"
	// ActiveDirectoryStatusError - Error with the Active Directory
	ActiveDirectoryStatusError ActiveDirectoryStatus = "Error"
	// ActiveDirectoryStatusInUse - Active Directory in use by SMB Volume
	ActiveDirectoryStatusInUse ActiveDirectoryStatus = "InUse"
	// ActiveDirectoryStatusUpdating - Active Directory Updating
	ActiveDirectoryStatusUpdating ActiveDirectoryStatus = "Updating"
)

func PossibleActiveDirectoryStatusValues 

func PossibleActiveDirectoryStatusValues() []ActiveDirectoryStatus

PossibleActiveDirectoryStatusValues returns the possible values for the ActiveDirectoryStatus const type.

type ApplicationType 

type ApplicationType string

ApplicationType - Application Type 

const (
	ApplicationTypeORACLE  ApplicationType = "ORACLE"
	ApplicationTypeSAPHANA ApplicationType = "SAP-HANA"
)

func PossibleApplicationTypeValues 

func PossibleApplicationTypeValues() []ApplicationType

PossibleApplicationTypeValues returns the possible values for the ApplicationType const type.

type AuthorizeRequest 

type AuthorizeRequest struct {
	// Resource id of the remote volume
	RemoteVolumeResourceID *string
}

AuthorizeRequest - Authorize request

func (AuthorizeRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AuthorizeRequest.

func (*AuthorizeRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AuthorizeRequest.

type AvsDataStore 

type AvsDataStore string

AvsDataStore - Specifies whether the volume is enabled for Azure VMware Solution (AVS) datastore purpose 

const (
	// AvsDataStoreDisabled - avsDataStore is disabled
	AvsDataStoreDisabled AvsDataStore = "Disabled"
	// AvsDataStoreEnabled - avsDataStore is enabled
	AvsDataStoreEnabled AvsDataStore = "Enabled"
)

func PossibleAvsDataStoreValues 

func PossibleAvsDataStoreValues() []AvsDataStore

PossibleAvsDataStoreValues returns the possible values for the AvsDataStore const type.

type BackupPoliciesClient 

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

BackupPoliciesClient contains the methods for the BackupPolicies group. Don't use this type directly, use NewBackupPoliciesClient() instead.

func NewBackupPoliciesClient 

func NewBackupPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BackupPoliciesClient, error)

NewBackupPoliciesClient creates a new instance of BackupPoliciesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BackupPoliciesClient) BeginCreate 

func (client *BackupPoliciesClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, body BackupPolicy, options *BackupPoliciesClientBeginCreateOptions) (*runtime.Poller[BackupPoliciesClientCreateResponse], error)

BeginCreate - Create a backup policy for Netapp Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • backupPolicyName - Backup policy Name which uniquely identify backup policy.
  • body - Backup policy object supplied in the body of the operation.
  • options - BackupPoliciesClientBeginCreateOptions contains the optional parameters for the BackupPoliciesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/BackupPolicies_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBackupPoliciesClient().BeginCreate(ctx, "myRG", "account1", "backupPolicyName", armnetapp.BackupPolicy{
	Location: to.Ptr("westus"),
	Properties: &armnetapp.BackupPolicyProperties{
		DailyBackupsToKeep:   to.Ptr[int32](10),
		Enabled:              to.Ptr(true),
		MonthlyBackupsToKeep: to.Ptr[int32](10),
		WeeklyBackupsToKeep:  to.Ptr[int32](10),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BackupPolicy = armnetapp.BackupPolicy{
// 	Name: to.Ptr("account1/backupPolicyName"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/backupPolocies/backupPolicyName"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetapp.BackupPolicyProperties{
// 		DailyBackupsToKeep: to.Ptr[int32](10),
// 		Enabled: to.Ptr(true),
// 		MonthlyBackupsToKeep: to.Ptr[int32](10),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		WeeklyBackupsToKeep: to.Ptr[int32](10),
// 	},
// }

Output:

func (*BackupPoliciesClient) BeginDelete 

func (client *BackupPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, options *BackupPoliciesClientBeginDeleteOptions) (*runtime.Poller[BackupPoliciesClientDeleteResponse], error)

BeginDelete - Delete backup policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • backupPolicyName - Backup policy Name which uniquely identify backup policy.
  • options - BackupPoliciesClientBeginDeleteOptions contains the optional parameters for the BackupPoliciesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/BackupPolicies_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBackupPoliciesClient().BeginDelete(ctx, "resourceGroup", "accountName", "backupPolicyName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*BackupPoliciesClient) BeginUpdate 

func (client *BackupPoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, body BackupPolicyPatch, options *BackupPoliciesClientBeginUpdateOptions) (*runtime.Poller[BackupPoliciesClientUpdateResponse], error)

BeginUpdate - Patch a backup policy for Netapp Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • backupPolicyName - Backup policy Name which uniquely identify backup policy.
  • body - Backup policy object supplied in the body of the operation.
  • options - BackupPoliciesClientBeginUpdateOptions contains the optional parameters for the BackupPoliciesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/BackupPolicies_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewBackupPoliciesClient().BeginUpdate(ctx, "myRG", "account1", "backupPolicyName", armnetapp.BackupPolicyPatch{
	Location: to.Ptr("westus"),
	Properties: &armnetapp.BackupPolicyProperties{
		DailyBackupsToKeep:   to.Ptr[int32](5),
		Enabled:              to.Ptr(false),
		MonthlyBackupsToKeep: to.Ptr[int32](10),
		WeeklyBackupsToKeep:  to.Ptr[int32](10),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BackupPolicy = armnetapp.BackupPolicy{
// 	Name: to.Ptr("account1/backupPolicyName"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/backupPolocies/backupPolicyName"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetapp.BackupPolicyProperties{
// 		DailyBackupsToKeep: to.Ptr[int32](5),
// 		Enabled: to.Ptr(false),
// 		MonthlyBackupsToKeep: to.Ptr[int32](10),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VolumeBackups: []*armnetapp.VolumeBackups{
// 			{
// 				BackupsCount: to.Ptr[int32](5),
// 				PolicyEnabled: to.Ptr(true),
// 				VolumeName: to.Ptr("volume 1"),
// 		}},
// 		VolumesAssigned: to.Ptr[int32](1),
// 		WeeklyBackupsToKeep: to.Ptr[int32](10),
// 	},
// }

Output:

func (*BackupPoliciesClient) Get 

func (client *BackupPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, options *BackupPoliciesClientGetOptions) (BackupPoliciesClientGetResponse, error)

Get - Get a particular backup Policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • backupPolicyName - Backup policy Name which uniquely identify backup policy.
  • options - BackupPoliciesClientGetOptions contains the optional parameters for the BackupPoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/BackupPolicies_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewBackupPoliciesClient().Get(ctx, "myRG", "account1", "backupPolicyName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.BackupPolicy = armnetapp.BackupPolicy{
// 	Name: to.Ptr("account1/backupPolicyName"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/backupPolocies/backupPolicyName"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.BackupPolicyProperties{
// 		DailyBackupsToKeep: to.Ptr[int32](10),
// 		Enabled: to.Ptr(true),
// 		MonthlyBackupsToKeep: to.Ptr[int32](10),
// 		VolumeBackups: []*armnetapp.VolumeBackups{
// 			{
// 				BackupsCount: to.Ptr[int32](5),
// 				PolicyEnabled: to.Ptr(true),
// 				VolumeName: to.Ptr("volume 1"),
// 		}},
// 		VolumesAssigned: to.Ptr[int32](0),
// 		WeeklyBackupsToKeep: to.Ptr[int32](10),
// 	},
// }

Output:

func (*BackupPoliciesClient) NewListPager 

func (client *BackupPoliciesClient) NewListPager(resourceGroupName string, accountName string, options *BackupPoliciesClientListOptions) *runtime.Pager[BackupPoliciesClientListResponse]

NewListPager - List backup policies for Netapp Account

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - BackupPoliciesClientListOptions contains the optional parameters for the BackupPoliciesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/BackupPolicies_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewBackupPoliciesClient().NewListPager("myRG", "account1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.BackupPoliciesList = armnetapp.BackupPoliciesList{
	// 	Value: []*armnetapp.BackupPolicy{
	// 		{
	// 			Name: to.Ptr("account1/backupPolicy1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/backupPolocies/backupPolicy1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.BackupPolicyProperties{
	// 				DailyBackupsToKeep: to.Ptr[int32](10),
	// 				Enabled: to.Ptr(true),
	// 				MonthlyBackupsToKeep: to.Ptr[int32](10),
	// 				VolumesAssigned: to.Ptr[int32](0),
	// 				WeeklyBackupsToKeep: to.Ptr[int32](10),
	// 			},
	// 	}},
	// }
}

Output:

type BackupPoliciesClientBeginCreateOptions 

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

BackupPoliciesClientBeginCreateOptions contains the optional parameters for the BackupPoliciesClient.BeginCreate method.

type BackupPoliciesClientBeginDeleteOptions 

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

BackupPoliciesClientBeginDeleteOptions contains the optional parameters for the BackupPoliciesClient.BeginDelete method.

type BackupPoliciesClientBeginUpdateOptions 

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

BackupPoliciesClientBeginUpdateOptions contains the optional parameters for the BackupPoliciesClient.BeginUpdate method.

type BackupPoliciesClientCreateResponse 

type BackupPoliciesClientCreateResponse struct {
	// Backup policy information
	BackupPolicy
}

BackupPoliciesClientCreateResponse contains the response from method BackupPoliciesClient.BeginCreate.

type BackupPoliciesClientDeleteResponse 

type BackupPoliciesClientDeleteResponse struct {
}

BackupPoliciesClientDeleteResponse contains the response from method BackupPoliciesClient.BeginDelete.

type BackupPoliciesClientGetOptions 

type BackupPoliciesClientGetOptions struct {
}

BackupPoliciesClientGetOptions contains the optional parameters for the BackupPoliciesClient.Get method.

type BackupPoliciesClientGetResponse 

type BackupPoliciesClientGetResponse struct {
	// Backup policy information
	BackupPolicy
}

BackupPoliciesClientGetResponse contains the response from method BackupPoliciesClient.Get.

type BackupPoliciesClientListOptions 

type BackupPoliciesClientListOptions struct {
}

BackupPoliciesClientListOptions contains the optional parameters for the BackupPoliciesClient.NewListPager method.

type BackupPoliciesClientListResponse 

type BackupPoliciesClientListResponse struct {
	// List of Backup Policies
	BackupPoliciesList
}

BackupPoliciesClientListResponse contains the response from method BackupPoliciesClient.NewListPager.

type BackupPoliciesClientUpdateResponse 

type BackupPoliciesClientUpdateResponse struct {
	// Backup policy information
	BackupPolicy
}

BackupPoliciesClientUpdateResponse contains the response from method BackupPoliciesClient.BeginUpdate.

type BackupPoliciesList 

type BackupPoliciesList struct {
	// A list of backup policies
	Value []*BackupPolicy
}

BackupPoliciesList - List of Backup Policies

func (BackupPoliciesList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPoliciesList.

func (*BackupPoliciesList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupPoliciesList.

type BackupPolicy 

type BackupPolicy struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Backup policy Properties
	Properties *BackupPolicyProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

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

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

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

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

BackupPolicy - Backup policy information

func (BackupPolicy) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicy.

func (*BackupPolicy) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupPolicy.

type BackupPolicyPatch 

type BackupPolicyPatch struct {
	// Resource location
	Location *string

	// Backup policy Properties
	Properties *BackupPolicyProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

BackupPolicyPatch - Backup policy Details for create and update

func (BackupPolicyPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicyPatch.

func (*BackupPolicyPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupPolicyPatch.

type BackupPolicyProperties 

type BackupPolicyProperties struct {
	// Daily backups count to keep
	DailyBackupsToKeep *int32

	// The property to decide policy is enabled or not
	Enabled *bool

	// Monthly backups count to keep
	MonthlyBackupsToKeep *int32

	// Weekly backups count to keep
	WeeklyBackupsToKeep *int32

	// READ-ONLY; Backup Policy Resource ID
	BackupPolicyID *string

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string

	// READ-ONLY; A list of volumes assigned to this policy
	VolumeBackups []*VolumeBackups

	// READ-ONLY; Volumes using current backup policy
	VolumesAssigned *int32
}

BackupPolicyProperties - Backup policy properties

func (BackupPolicyProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicyProperties.

func (*BackupPolicyProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupPolicyProperties.

type BackupsClient 

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

BackupsClient contains the methods for the Backups group. Don't use this type directly, use NewBackupsClient() instead.

func NewBackupsClient 

func NewBackupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BackupsClient, error)

NewBackupsClient creates a new instance of BackupsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BackupsClient) GetVolumeRestoreStatus 

func (client *BackupsClient) GetVolumeRestoreStatus(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *BackupsClientGetVolumeRestoreStatusOptions) (BackupsClientGetVolumeRestoreStatusResponse, error)

GetVolumeRestoreStatus - Get the status of the restore for a volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - BackupsClientGetVolumeRestoreStatusOptions contains the optional parameters for the BackupsClient.GetVolumeRestoreStatus method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_RestoreStatus.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewBackupsClient().GetVolumeRestoreStatus(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.RestoreStatus = armnetapp.RestoreStatus{
// 	ErrorMessage: to.Ptr(""),
// 	Healthy: to.Ptr(true),
// 	MirrorState: to.Ptr(armnetapp.MirrorStateUninitialized),
// 	RelationshipStatus: to.Ptr(armnetapp.RelationshipStatusIdle),
// 	TotalTransferBytes: to.Ptr[int64](100000),
// 	UnhealthyReason: to.Ptr(""),
// }

Output:

type BackupsClientGetVolumeRestoreStatusOptions 

type BackupsClientGetVolumeRestoreStatusOptions struct {
}

BackupsClientGetVolumeRestoreStatusOptions contains the optional parameters for the BackupsClient.GetVolumeRestoreStatus method.

type BackupsClientGetVolumeRestoreStatusResponse 

type BackupsClientGetVolumeRestoreStatusResponse struct {
	// Restore status
	RestoreStatus
}

BackupsClientGetVolumeRestoreStatusResponse contains the response from method BackupsClient.GetVolumeRestoreStatus.

type BreakFileLocksRequest 

type BreakFileLocksRequest struct {
	// To clear file locks on a volume for a particular client
	ClientIP *string

	// Break File locks could be a disruptive operation for application as locks on the volume will be broken, if want to process,
	// set to true.
	ConfirmRunningDisruptiveOperation *bool
}

BreakFileLocksRequest - Break file locks request

func (BreakFileLocksRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BreakFileLocksRequest.

func (*BreakFileLocksRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BreakFileLocksRequest.

type BreakReplicationRequest 

type BreakReplicationRequest struct {
	// If replication is in status transferring and you want to force break the replication, set to true
	ForceBreakReplication *bool
}

BreakReplicationRequest - Break replication request

func (BreakReplicationRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BreakReplicationRequest.

func (*BreakReplicationRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BreakReplicationRequest.

type CapacityPool 

type CapacityPool struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Capacity pool properties
	Properties *PoolProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

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

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

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

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

CapacityPool - Capacity pool resource

func (CapacityPool) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityPool.

func (*CapacityPool) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CapacityPool.

type CapacityPoolList 

type CapacityPoolList struct {
	// URL to get the next set of results.
	NextLink *string

	// List of Capacity pools
	Value []*CapacityPool
}

CapacityPoolList - List of capacity pool resources

func (CapacityPoolList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityPoolList.

func (*CapacityPoolList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CapacityPoolList.

type CapacityPoolPatch 

type CapacityPoolPatch struct {
	// Resource location
	Location *string

	// Capacity pool properties
	Properties *PoolPatchProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

CapacityPoolPatch - Capacity pool patch resource

func (CapacityPoolPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityPoolPatch.

func (*CapacityPoolPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CapacityPoolPatch.

type CheckAvailabilityResponse 

type CheckAvailabilityResponse struct {
	// true indicates name is valid and available. false indicates the name is invalid, unavailable, or both.
	IsAvailable *bool

	// If reason == invalid, provide the user with the reason why the given name is invalid, and provide the resource naming requirements
	// so that the user can select a valid name. If reason == AlreadyExists,
	// explain that resource name is already in use, and direct them to select a different name.
	Message *string

	// Invalid indicates the name provided does not match Azure App Service naming requirements. AlreadyExists indicates that
	// the name is already in use and is therefore unavailable.
	Reason *InAvailabilityReasonType
}

CheckAvailabilityResponse - Information regarding availability of a resource.

func (CheckAvailabilityResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckAvailabilityResponse.

func (*CheckAvailabilityResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckAvailabilityResponse.

type CheckNameResourceTypes 

type CheckNameResourceTypes string

CheckNameResourceTypes - Resource type used for verification. 

const (
	CheckNameResourceTypesMicrosoftNetAppNetAppAccounts                              CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts"
	CheckNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPools                 CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools"
	CheckNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumes          CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes"
	CheckNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumesSnapshots CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"
)

func PossibleCheckNameResourceTypesValues 

func PossibleCheckNameResourceTypesValues() []CheckNameResourceTypes

PossibleCheckNameResourceTypesValues returns the possible values for the CheckNameResourceTypes const type.

type CheckQuotaNameResourceTypes 

type CheckQuotaNameResourceTypes string

CheckQuotaNameResourceTypes - Resource type used for verification. 

const (
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccounts                              CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts"
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPools                 CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools"
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumes          CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes"
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumesSnapshots CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"
)

func PossibleCheckQuotaNameResourceTypesValues 

func PossibleCheckQuotaNameResourceTypesValues() []CheckQuotaNameResourceTypes

PossibleCheckQuotaNameResourceTypesValues returns the possible values for the CheckQuotaNameResourceTypes const type.

type ChownMode 

type ChownMode string

ChownMode - This parameter specifies who is authorized to change the ownership of a file. restricted - Only root user can change the ownership of the file. unrestricted - Non-root users can change ownership of files that they own. 

const (
	ChownModeRestricted   ChownMode = "Restricted"
	ChownModeUnrestricted ChownMode = "Unrestricted"
)

func PossibleChownModeValues 

func PossibleChownModeValues() []ChownMode

PossibleChownModeValues returns the possible values for the ChownMode const type.

type ClientFactory 

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

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAccountsClient 

func (c *ClientFactory) NewAccountsClient() *AccountsClient

NewAccountsClient creates a new instance of AccountsClient.

func (*ClientFactory) NewBackupPoliciesClient 

func (c *ClientFactory) NewBackupPoliciesClient() *BackupPoliciesClient

NewBackupPoliciesClient creates a new instance of BackupPoliciesClient.

func (*ClientFactory) NewBackupsClient 

func (c *ClientFactory) NewBackupsClient() *BackupsClient

NewBackupsClient creates a new instance of BackupsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPoolsClient 

func (c *ClientFactory) NewPoolsClient() *PoolsClient

NewPoolsClient creates a new instance of PoolsClient.

func (*ClientFactory) NewResourceClient 

func (c *ClientFactory) NewResourceClient() *ResourceClient

NewResourceClient creates a new instance of ResourceClient.

func (*ClientFactory) NewResourceQuotaLimitsClient 

func (c *ClientFactory) NewResourceQuotaLimitsClient() *ResourceQuotaLimitsClient

NewResourceQuotaLimitsClient creates a new instance of ResourceQuotaLimitsClient.

func (*ClientFactory) NewSnapshotPoliciesClient 

func (c *ClientFactory) NewSnapshotPoliciesClient() *SnapshotPoliciesClient

NewSnapshotPoliciesClient creates a new instance of SnapshotPoliciesClient.

func (*ClientFactory) NewSnapshotsClient 

func (c *ClientFactory) NewSnapshotsClient() *SnapshotsClient

NewSnapshotsClient creates a new instance of SnapshotsClient.

func (*ClientFactory) NewSubvolumesClient 

func (c *ClientFactory) NewSubvolumesClient() *SubvolumesClient

NewSubvolumesClient creates a new instance of SubvolumesClient.

func (*ClientFactory) NewVolumeGroupsClient 

func (c *ClientFactory) NewVolumeGroupsClient() *VolumeGroupsClient

NewVolumeGroupsClient creates a new instance of VolumeGroupsClient.

func (*ClientFactory) NewVolumeQuotaRulesClient 

func (c *ClientFactory) NewVolumeQuotaRulesClient() *VolumeQuotaRulesClient

NewVolumeQuotaRulesClient creates a new instance of VolumeQuotaRulesClient.

func (*ClientFactory) NewVolumesClient 

func (c *ClientFactory) NewVolumesClient() *VolumesClient

NewVolumesClient creates a new instance of VolumesClient.

type CoolAccessRetrievalPolicy 

type CoolAccessRetrievalPolicy string

CoolAccessRetrievalPolicy - coolAccessRetrievalPolicy determines the data retrieval behavior from the cool tier to standard storage based on the read pattern for cool access enabled volumes. The possible values for this field are: Default - Data will be pulled from cool tier to standard storage on random reads. This policy is the default. OnRead - All client-driven data read is pulled from cool tier to standard storage on both sequential and random reads. Never - No client-driven data is pulled from cool tier to standard storage. 

const (
	CoolAccessRetrievalPolicyDefault CoolAccessRetrievalPolicy = "Default"
	CoolAccessRetrievalPolicyNever   CoolAccessRetrievalPolicy = "Never"
	CoolAccessRetrievalPolicyOnRead  CoolAccessRetrievalPolicy = "OnRead"
)

func PossibleCoolAccessRetrievalPolicyValues 

func PossibleCoolAccessRetrievalPolicyValues() []CoolAccessRetrievalPolicy

PossibleCoolAccessRetrievalPolicyValues returns the possible values for the CoolAccessRetrievalPolicy const type.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DailySchedule 

type DailySchedule struct {
	// Indicates which hour in UTC timezone a snapshot should be taken
	Hour *int32

	// Indicates which minute snapshot should be taken
	Minute *int32

	// Daily snapshot count to keep
	SnapshotsToKeep *int32

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64
}

DailySchedule - Daily Schedule properties

func (DailySchedule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DailySchedule.

func (*DailySchedule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DailySchedule.

type Dimension 

type Dimension struct {
	// Display name of dimension.
	DisplayName *string

	// Display name of dimension.
	Name *string
}

Dimension of blobs, possibly be blob type or access tier.

func (Dimension) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Dimension.

func (*Dimension) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Dimension.

type EnableSubvolumes 

type EnableSubvolumes string

EnableSubvolumes - Flag indicating whether subvolume operations are enabled on the volume 

const (
	// EnableSubvolumesDisabled - subvolumes are not enabled
	EnableSubvolumesDisabled EnableSubvolumes = "Disabled"
	// EnableSubvolumesEnabled - subvolumes are enabled
	EnableSubvolumesEnabled EnableSubvolumes = "Enabled"
)

func PossibleEnableSubvolumesValues 

func PossibleEnableSubvolumesValues() []EnableSubvolumes

PossibleEnableSubvolumesValues returns the possible values for the EnableSubvolumes const type.

type EncryptionIdentity 

type EncryptionIdentity struct {
	// The ARM resource identifier of the user assigned identity used to authenticate with key vault. Applicable if identity.type
	// has 'UserAssigned'. It should match key of identity.userAssignedIdentities.
	UserAssignedIdentity *string

	// READ-ONLY; The principal ID (object ID) of the identity used to authenticate with key vault. Read-only.
	PrincipalID *string
}

EncryptionIdentity - Identity used to authenticate with key vault.

func (EncryptionIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionIdentity.

func (*EncryptionIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionIdentity.

type EncryptionKeySource 

type EncryptionKeySource string

EncryptionKeySource - Source of key used to encrypt data in volume. Applicable if NetApp account has encryption.keySource = 'Microsoft.KeyVault'. Possible values (case-insensitive) are: 'Microsoft.NetApp, Microsoft.KeyVault' 

const (
	// EncryptionKeySourceMicrosoftKeyVault - Customer-managed key encryption
	EncryptionKeySourceMicrosoftKeyVault EncryptionKeySource = "Microsoft.KeyVault"
	// EncryptionKeySourceMicrosoftNetApp - Microsoft-managed key encryption
	EncryptionKeySourceMicrosoftNetApp EncryptionKeySource = "Microsoft.NetApp"
)

func PossibleEncryptionKeySourceValues 

func PossibleEncryptionKeySourceValues() []EncryptionKeySource

PossibleEncryptionKeySourceValues returns the possible values for the EncryptionKeySource const type.

type EncryptionType 

type EncryptionType string

EncryptionType - Encryption type of the capacity pool, set encryption type for data at rest for this pool and all volumes in it. This value can only be set when creating new pool. 

const (
	// EncryptionTypeDouble - EncryptionType Double, volumes will use double encryption at rest
	EncryptionTypeDouble EncryptionType = "Double"
	// EncryptionTypeSingle - EncryptionType Single, volumes will use single encryption at rest
	EncryptionTypeSingle EncryptionType = "Single"
)

func PossibleEncryptionTypeValues 

func PossibleEncryptionTypeValues() []EncryptionType

PossibleEncryptionTypeValues returns the possible values for the EncryptionType const type.

type EndpointType 

type EndpointType string

EndpointType - Indicates whether the local volume is the source or destination for the Volume Replication 

const (
	EndpointTypeDst EndpointType = "dst"
	EndpointTypeSrc EndpointType = "src"
)

func PossibleEndpointTypeValues 

func PossibleEndpointTypeValues() []EndpointType

PossibleEndpointTypeValues returns the possible values for the EndpointType const type.

type ExportPolicyRule 

type ExportPolicyRule struct {
	// Client ingress specification as comma separated string with IPv4 CIDRs, IPv4 host addresses and host names
	AllowedClients *string

	// This parameter specifies who is authorized to change the ownership of a file. restricted - Only root user can change the
	// ownership of the file. unrestricted - Non-root users can change ownership of
	// files that they own.
	ChownMode *ChownMode

	// Allows CIFS protocol
	Cifs *bool

	// Has root access to volume
	HasRootAccess *bool

	// Kerberos5i Read only access. To be use with swagger version 2020-05-01 or later
	Kerberos5IReadOnly *bool

	// Kerberos5i Read and write access. To be use with swagger version 2020-05-01 or later
	Kerberos5IReadWrite *bool

	// Kerberos5p Read only access. To be use with swagger version 2020-05-01 or later
	Kerberos5PReadOnly *bool

	// Kerberos5p Read and write access. To be use with swagger version 2020-05-01 or later
	Kerberos5PReadWrite *bool

	// Kerberos5 Read only access. To be use with swagger version 2020-05-01 or later
	Kerberos5ReadOnly *bool

	// Kerberos5 Read and write access. To be use with swagger version 2020-05-01 or later
	Kerberos5ReadWrite *bool

	// Allows NFSv3 protocol. Enable only for NFSv3 type volumes
	Nfsv3 *bool

	// Allows NFSv4.1 protocol. Enable only for NFSv4.1 type volumes
	Nfsv41 *bool

	// Order index
	RuleIndex *int32

	// Read only access
	UnixReadOnly *bool

	// Read and write access
	UnixReadWrite *bool
}

ExportPolicyRule - Volume Export Policy Rule

func (ExportPolicyRule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExportPolicyRule.

func (*ExportPolicyRule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExportPolicyRule.

type FileAccessLogs 

type FileAccessLogs string

FileAccessLogs - Flag indicating whether file access logs are enabled for the volume, based on active diagnostic settings present on the volume. 

const (
	// FileAccessLogsDisabled - fileAccessLogs are not enabled
	FileAccessLogsDisabled FileAccessLogs = "Disabled"
	// FileAccessLogsEnabled - fileAccessLogs are enabled
	FileAccessLogsEnabled FileAccessLogs = "Enabled"
)

func PossibleFileAccessLogsValues 

func PossibleFileAccessLogsValues() []FileAccessLogs

PossibleFileAccessLogsValues returns the possible values for the FileAccessLogs const type.

type FilePathAvailabilityRequest 

type FilePathAvailabilityRequest struct {
	// REQUIRED; File path to verify.
	Name *string

	// REQUIRED; The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes
	SubnetID *string
}

FilePathAvailabilityRequest - File path availability request content - availability is based on the name and the subnetId.

func (FilePathAvailabilityRequest) MarshalJSON 

func (f FilePathAvailabilityRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FilePathAvailabilityRequest.

func (*FilePathAvailabilityRequest) UnmarshalJSON 

func (f *FilePathAvailabilityRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FilePathAvailabilityRequest.

type GetGroupIDListForLDAPUserRequest 

type GetGroupIDListForLDAPUserRequest struct {
	// REQUIRED; username is required to fetch the group to which user is part of
	Username *string
}

GetGroupIDListForLDAPUserRequest - Get group Id list for LDAP User request

func (GetGroupIDListForLDAPUserRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type GetGroupIDListForLDAPUserRequest.

func (*GetGroupIDListForLDAPUserRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GetGroupIDListForLDAPUserRequest.

type GetGroupIDListForLDAPUserResponse 

type GetGroupIDListForLDAPUserResponse struct {
	// Group Id list
	GroupIDsForLdapUser []*string
}

GetGroupIDListForLDAPUserResponse - Group Id list for Ldap user

func (GetGroupIDListForLDAPUserResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type GetGroupIDListForLDAPUserResponse.

func (*GetGroupIDListForLDAPUserResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GetGroupIDListForLDAPUserResponse.

type HourlySchedule 

type HourlySchedule struct {
	// Indicates which minute snapshot should be taken
	Minute *int32

	// Hourly snapshot count to keep
	SnapshotsToKeep *int32

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64
}

HourlySchedule - Hourly Schedule properties

func (HourlySchedule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HourlySchedule.

func (*HourlySchedule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HourlySchedule.

type InAvailabilityReasonType 

type InAvailabilityReasonType string

InAvailabilityReasonType - Invalid indicates the name provided does not match Azure App Service naming requirements. AlreadyExists indicates that the name is already in use and is therefore unavailable. 

const (
	InAvailabilityReasonTypeAlreadyExists InAvailabilityReasonType = "AlreadyExists"
	InAvailabilityReasonTypeInvalid       InAvailabilityReasonType = "Invalid"
)

func PossibleInAvailabilityReasonTypeValues 

func PossibleInAvailabilityReasonTypeValues() []InAvailabilityReasonType

PossibleInAvailabilityReasonTypeValues returns the possible values for the InAvailabilityReasonType const type.

type KeySource 

type KeySource string

KeySource - The encryption keySource (provider). Possible values (case-insensitive): Microsoft.NetApp, Microsoft.KeyVault 

const (
	// KeySourceMicrosoftKeyVault - Customer-managed key encryption
	KeySourceMicrosoftKeyVault KeySource = "Microsoft.KeyVault"
	// KeySourceMicrosoftNetApp - Microsoft-managed key encryption
	KeySourceMicrosoftNetApp KeySource = "Microsoft.NetApp"
)

func PossibleKeySourceValues 

func PossibleKeySourceValues() []KeySource

PossibleKeySourceValues returns the possible values for the KeySource const type.

type KeyVaultProperties 

type KeyVaultProperties struct {
	// REQUIRED; The name of KeyVault key.
	KeyName *string

	// REQUIRED; The resource ID of KeyVault.
	KeyVaultResourceID *string

	// REQUIRED; The Uri of KeyVault.
	KeyVaultURI *string

	// READ-ONLY; UUID v4 used to identify the Azure Key Vault configuration
	KeyVaultID *string

	// READ-ONLY; Status of the KeyVault connection.
	Status *KeyVaultStatus
}

KeyVaultProperties - Properties of key vault.

func (KeyVaultProperties) MarshalJSON 

func (k KeyVaultProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultProperties.

func (*KeyVaultProperties) UnmarshalJSON 

func (k *KeyVaultProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultProperties.

type KeyVaultStatus 

type KeyVaultStatus string

KeyVaultStatus - Status of the KeyVault connection. 

const (
	// KeyVaultStatusCreated - KeyVault connection created but not in use
	KeyVaultStatusCreated KeyVaultStatus = "Created"
	// KeyVaultStatusDeleted - KeyVault connection Deleted
	KeyVaultStatusDeleted KeyVaultStatus = "Deleted"
	// KeyVaultStatusError - Error with the KeyVault connection
	KeyVaultStatusError KeyVaultStatus = "Error"
	// KeyVaultStatusInUse - KeyVault connection in use by SMB Volume
	KeyVaultStatusInUse KeyVaultStatus = "InUse"
	// KeyVaultStatusUpdating - KeyVault connection Updating
	KeyVaultStatusUpdating KeyVaultStatus = "Updating"
)

func PossibleKeyVaultStatusValues 

func PossibleKeyVaultStatusValues() []KeyVaultStatus

PossibleKeyVaultStatusValues returns the possible values for the KeyVaultStatus const type.

type LdapSearchScopeOpt 

type LdapSearchScopeOpt struct {
	// This specifies the group DN, which overrides the base DN for group lookups.
	GroupDN *string

	// This specifies the custom LDAP search filter to be used when looking up group membership from LDAP server.
	GroupMembershipFilter *string

	// This specifies the user DN, which overrides the base DN for user lookups.
	UserDN *string
}

LdapSearchScopeOpt - LDAP search scope

func (LdapSearchScopeOpt) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LdapSearchScopeOpt.

func (*LdapSearchScopeOpt) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LdapSearchScopeOpt.

type ListReplications 

type ListReplications struct {
	// A list of replications
	Value []*Replication
}

ListReplications - List Replications

func (ListReplications) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ListReplications.

func (*ListReplications) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListReplications.

type LogSpecification 

type LogSpecification struct {
	// Display name of log specification.
	DisplayName *string

	// Name of log specification.
	Name *string
}

LogSpecification - Log Definition of a single resource metric.

func (LogSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LogSpecification.

func (*LogSpecification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LogSpecification.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
	Type *ManagedServiceIdentityType

	// The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM
	// resource ids in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}.
	// The dictionary values can be empty objects ({}) in
	// requests.
	UserAssignedIdentities map[string]*UserAssignedIdentity

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string
}

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). 

const (
	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type MetricAggregationType 

type MetricAggregationType string
const (
	MetricAggregationTypeAverage MetricAggregationType = "Average"
)

func PossibleMetricAggregationTypeValues 

func PossibleMetricAggregationTypeValues() []MetricAggregationType

PossibleMetricAggregationTypeValues returns the possible values for the MetricAggregationType const type.

type MetricSpecification 

type MetricSpecification struct {
	// Aggregation type could be Average.
	AggregationType *string

	// The category this metric specification belong to, could be Capacity.
	Category *string

	// Dimensions of blobs, including blob type and access tier.
	Dimensions []*Dimension

	// Display description of metric specification.
	DisplayDescription *string

	// Display name of metric specification.
	DisplayName *string

	// Whether or not the service is using regional MDM accounts.
	EnableRegionalMdmAccount *bool

	// The property to decide fill gap with zero or not.
	FillGapWithZero *bool

	// The internal metric name.
	InternalMetricName *string

	// Whether the metric is internal.
	IsInternal *bool

	// Name of metric specification.
	Name *string

	// Account Resource Id.
	ResourceIDDimensionNameOverride *string

	// The source MDM account.
	SourceMdmAccount *string

	// The source MDM namespace.
	SourceMdmNamespace *string

	// Support metric aggregation type.
	SupportedAggregationTypes []*MetricAggregationType

	// The supported time grain types for the metrics.
	SupportedTimeGrainTypes []*string

	// Unit could be Bytes or Count.
	Unit *string
}

MetricSpecification - Metric specification of operation.

func (MetricSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricSpecification.

func (*MetricSpecification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricSpecification.

type MirrorState 

type MirrorState string

MirrorState - The status of the replication 

const (
	MirrorStateBroken        MirrorState = "Broken"
	MirrorStateMirrored      MirrorState = "Mirrored"
	MirrorStateUninitialized MirrorState = "Uninitialized"
)

func PossibleMirrorStateValues 

func PossibleMirrorStateValues() []MirrorState

PossibleMirrorStateValues returns the possible values for the MirrorState const type.

type MonthlySchedule 

type MonthlySchedule struct {
	// Indicates which days of the month snapshot should be taken. A comma delimited string.
	DaysOfMonth *string

	// Indicates which hour in UTC timezone a snapshot should be taken
	Hour *int32

	// Indicates which minute snapshot should be taken
	Minute *int32

	// Monthly snapshot count to keep
	SnapshotsToKeep *int32

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64
}

MonthlySchedule - Monthly Schedule properties

func (MonthlySchedule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MonthlySchedule.

func (*MonthlySchedule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MonthlySchedule.

type MountTargetProperties 

type MountTargetProperties struct {
	// REQUIRED; UUID v4 used to identify the MountTarget
	FileSystemID *string

	// The SMB server's Fully Qualified Domain Name, FQDN
	SmbServerFqdn *string

	// READ-ONLY; The mount target's IPv4 address
	IPAddress *string

	// READ-ONLY; UUID v4 used to identify the MountTarget
	MountTargetID *string
}

MountTargetProperties - Mount target properties

func (MountTargetProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MountTargetProperties.

func (*MountTargetProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MountTargetProperties.

type NetworkFeatures 

type NetworkFeatures string

NetworkFeatures - Network features available to the volume, or current state of update. 

const (
	// NetworkFeaturesBasic - Basic network features.
	NetworkFeaturesBasic NetworkFeatures = "Basic"
	// NetworkFeaturesBasicStandard - Updating from Basic to Standard network features.
	NetworkFeaturesBasicStandard NetworkFeatures = "Basic_Standard"
	// NetworkFeaturesStandard - Standard network features.
	NetworkFeaturesStandard NetworkFeatures = "Standard"
	// NetworkFeaturesStandardBasic - Updating from Standard to Basic network features.
	NetworkFeaturesStandardBasic NetworkFeatures = "Standard_Basic"
)

func PossibleNetworkFeaturesValues 

func PossibleNetworkFeaturesValues() []NetworkFeatures

PossibleNetworkFeaturesValues returns the possible values for the NetworkFeatures const type.

type NetworkSiblingSet 

type NetworkSiblingSet struct {
	// Network features available to the volume, or current state of update.
	NetworkFeatures *NetworkFeatures

	// Network Sibling Set ID for a group of volumes sharing networking resources in a subnet.
	NetworkSiblingSetID *string

	// Network sibling set state Id identifying the current state of the sibling set.
	NetworkSiblingSetStateID *string

	// List of NIC information
	NicInfoList []*NicInfo

	// The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes. Example
	// /subscriptions/subscriptionId/resourceGroups/resourceGroup/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/{mySubnet}
	SubnetID *string

	// READ-ONLY; Gets the status of the NetworkSiblingSet at the time the operation was called.
	ProvisioningState *NetworkSiblingSetProvisioningState
}

NetworkSiblingSet - Describes the contents of a network sibling set.

func (NetworkSiblingSet) MarshalJSON 

func (n NetworkSiblingSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkSiblingSet.

func (*NetworkSiblingSet) UnmarshalJSON 

func (n *NetworkSiblingSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkSiblingSet.

type NetworkSiblingSetProvisioningState 

type NetworkSiblingSetProvisioningState string

NetworkSiblingSetProvisioningState - Gets the status of the NetworkSiblingSet at the time the operation was called. 

const (
	NetworkSiblingSetProvisioningStateCanceled  NetworkSiblingSetProvisioningState = "Canceled"
	NetworkSiblingSetProvisioningStateFailed    NetworkSiblingSetProvisioningState = "Failed"
	NetworkSiblingSetProvisioningStateSucceeded NetworkSiblingSetProvisioningState = "Succeeded"
	NetworkSiblingSetProvisioningStateUpdating  NetworkSiblingSetProvisioningState = "Updating"
)

func PossibleNetworkSiblingSetProvisioningStateValues 

func PossibleNetworkSiblingSetProvisioningStateValues() []NetworkSiblingSetProvisioningState

PossibleNetworkSiblingSetProvisioningStateValues returns the possible values for the NetworkSiblingSetProvisioningState const type.

type NicInfo 

type NicInfo struct {
	// Volume resource Ids
	VolumeResourceIDs []*string

	// READ-ONLY; ipAddress
	IPAddress *string
}

NicInfo - NIC information and list of volumes for which the NIC has the primary mount ip address.

func (NicInfo) MarshalJSON 

func (n NicInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NicInfo.

func (*NicInfo) UnmarshalJSON 

func (n *NicInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NicInfo.

type Operation 

type Operation struct {
	// Display metadata associated with the operation.
	Display *OperationDisplay

	// Operation name: {provider}/{resource}/{operation}
	Name *string

	// The origin of operations.
	Origin *string

	// Properties of operation, include metric specifications.
	Properties *OperationProperties
}

Operation - Microsoft.NetApp REST API operation definition.

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// Operation description.
	Description *string

	// Type of operation: get, read, delete, etc.
	Operation *string

	// Service provider: Microsoft NetApp.
	Provider *string

	// Resource on which the operation is performed etc.
	Resource *string
}

OperationDisplay - Display metadata associated with the operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// List of Storage operations supported by the Storage resource provider.
	Value []*Operation
}

OperationListResult - Result of the request to list Cloud Volume operations. It contains a list of operations and a URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationProperties 

type OperationProperties struct {
	// One property of operation, include metric specifications.
	ServiceSpecification *ServiceSpecification
}

OperationProperties - Properties of operation, include metric specifications.

func (OperationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationProperties.

func (*OperationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationProperties.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager 

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

NewListPager - Lists all of the available Microsoft.NetApp Rest API operations

Generated from API version 2023-07-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/OperationList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OperationListResult = armnetapp.OperationListResult{
	// 	Value: []*armnetapp.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/register/action"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Subscription Registration Action"),
	// 				Operation: to.Ptr("Subscription Registration Action"),
	// 				Provider: to.Ptr("Microsoft.NetApp"),
	// 				Resource: to.Ptr("Subscription"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/read"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Reads a volume resource."),
	// 				Operation: to.Ptr("Read volume resource"),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/write"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Writes a volume resource."),
	// 				Operation: to.Ptr("Write volume resource"),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/delete"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Deletes a volume resource."),
	// 				Operation: to.Ptr("Delete volume resource"),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/Revert/action"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Revert volume to specific snapshot"),
	// 				Operation: to.Ptr("Revert volume resource"),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/BreakReplication/action"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Break volume replication relations"),
	// 				Operation: to.Ptr("Break volume replication resource"),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/ReplicationStatus/action"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Reads the statuses of the Volume Replication."),
	// 				Operation: to.Ptr("Read Volume Replication Status."),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/ListReplications/action"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/ReInitializeReplication/action"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Attempts to re-initialize an uninitialized replication"),
	// 				Operation: to.Ptr("Re-Initialize replication"),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/providers/Microsoft.Insights/metricDefinitions/read"),
	// 			Display: &armnetapp.OperationDisplay{
	// 				Description: to.Ptr("Gets the available metrics for Volume resource."),
	// 				Operation: to.Ptr("Read volume metric definitions."),
	// 				Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 				Resource: to.Ptr("Volumes resource type"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 			Properties: &armnetapp.OperationProperties{
	// 				ServiceSpecification: &armnetapp.ServiceSpecification{
	// 					MetricSpecifications: []*armnetapp.MetricSpecification{
	// 						{
	// 							Name: to.Ptr("AverageReadLatency"),
	// 							AggregationType: to.Ptr("Average"),
	// 							Dimensions: []*armnetapp.Dimension{
	// 							},
	// 							DisplayDescription: to.Ptr("Average read latency in milliseconds per operation"),
	// 							DisplayName: to.Ptr("Average read latency"),
	// 							EnableRegionalMdmAccount: to.Ptr(true),
	// 							FillGapWithZero: to.Ptr(false),
	// 							InternalMetricName: to.Ptr("AverageReadLatency"),
	// 							IsInternal: to.Ptr(false),
	// 							SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 							SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 							SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 								to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 								SupportedTimeGrainTypes: []*string{
	// 									to.Ptr("PT5M"),
	// 									to.Ptr("PT15M"),
	// 									to.Ptr("PT30M"),
	// 									to.Ptr("PT1H"),
	// 									to.Ptr("PT6H"),
	// 									to.Ptr("PT12H"),
	// 									to.Ptr("P1D")},
	// 									Unit: to.Ptr("MilliSeconds"),
	// 								},
	// 								{
	// 									Name: to.Ptr("AverageWriteLatency"),
	// 									AggregationType: to.Ptr("Average"),
	// 									Dimensions: []*armnetapp.Dimension{
	// 									},
	// 									DisplayDescription: to.Ptr("Average write latency in milliseconds per operation"),
	// 									DisplayName: to.Ptr("Average write latency"),
	// 									EnableRegionalMdmAccount: to.Ptr(true),
	// 									FillGapWithZero: to.Ptr(false),
	// 									InternalMetricName: to.Ptr("AverageWriteLatency"),
	// 									IsInternal: to.Ptr(false),
	// 									SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 									SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 									SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 										to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 										SupportedTimeGrainTypes: []*string{
	// 											to.Ptr("PT5M"),
	// 											to.Ptr("PT15M"),
	// 											to.Ptr("PT30M"),
	// 											to.Ptr("PT1H"),
	// 											to.Ptr("PT6H"),
	// 											to.Ptr("PT12H"),
	// 											to.Ptr("P1D")},
	// 											Unit: to.Ptr("MilliSeconds"),
	// 										},
	// 										{
	// 											Name: to.Ptr("VolumeLogicalSize"),
	// 											AggregationType: to.Ptr("Average"),
	// 											Dimensions: []*armnetapp.Dimension{
	// 											},
	// 											DisplayDescription: to.Ptr("Logical size of the volume (used bytes)"),
	// 											DisplayName: to.Ptr("Volume Consumed Size"),
	// 											EnableRegionalMdmAccount: to.Ptr(true),
	// 											FillGapWithZero: to.Ptr(false),
	// 											InternalMetricName: to.Ptr("VolumeLogicalSize"),
	// 											IsInternal: to.Ptr(false),
	// 											SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 											SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 											SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 												to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 												SupportedTimeGrainTypes: []*string{
	// 													to.Ptr("PT5M"),
	// 													to.Ptr("PT15M"),
	// 													to.Ptr("PT30M"),
	// 													to.Ptr("PT1H"),
	// 													to.Ptr("PT6H"),
	// 													to.Ptr("PT12H"),
	// 													to.Ptr("P1D")},
	// 													Unit: to.Ptr("Bytes"),
	// 												},
	// 												{
	// 													Name: to.Ptr("VolumeSnapshotSize"),
	// 													AggregationType: to.Ptr("Average"),
	// 													Dimensions: []*armnetapp.Dimension{
	// 													},
	// 													DisplayDescription: to.Ptr("Size of all snapshots in volume"),
	// 													DisplayName: to.Ptr("Volume snapshot size"),
	// 													EnableRegionalMdmAccount: to.Ptr(true),
	// 													FillGapWithZero: to.Ptr(false),
	// 													InternalMetricName: to.Ptr("VolumeSnapshotSize"),
	// 													IsInternal: to.Ptr(false),
	// 													SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 													SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 													SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 														to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 														SupportedTimeGrainTypes: []*string{
	// 															to.Ptr("PT5M"),
	// 															to.Ptr("PT15M"),
	// 															to.Ptr("PT30M"),
	// 															to.Ptr("PT1H"),
	// 															to.Ptr("PT6H"),
	// 															to.Ptr("PT12H"),
	// 															to.Ptr("P1D")},
	// 															Unit: to.Ptr("Bytes"),
	// 														},
	// 														{
	// 															Name: to.Ptr("ReadIops"),
	// 															AggregationType: to.Ptr("Average"),
	// 															Dimensions: []*armnetapp.Dimension{
	// 															},
	// 															DisplayDescription: to.Ptr("Read In/out operations per second"),
	// 															DisplayName: to.Ptr("Read iops"),
	// 															EnableRegionalMdmAccount: to.Ptr(true),
	// 															FillGapWithZero: to.Ptr(false),
	// 															InternalMetricName: to.Ptr("ReadIops"),
	// 															IsInternal: to.Ptr(false),
	// 															SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 															SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 															SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																SupportedTimeGrainTypes: []*string{
	// 																	to.Ptr("PT5M"),
	// 																	to.Ptr("PT15M"),
	// 																	to.Ptr("PT30M"),
	// 																	to.Ptr("PT1H"),
	// 																	to.Ptr("PT6H"),
	// 																	to.Ptr("PT12H"),
	// 																	to.Ptr("P1D")},
	// 																	Unit: to.Ptr("CountPerSecond"),
	// 																},
	// 																{
	// 																	Name: to.Ptr("WriteIops"),
	// 																	AggregationType: to.Ptr("Average"),
	// 																	Dimensions: []*armnetapp.Dimension{
	// 																	},
	// 																	DisplayDescription: to.Ptr("Write In/out operations per second"),
	// 																	DisplayName: to.Ptr("Write iops"),
	// 																	EnableRegionalMdmAccount: to.Ptr(true),
	// 																	FillGapWithZero: to.Ptr(false),
	// 																	InternalMetricName: to.Ptr("WriteIops"),
	// 																	IsInternal: to.Ptr(false),
	// 																	SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																	SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																	SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																		to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																		SupportedTimeGrainTypes: []*string{
	// 																			to.Ptr("PT5M"),
	// 																			to.Ptr("PT15M"),
	// 																			to.Ptr("PT30M"),
	// 																			to.Ptr("PT1H"),
	// 																			to.Ptr("PT6H"),
	// 																			to.Ptr("PT12H"),
	// 																			to.Ptr("P1D")},
	// 																			Unit: to.Ptr("CountPerSecond"),
	// 																		},
	// 																		{
	// 																			Name: to.Ptr("VolumeAllocatedSize"),
	// 																			AggregationType: to.Ptr("Average"),
	// 																			Dimensions: []*armnetapp.Dimension{
	// 																			},
	// 																			DisplayDescription: to.Ptr("The provisioned size of a volume"),
	// 																			DisplayName: to.Ptr("Volume allocated size"),
	// 																			EnableRegionalMdmAccount: to.Ptr(true),
	// 																			FillGapWithZero: to.Ptr(false),
	// 																			InternalMetricName: to.Ptr("VolumeAllocatedSize"),
	// 																			IsInternal: to.Ptr(false),
	// 																			SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																			SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																			SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																				to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																				SupportedTimeGrainTypes: []*string{
	// 																					to.Ptr("PT5M"),
	// 																					to.Ptr("PT15M"),
	// 																					to.Ptr("PT30M"),
	// 																					to.Ptr("PT1H"),
	// 																					to.Ptr("PT6H"),
	// 																					to.Ptr("PT12H"),
	// 																					to.Ptr("P1D")},
	// 																					Unit: to.Ptr("Bytes"),
	// 																				},
	// 																				{
	// 																					Name: to.Ptr("VolumeCoolTierSize"),
	// 																					AggregationType: to.Ptr("Average"),
	// 																					Dimensions: []*armnetapp.Dimension{
	// 																					},
	// 																					DisplayDescription: to.Ptr("Volume Footprint for Cool Tier"),
	// 																					DisplayName: to.Ptr("Volume cool tier size"),
	// 																					EnableRegionalMdmAccount: to.Ptr(true),
	// 																					FillGapWithZero: to.Ptr(false),
	// 																					InternalMetricName: to.Ptr("VolumeCoolTierSize"),
	// 																					IsInternal: to.Ptr(false),
	// 																					SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																					SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																					SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																						to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																						SupportedTimeGrainTypes: []*string{
	// 																							to.Ptr("PT5M"),
	// 																							to.Ptr("PT15M"),
	// 																							to.Ptr("PT30M"),
	// 																							to.Ptr("PT1H"),
	// 																							to.Ptr("PT6H"),
	// 																							to.Ptr("PT12H"),
	// 																							to.Ptr("P1D")},
	// 																							Unit: to.Ptr("Bytes"),
	// 																						},
	// 																						{
	// 																							Name: to.Ptr("VolumeCoolTierDataReadSize"),
	// 																							AggregationType: to.Ptr("Average"),
	// 																							Dimensions: []*armnetapp.Dimension{
	// 																							},
	// 																							DisplayDescription: to.Ptr("Data read in using GET per volume"),
	// 																							DisplayName: to.Ptr("Volume cool tier data read size"),
	// 																							EnableRegionalMdmAccount: to.Ptr(true),
	// 																							FillGapWithZero: to.Ptr(false),
	// 																							InternalMetricName: to.Ptr("VolumeCoolTierDataReadSize"),
	// 																							IsInternal: to.Ptr(false),
	// 																							SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																							SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																							SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																								to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																								SupportedTimeGrainTypes: []*string{
	// 																									to.Ptr("PT5M"),
	// 																									to.Ptr("PT15M"),
	// 																									to.Ptr("PT30M"),
	// 																									to.Ptr("PT1H"),
	// 																									to.Ptr("PT6H"),
	// 																									to.Ptr("PT12H"),
	// 																									to.Ptr("P1D")},
	// 																									Unit: to.Ptr("Bytes"),
	// 																								},
	// 																								{
	// 																									Name: to.Ptr("VolumeCoolTierDataWriteSize"),
	// 																									AggregationType: to.Ptr("Average"),
	// 																									Dimensions: []*armnetapp.Dimension{
	// 																									},
	// 																									DisplayDescription: to.Ptr("Data tiered out using PUT per volume"),
	// 																									DisplayName: to.Ptr("Volume cool tier data write size"),
	// 																									EnableRegionalMdmAccount: to.Ptr(true),
	// 																									FillGapWithZero: to.Ptr(false),
	// 																									InternalMetricName: to.Ptr("VolumeCoolTierDataWriteSize"),
	// 																									IsInternal: to.Ptr(false),
	// 																									SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																									SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																									SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																										to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																										SupportedTimeGrainTypes: []*string{
	// 																											to.Ptr("PT5M"),
	// 																											to.Ptr("PT15M"),
	// 																											to.Ptr("PT30M"),
	// 																											to.Ptr("PT1H"),
	// 																											to.Ptr("PT6H"),
	// 																											to.Ptr("PT12H"),
	// 																											to.Ptr("P1D")},
	// 																											Unit: to.Ptr("Bytes"),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("XregionReplicationLastTransferDuration"),
	// 																											AggregationType: to.Ptr("Average"),
	// 																											Dimensions: []*armnetapp.Dimension{
	// 																											},
	// 																											DisplayDescription: to.Ptr("The amount of time in seconds it took for the last transfer to complete."),
	// 																											DisplayName: to.Ptr("Volume replication last transfer duration"),
	// 																											EnableRegionalMdmAccount: to.Ptr(true),
	// 																											FillGapWithZero: to.Ptr(false),
	// 																											InternalMetricName: to.Ptr("XregionReplicationLastTransferDuration"),
	// 																											IsInternal: to.Ptr(false),
	// 																											SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																											SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																											SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																												to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																												SupportedTimeGrainTypes: []*string{
	// 																													to.Ptr("PT5M"),
	// 																													to.Ptr("PT15M"),
	// 																													to.Ptr("PT30M"),
	// 																													to.Ptr("PT1H"),
	// 																													to.Ptr("PT6H"),
	// 																													to.Ptr("PT12H"),
	// 																													to.Ptr("P1D")},
	// 																													Unit: to.Ptr("Seconds"),
	// 																												},
	// 																												{
	// 																													Name: to.Ptr("XregionReplicationLastTransferSize"),
	// 																													AggregationType: to.Ptr("Average"),
	// 																													Dimensions: []*armnetapp.Dimension{
	// 																													},
	// 																													DisplayDescription: to.Ptr("The total number of bytes transferred as part of the last transfer."),
	// 																													DisplayName: to.Ptr("Volume replication last transfer size"),
	// 																													EnableRegionalMdmAccount: to.Ptr(true),
	// 																													FillGapWithZero: to.Ptr(false),
	// 																													InternalMetricName: to.Ptr("XregionReplicationLastTransferSize"),
	// 																													IsInternal: to.Ptr(false),
	// 																													SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																													SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																													SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																														to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																														SupportedTimeGrainTypes: []*string{
	// 																															to.Ptr("PT5M"),
	// 																															to.Ptr("PT15M"),
	// 																															to.Ptr("PT30M"),
	// 																															to.Ptr("PT1H"),
	// 																															to.Ptr("PT6H"),
	// 																															to.Ptr("PT12H"),
	// 																															to.Ptr("P1D")},
	// 																															Unit: to.Ptr("Bytes"),
	// 																														},
	// 																														{
	// 																															Name: to.Ptr("XregionReplicationHealthy"),
	// 																															AggregationType: to.Ptr("Average"),
	// 																															Dimensions: []*armnetapp.Dimension{
	// 																															},
	// 																															DisplayDescription: to.Ptr("Condition of the relationship, 1 or 0."),
	// 																															DisplayName: to.Ptr("Is volume replication status healthy"),
	// 																															EnableRegionalMdmAccount: to.Ptr(true),
	// 																															FillGapWithZero: to.Ptr(false),
	// 																															InternalMetricName: to.Ptr("XregionReplicationHealthy"),
	// 																															IsInternal: to.Ptr(false),
	// 																															SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																															SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																															SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																SupportedTimeGrainTypes: []*string{
	// 																																	to.Ptr("PT5M"),
	// 																																	to.Ptr("PT15M"),
	// 																																	to.Ptr("PT30M"),
	// 																																	to.Ptr("PT1H"),
	// 																																	to.Ptr("PT6H"),
	// 																																	to.Ptr("PT12H"),
	// 																																	to.Ptr("P1D")},
	// 																																	Unit: to.Ptr("Count"),
	// 																																},
	// 																																{
	// 																																	Name: to.Ptr("XregionReplicationLagTime"),
	// 																																	AggregationType: to.Ptr("Average"),
	// 																																	Dimensions: []*armnetapp.Dimension{
	// 																																	},
	// 																																	DisplayDescription: to.Ptr("The amount of time in seconds by which the data on the mirror lags behind the source."),
	// 																																	DisplayName: to.Ptr("Volume replication lag time"),
	// 																																	EnableRegionalMdmAccount: to.Ptr(true),
	// 																																	FillGapWithZero: to.Ptr(false),
	// 																																	InternalMetricName: to.Ptr("XregionReplicationLagTime"),
	// 																																	IsInternal: to.Ptr(false),
	// 																																	SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																	SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																	SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																		to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																		SupportedTimeGrainTypes: []*string{
	// 																																			to.Ptr("PT5M"),
	// 																																			to.Ptr("PT15M"),
	// 																																			to.Ptr("PT30M"),
	// 																																			to.Ptr("PT1H"),
	// 																																			to.Ptr("PT6H"),
	// 																																			to.Ptr("PT12H"),
	// 																																			to.Ptr("P1D")},
	// 																																			Unit: to.Ptr("Seconds"),
	// 																																		},
	// 																																		{
	// 																																			Name: to.Ptr("XregionReplicationTotalTransferBytes"),
	// 																																			AggregationType: to.Ptr("Average"),
	// 																																			Dimensions: []*armnetapp.Dimension{
	// 																																			},
	// 																																			DisplayDescription: to.Ptr("Cumulative bytes transferred for the relationship."),
	// 																																			DisplayName: to.Ptr("Volume replication total transfer"),
	// 																																			EnableRegionalMdmAccount: to.Ptr(true),
	// 																																			FillGapWithZero: to.Ptr(false),
	// 																																			InternalMetricName: to.Ptr("XregionReplicationTotalTransferBytes"),
	// 																																			IsInternal: to.Ptr(false),
	// 																																			SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																			SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																			SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																				to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																				SupportedTimeGrainTypes: []*string{
	// 																																					to.Ptr("PT5M"),
	// 																																					to.Ptr("PT15M"),
	// 																																					to.Ptr("PT30M"),
	// 																																					to.Ptr("PT1H"),
	// 																																					to.Ptr("PT6H"),
	// 																																					to.Ptr("PT12H"),
	// 																																					to.Ptr("P1D")},
	// 																																					Unit: to.Ptr("Bytes"),
	// 																																				},
	// 																																				{
	// 																																					Name: to.Ptr("XregionReplicationRelationshipProgress"),
	// 																																					AggregationType: to.Ptr("Average"),
	// 																																					Dimensions: []*armnetapp.Dimension{
	// 																																					},
	// 																																					DisplayDescription: to.Ptr("Total amount of data transferred for the current transfer operation."),
	// 																																					DisplayName: to.Ptr("Volume replication progress"),
	// 																																					EnableRegionalMdmAccount: to.Ptr(true),
	// 																																					FillGapWithZero: to.Ptr(false),
	// 																																					InternalMetricName: to.Ptr("XregionReplicationRelationshipProgress"),
	// 																																					IsInternal: to.Ptr(false),
	// 																																					SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																					SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																					SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																						to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																						SupportedTimeGrainTypes: []*string{
	// 																																							to.Ptr("PT5M"),
	// 																																							to.Ptr("PT15M"),
	// 																																							to.Ptr("PT30M"),
	// 																																							to.Ptr("PT1H"),
	// 																																							to.Ptr("PT6H"),
	// 																																							to.Ptr("PT12H"),
	// 																																							to.Ptr("P1D")},
	// 																																							Unit: to.Ptr("Bytes"),
	// 																																						},
	// 																																						{
	// 																																							Name: to.Ptr("XregionReplicationRelationshipTransferring"),
	// 																																							AggregationType: to.Ptr("Average"),
	// 																																							Dimensions: []*armnetapp.Dimension{
	// 																																							},
	// 																																							DisplayDescription: to.Ptr("Whether the status of the Volume Replication is 'transferring'."),
	// 																																							DisplayName: to.Ptr("Is volume replication transferring"),
	// 																																							EnableRegionalMdmAccount: to.Ptr(true),
	// 																																							FillGapWithZero: to.Ptr(false),
	// 																																							InternalMetricName: to.Ptr("XregionReplicationRelationshipTransferring"),
	// 																																							IsInternal: to.Ptr(false),
	// 																																							SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																							SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																							SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																								to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																								SupportedTimeGrainTypes: []*string{
	// 																																									to.Ptr("PT5M"),
	// 																																									to.Ptr("PT15M"),
	// 																																									to.Ptr("PT30M"),
	// 																																									to.Ptr("PT1H"),
	// 																																									to.Ptr("PT6H"),
	// 																																									to.Ptr("PT12H"),
	// 																																									to.Ptr("P1D")},
	// 																																									Unit: to.Ptr("Count"),
	// 																																								},
	// 																																								{
	// 																																									Name: to.Ptr("CbsVolumeLogicalBackupBytes"),
	// 																																									AggregationType: to.Ptr("Average"),
	// 																																									Dimensions: []*armnetapp.Dimension{
	// 																																									},
	// 																																									DisplayDescription: to.Ptr("Total bytes backed up for this Volume."),
	// 																																									DisplayName: to.Ptr("Volume Backup Bytes"),
	// 																																									EnableRegionalMdmAccount: to.Ptr(true),
	// 																																									FillGapWithZero: to.Ptr(false),
	// 																																									InternalMetricName: to.Ptr("CbsVolumeLogicalBackupBytes"),
	// 																																									IsInternal: to.Ptr(false),
	// 																																									SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																									SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																									SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																										to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																										SupportedTimeGrainTypes: []*string{
	// 																																											to.Ptr("PT5M"),
	// 																																											to.Ptr("PT15M"),
	// 																																											to.Ptr("PT30M"),
	// 																																											to.Ptr("PT1H"),
	// 																																											to.Ptr("PT6H"),
	// 																																											to.Ptr("PT12H"),
	// 																																											to.Ptr("P1D")},
	// 																																											Unit: to.Ptr("Bytes"),
	// 																																										},
	// 																																										{
	// 																																											Name: to.Ptr("CbsVolumeProtected"),
	// 																																											AggregationType: to.Ptr("Average"),
	// 																																											Dimensions: []*armnetapp.Dimension{
	// 																																											},
	// 																																											DisplayDescription: to.Ptr("Is backup enabled for the volume? 1 if yes, 0 if no."),
	// 																																											DisplayName: to.Ptr("Is Volume Backup Enabled"),
	// 																																											EnableRegionalMdmAccount: to.Ptr(true),
	// 																																											FillGapWithZero: to.Ptr(false),
	// 																																											InternalMetricName: to.Ptr("CbsVolumeProtected"),
	// 																																											IsInternal: to.Ptr(false),
	// 																																											SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																											SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																											SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																												to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																												SupportedTimeGrainTypes: []*string{
	// 																																													to.Ptr("PT5M"),
	// 																																													to.Ptr("PT15M"),
	// 																																													to.Ptr("PT30M"),
	// 																																													to.Ptr("PT1H"),
	// 																																													to.Ptr("PT6H"),
	// 																																													to.Ptr("PT12H"),
	// 																																													to.Ptr("P1D")},
	// 																																													Unit: to.Ptr("Count"),
	// 																																												},
	// 																																												{
	// 																																													Name: to.Ptr("CbsVolumeBackupActive"),
	// 																																													AggregationType: to.Ptr("Average"),
	// 																																													Dimensions: []*armnetapp.Dimension{
	// 																																													},
	// 																																													DisplayDescription: to.Ptr("Is the backup policy suspended for the volume? 0 if yes, 1 if no."),
	// 																																													DisplayName: to.Ptr("Is Volume Backup suspended"),
	// 																																													EnableRegionalMdmAccount: to.Ptr(true),
	// 																																													FillGapWithZero: to.Ptr(false),
	// 																																													InternalMetricName: to.Ptr("CbsVolumeBackupActive"),
	// 																																													IsInternal: to.Ptr(false),
	// 																																													SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																													SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																													SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																														to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																														SupportedTimeGrainTypes: []*string{
	// 																																															to.Ptr("PT5M"),
	// 																																															to.Ptr("PT15M"),
	// 																																															to.Ptr("PT30M"),
	// 																																															to.Ptr("PT1H"),
	// 																																															to.Ptr("PT6H"),
	// 																																															to.Ptr("PT12H"),
	// 																																															to.Ptr("P1D")},
	// 																																															Unit: to.Ptr("Count"),
	// 																																														},
	// 																																														{
	// 																																															Name: to.Ptr("CbsVolumeOperationTransferredBytes"),
	// 																																															AggregationType: to.Ptr("Average"),
	// 																																															Dimensions: []*armnetapp.Dimension{
	// 																																															},
	// 																																															DisplayDescription: to.Ptr("Total bytes transferred for last backup or restore operation."),
	// 																																															DisplayName: to.Ptr("Volume Backup Last Transferred Bytes"),
	// 																																															EnableRegionalMdmAccount: to.Ptr(true),
	// 																																															FillGapWithZero: to.Ptr(false),
	// 																																															InternalMetricName: to.Ptr("CbsVolumeOperationTransferredBytes"),
	// 																																															IsInternal: to.Ptr(false),
	// 																																															SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																															SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																															SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																SupportedTimeGrainTypes: []*string{
	// 																																																	to.Ptr("PT5M"),
	// 																																																	to.Ptr("PT15M"),
	// 																																																	to.Ptr("PT30M"),
	// 																																																	to.Ptr("PT1H"),
	// 																																																	to.Ptr("PT6H"),
	// 																																																	to.Ptr("PT12H"),
	// 																																																	to.Ptr("P1D")},
	// 																																																	Unit: to.Ptr("Bytes"),
	// 																																																},
	// 																																																{
	// 																																																	Name: to.Ptr("CbsVolumeOperationComplete"),
	// 																																																	AggregationType: to.Ptr("Average"),
	// 																																																	Dimensions: []*armnetapp.Dimension{
	// 																																																	},
	// 																																																	DisplayDescription: to.Ptr("Did the last volume backup or restore operation complete successfully? 1 if yes, 0 if no."),
	// 																																																	DisplayName: to.Ptr("Is Volume Backup Operation Complete"),
	// 																																																	EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																	FillGapWithZero: to.Ptr(false),
	// 																																																	InternalMetricName: to.Ptr("CbsVolumeOperationComplete"),
	// 																																																	IsInternal: to.Ptr(false),
	// 																																																	SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																	SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																	SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																		to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																		SupportedTimeGrainTypes: []*string{
	// 																																																			to.Ptr("PT5M"),
	// 																																																			to.Ptr("PT15M"),
	// 																																																			to.Ptr("PT30M"),
	// 																																																			to.Ptr("PT1H"),
	// 																																																			to.Ptr("PT6H"),
	// 																																																			to.Ptr("PT12H"),
	// 																																																			to.Ptr("P1D")},
	// 																																																			Unit: to.Ptr("Count"),
	// 																																																		},
	// 																																																		{
	// 																																																			Name: to.Ptr("VolumeConsumedSizePercentage"),
	// 																																																			AggregationType: to.Ptr("Average"),
	// 																																																			Dimensions: []*armnetapp.Dimension{
	// 																																																			},
	// 																																																			DisplayDescription: to.Ptr("The percentage of the volume consumed including snapshots."),
	// 																																																			DisplayName: to.Ptr("Percentage Volume Consumed Size"),
	// 																																																			EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																			FillGapWithZero: to.Ptr(false),
	// 																																																			InternalMetricName: to.Ptr("VolumeConsumedSizePercentage"),
	// 																																																			IsInternal: to.Ptr(false),
	// 																																																			SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																			SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																			SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																				to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																				SupportedTimeGrainTypes: []*string{
	// 																																																					to.Ptr("PT5M"),
	// 																																																					to.Ptr("PT15M"),
	// 																																																					to.Ptr("PT30M"),
	// 																																																					to.Ptr("PT1H"),
	// 																																																					to.Ptr("PT6H"),
	// 																																																					to.Ptr("PT12H"),
	// 																																																					to.Ptr("P1D")},
	// 																																																					Unit: to.Ptr("Percent"),
	// 																																																				},
	// 																																																				{
	// 																																																					Name: to.Ptr("OtherThroughput"),
	// 																																																					AggregationType: to.Ptr("Average"),
	// 																																																					Dimensions: []*armnetapp.Dimension{
	// 																																																					},
	// 																																																					DisplayDescription: to.Ptr("Other throughput (that is not read or write) in bytes per second"),
	// 																																																					DisplayName: to.Ptr("Other throughput"),
	// 																																																					EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																					FillGapWithZero: to.Ptr(false),
	// 																																																					InternalMetricName: to.Ptr("OtherThroughput"),
	// 																																																					IsInternal: to.Ptr(false),
	// 																																																					SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																					SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																					SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																						to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																						SupportedTimeGrainTypes: []*string{
	// 																																																							to.Ptr("PT5M"),
	// 																																																							to.Ptr("PT15M"),
	// 																																																							to.Ptr("PT30M"),
	// 																																																							to.Ptr("PT1H"),
	// 																																																							to.Ptr("PT6H"),
	// 																																																							to.Ptr("PT12H"),
	// 																																																							to.Ptr("P1D")},
	// 																																																							Unit: to.Ptr("BytesPerSecond"),
	// 																																																						},
	// 																																																						{
	// 																																																							Name: to.Ptr("ReadThroughput"),
	// 																																																							AggregationType: to.Ptr("Average"),
	// 																																																							Dimensions: []*armnetapp.Dimension{
	// 																																																							},
	// 																																																							DisplayDescription: to.Ptr("Read throughput in bytes per second"),
	// 																																																							DisplayName: to.Ptr("Read throughput"),
	// 																																																							EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																							FillGapWithZero: to.Ptr(false),
	// 																																																							InternalMetricName: to.Ptr("ReadThroughput"),
	// 																																																							IsInternal: to.Ptr(false),
	// 																																																							SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																							SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																							SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																								to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																								SupportedTimeGrainTypes: []*string{
	// 																																																									to.Ptr("PT5M"),
	// 																																																									to.Ptr("PT15M"),
	// 																																																									to.Ptr("PT30M"),
	// 																																																									to.Ptr("PT1H"),
	// 																																																									to.Ptr("PT6H"),
	// 																																																									to.Ptr("PT12H"),
	// 																																																									to.Ptr("P1D")},
	// 																																																									Unit: to.Ptr("BytesPerSecond"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("TotalThroughput"),
	// 																																																									AggregationType: to.Ptr("Average"),
	// 																																																									Dimensions: []*armnetapp.Dimension{
	// 																																																									},
	// 																																																									DisplayDescription: to.Ptr("Sum of all throughput in bytes per second"),
	// 																																																									DisplayName: to.Ptr("Total throughput"),
	// 																																																									EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																									FillGapWithZero: to.Ptr(false),
	// 																																																									InternalMetricName: to.Ptr("TotalThroughput"),
	// 																																																									IsInternal: to.Ptr(false),
	// 																																																									SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																									SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																									SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																										to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																										SupportedTimeGrainTypes: []*string{
	// 																																																											to.Ptr("PT5M"),
	// 																																																											to.Ptr("PT15M"),
	// 																																																											to.Ptr("PT30M"),
	// 																																																											to.Ptr("PT1H"),
	// 																																																											to.Ptr("PT6H"),
	// 																																																											to.Ptr("PT12H"),
	// 																																																											to.Ptr("P1D")},
	// 																																																											Unit: to.Ptr("BytesPerSecond"),
	// 																																																										},
	// 																																																										{
	// 																																																											Name: to.Ptr("WriteThroughput"),
	// 																																																											AggregationType: to.Ptr("Average"),
	// 																																																											Dimensions: []*armnetapp.Dimension{
	// 																																																											},
	// 																																																											DisplayDescription: to.Ptr("Write throughput in bytes per second"),
	// 																																																											DisplayName: to.Ptr("Write throughput"),
	// 																																																											EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																											FillGapWithZero: to.Ptr(false),
	// 																																																											InternalMetricName: to.Ptr("WriteThroughput"),
	// 																																																											IsInternal: to.Ptr(false),
	// 																																																											SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																											SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																											SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																												to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																												SupportedTimeGrainTypes: []*string{
	// 																																																													to.Ptr("PT5M"),
	// 																																																													to.Ptr("PT15M"),
	// 																																																													to.Ptr("PT30M"),
	// 																																																													to.Ptr("PT1H"),
	// 																																																													to.Ptr("PT6H"),
	// 																																																													to.Ptr("PT12H"),
	// 																																																													to.Ptr("P1D")},
	// 																																																													Unit: to.Ptr("BytesPerSecond"),
	// 																																																											}},
	// 																																																										},
	// 																																																									},
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/providers/Microsoft.Insights/diagnosticSettings/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Gets the diagnostic setting for the resource."),
	// 																																																										Operation: to.Ptr("Read diagnostic setting."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/providers/Microsoft.Insights/diagnosticSettings/write"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Creates or updates the diagnostic setting for the resource."),
	// 																																																										Operation: to.Ptr("Write diagnostic setting."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/AuthorizeReplication/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Authorize the source volume replication"),
	// 																																																										Operation: to.Ptr("Authorize Replication"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/ResyncReplication/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Resync the replication on the destination volume"),
	// 																																																										Operation: to.Ptr("Resync Replication"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/DeleteReplication/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Delete the replication on the destination volume"),
	// 																																																										Operation: to.Ptr("Delete Replication"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/ReplicationStatus/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Reads the statuses of the Volume Replication."),
	// 																																																										Operation: to.Ptr("Read Volume Replication Status."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/MountTargets/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Reads a mount target resource."),
	// 																																																										Operation: to.Ptr("Read mount target resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/BackupStatus/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/RestoreStatus/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/PoolChange/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Moves volume to another pool."),
	// 																																																										Operation: to.Ptr("Change pool for volume"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/RelocateVolume/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Relocate volume to a new stamp."),
	// 																																																										Operation: to.Ptr("Relocate volume to a new stamp."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/FinalizeRelocation/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Finalize relocation by cleaning up the old volume."),
	// 																																																										Operation: to.Ptr("Finalize relocation of volume."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/RevertRelocation/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Revert the relocation and revert back to the old volume."),
	// 																																																										Operation: to.Ptr("Revert the relocation of volume."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Volumes resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Reads an account resource."),
	// 																																																										Operation: to.Ptr("Read account resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Accounts resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/write"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Writes an account resource."),
	// 																																																										Operation: to.Ptr("Write account resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Accounts resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/delete"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Deletes a account resource."),
	// 																																																										Operation: to.Ptr("Delete account resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Accounts resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/RenewCredentials/action"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Renews MSI credentials of account, if account has MSI credentials that are due for renewal."),
	// 																																																										Operation: to.Ptr("Renew MSI credentials, if possible."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Accounts resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Reads a pool resource."),
	// 																																																										Operation: to.Ptr("Read pool resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Pools resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/write"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Writes a pool resource."),
	// 																																																										Operation: to.Ptr("Write pool resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Pools resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/delete"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Deletes a pool resource."),
	// 																																																										Operation: to.Ptr("Delete pool resource"),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Pools resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("user,system"),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/providers/Microsoft.Insights/metricDefinitions/read"),
	// 																																																									Display: &armnetapp.OperationDisplay{
	// 																																																										Description: to.Ptr("Gets the available metrics for Volume resource."),
	// 																																																										Operation: to.Ptr("Read volume metric definitions."),
	// 																																																										Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																										Resource: to.Ptr("Pools resource type"),
	// 																																																									},
	// 																																																									Origin: to.Ptr("system"),
	// 																																																									Properties: &armnetapp.OperationProperties{
	// 																																																										ServiceSpecification: &armnetapp.ServiceSpecification{
	// 																																																											MetricSpecifications: []*armnetapp.MetricSpecification{
	// 																																																												{
	// 																																																													Name: to.Ptr("VolumePoolAllocatedUsed"),
	// 																																																													AggregationType: to.Ptr("Average"),
	// 																																																													Dimensions: []*armnetapp.Dimension{
	// 																																																													},
	// 																																																													DisplayDescription: to.Ptr("Allocated used size of the pool"),
	// 																																																													DisplayName: to.Ptr("Pool Allocated To Volume Size"),
	// 																																																													EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																													FillGapWithZero: to.Ptr(false),
	// 																																																													InternalMetricName: to.Ptr("VolumePoolAllocatedUsed"),
	// 																																																													IsInternal: to.Ptr(false),
	// 																																																													SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																													SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																													SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																														to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																														SupportedTimeGrainTypes: []*string{
	// 																																																															to.Ptr("PT5M"),
	// 																																																															to.Ptr("PT15M"),
	// 																																																															to.Ptr("PT30M"),
	// 																																																															to.Ptr("PT1H"),
	// 																																																															to.Ptr("PT6H"),
	// 																																																															to.Ptr("PT12H"),
	// 																																																															to.Ptr("P1D")},
	// 																																																															Unit: to.Ptr("Bytes"),
	// 																																																														},
	// 																																																														{
	// 																																																															Name: to.Ptr("VolumePoolTotalLogicalSize"),
	// 																																																															AggregationType: to.Ptr("Average"),
	// 																																																															Dimensions: []*armnetapp.Dimension{
	// 																																																															},
	// 																																																															DisplayDescription: to.Ptr("Sum of the logical size of all the volumes belonging to the pool"),
	// 																																																															DisplayName: to.Ptr("Pool Consumed Size"),
	// 																																																															EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																															FillGapWithZero: to.Ptr(false),
	// 																																																															InternalMetricName: to.Ptr("VolumePoolTotalLogicalSize"),
	// 																																																															IsInternal: to.Ptr(false),
	// 																																																															SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																															SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																															SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																																to.Ptr(armnetapp.MetricAggregationTypeAverage),
	// 																																																																to.Ptr(armnetapp.MetricAggregationType("Total"))},
	// 																																																																SupportedTimeGrainTypes: []*string{
	// 																																																																	to.Ptr("PT5M"),
	// 																																																																	to.Ptr("PT15M"),
	// 																																																																	to.Ptr("PT30M"),
	// 																																																																	to.Ptr("PT1H"),
	// 																																																																	to.Ptr("PT6H"),
	// 																																																																	to.Ptr("PT12H"),
	// 																																																																	to.Ptr("P1D")},
	// 																																																																	Unit: to.Ptr("Bytes"),
	// 																																																																},
	// 																																																																{
	// 																																																																	Name: to.Ptr("VolumePoolAllocatedSize"),
	// 																																																																	AggregationType: to.Ptr("Average"),
	// 																																																																	Dimensions: []*armnetapp.Dimension{
	// 																																																																	},
	// 																																																																	DisplayDescription: to.Ptr("Provisioned size of this pool"),
	// 																																																																	DisplayName: to.Ptr("Pool Allocated Size"),
	// 																																																																	EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																																	FillGapWithZero: to.Ptr(false),
	// 																																																																	InternalMetricName: to.Ptr("VolumePoolAllocatedSize"),
	// 																																																																	IsInternal: to.Ptr(false),
	// 																																																																	SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																																	SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																																	SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																																		to.Ptr(armnetapp.MetricAggregationTypeAverage),
	// 																																																																		to.Ptr(armnetapp.MetricAggregationType("Total"))},
	// 																																																																		SupportedTimeGrainTypes: []*string{
	// 																																																																			to.Ptr("PT5M"),
	// 																																																																			to.Ptr("PT15M"),
	// 																																																																			to.Ptr("PT30M"),
	// 																																																																			to.Ptr("PT1H"),
	// 																																																																			to.Ptr("PT6H"),
	// 																																																																			to.Ptr("PT12H"),
	// 																																																																			to.Ptr("P1D")},
	// 																																																																			Unit: to.Ptr("Bytes"),
	// 																																																																		},
	// 																																																																		{
	// 																																																																			Name: to.Ptr("VolumePoolTotalSnapshotSize"),
	// 																																																																			AggregationType: to.Ptr("Average"),
	// 																																																																			Dimensions: []*armnetapp.Dimension{
	// 																																																																			},
	// 																																																																			DisplayDescription: to.Ptr("Sum of snapshot size of all volumes in this pool"),
	// 																																																																			DisplayName: to.Ptr("Total Snapshot size for the pool"),
	// 																																																																			EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																																			FillGapWithZero: to.Ptr(false),
	// 																																																																			InternalMetricName: to.Ptr("VolumePoolTotalSnapshotSize"),
	// 																																																																			IsInternal: to.Ptr(false),
	// 																																																																			SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																																			SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																																			SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																																				to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																																				SupportedTimeGrainTypes: []*string{
	// 																																																																					to.Ptr("PT5M"),
	// 																																																																					to.Ptr("PT15M"),
	// 																																																																					to.Ptr("PT30M"),
	// 																																																																					to.Ptr("PT1H"),
	// 																																																																					to.Ptr("PT6H"),
	// 																																																																					to.Ptr("PT12H"),
	// 																																																																					to.Ptr("P1D")},
	// 																																																																					Unit: to.Ptr("Bytes"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("VolumePoolProvisionedThroughput"),
	// 																																																																					AggregationType: to.Ptr("Average"),
	// 																																																																					Dimensions: []*armnetapp.Dimension{
	// 																																																																					},
	// 																																																																					DisplayDescription: to.Ptr("Provisioned throughput of this pool"),
	// 																																																																					DisplayName: to.Ptr("Provisioned throughput for the pool"),
	// 																																																																					EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																																					FillGapWithZero: to.Ptr(false),
	// 																																																																					InternalMetricName: to.Ptr("VolumePoolProvisionedThroughput"),
	// 																																																																					IsInternal: to.Ptr(false),
	// 																																																																					SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																																					SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																																					SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																																						to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																																						SupportedTimeGrainTypes: []*string{
	// 																																																																							to.Ptr("PT5M"),
	// 																																																																							to.Ptr("PT15M"),
	// 																																																																							to.Ptr("PT30M"),
	// 																																																																							to.Ptr("PT1H"),
	// 																																																																							to.Ptr("PT6H"),
	// 																																																																							to.Ptr("PT12H"),
	// 																																																																							to.Ptr("P1D")},
	// 																																																																							Unit: to.Ptr("BytesPerSecond"),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("VolumePoolAllocatedToVolumeThroughput"),
	// 																																																																							AggregationType: to.Ptr("Average"),
	// 																																																																							Dimensions: []*armnetapp.Dimension{
	// 																																																																							},
	// 																																																																							DisplayDescription: to.Ptr("Sum of the throughput of all the volumes belonging to the pool"),
	// 																																																																							DisplayName: to.Ptr("Pool allocated throughput"),
	// 																																																																							EnableRegionalMdmAccount: to.Ptr(true),
	// 																																																																							FillGapWithZero: to.Ptr(false),
	// 																																																																							InternalMetricName: to.Ptr("VolumePoolAllocatedToVolumeThroughput"),
	// 																																																																							IsInternal: to.Ptr(false),
	// 																																																																							SourceMdmAccount: to.Ptr("MicrosoftNetAppShoebox2"),
	// 																																																																							SourceMdmNamespace: to.Ptr("NetAppUsageAndMetrics"),
	// 																																																																							SupportedAggregationTypes: []*armnetapp.MetricAggregationType{
	// 																																																																								to.Ptr(armnetapp.MetricAggregationTypeAverage)},
	// 																																																																								SupportedTimeGrainTypes: []*string{
	// 																																																																									to.Ptr("PT5M"),
	// 																																																																									to.Ptr("PT15M"),
	// 																																																																									to.Ptr("PT30M"),
	// 																																																																									to.Ptr("PT1H"),
	// 																																																																									to.Ptr("PT6H"),
	// 																																																																									to.Ptr("PT12H"),
	// 																																																																									to.Ptr("P1D")},
	// 																																																																									Unit: to.Ptr("BytesPerSecond"),
	// 																																																																							}},
	// 																																																																						},
	// 																																																																					},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/providers/Microsoft.Insights/logDefinitions/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Gets the log definitions for the resource."),
	// 																																																																						Operation: to.Ptr("Read log definitions."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Pools resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("system"),
	// 																																																																					Properties: &armnetapp.OperationProperties{
	// 																																																																						ServiceSpecification: &armnetapp.ServiceSpecification{
	// 																																																																							LogSpecifications: []*armnetapp.LogSpecification{
	// 																																																																								{
	// 																																																																									Name: to.Ptr("Autoscale"),
	// 																																																																									DisplayName: to.Ptr("Capacity Pool Autoscaled"),
	// 																																																																							}},
	// 																																																																						},
	// 																																																																					},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/providers/Microsoft.Insights/diagnosticSettings/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Gets the diagnostic setting for the resource."),
	// 																																																																						Operation: to.Ptr("Read diagnostic setting."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Pools resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/providers/Microsoft.Insights/diagnosticSettings/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Creates or updates the diagnostic setting for the resource."),
	// 																																																																						Operation: to.Ptr("Write diagnostic setting."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Pools resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a snapshot resource."),
	// 																																																																						Operation: to.Ptr("Read snapshot resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshots resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Writes a snapshot resource."),
	// 																																																																						Operation: to.Ptr("Write snapshot resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshots resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Deletes a snapshot resource."),
	// 																																																																						Operation: to.Ptr("Delete snapshot resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshots resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots/RestoreFiles/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Restores files from a snapshot resource"),
	// 																																																																						Operation: to.Ptr("Single File Snapshot Restore"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshots resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Subvolume resource type."),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Write a subvolume resource."),
	// 																																																																						Operation: to.Ptr("Write subvolume Resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Subvolume resource type."),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Subvolume resource type."),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes/GetMetadata/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Read subvolume metadata resource."),
	// 																																																																						Operation: to.Ptr("Subvolume Metadata resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Subvolume resource type."),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a snapshot policy resource."),
	// 																																																																						Operation: to.Ptr("Read snapshot policy resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshot Policies resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Writes a snapshot policy resource."),
	// 																																																																						Operation: to.Ptr("Write snapshot policy resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshot Policies resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Deletes a snapshot policy resource."),
	// 																																																																						Operation: to.Ptr("Delete snapshot policy resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshot Policies resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies/Volumes/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("List volumes connected to snapshot policy"),
	// 																																																																						Operation: to.Ptr("List connected volumes"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshot Policies resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies/ListVolumes/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("List volumes connected to snapshot policy"),
	// 																																																																						Operation: to.Ptr("List connected volumes"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Snapshot Policies resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/backups/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a backup resource."),
	// 																																																																						Operation: to.Ptr("Read backup resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Backup resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/backups/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Writes a backup resource."),
	// 																																																																						Operation: to.Ptr("Write backup resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Backup resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/backups/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Deletes a backup resource."),
	// 																																																																						Operation: to.Ptr("Delete backup resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Backup resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a backup policy resource."),
	// 																																																																						Operation: to.Ptr("Read backup policy resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Backup Policy resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Writes a backup policy resource."),
	// 																																																																						Operation: to.Ptr("Write backup policy resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Backup Policy resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/backupPolicies/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Deletes a backup policy resource."),
	// 																																																																						Operation: to.Ptr("Delete backup policy resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Backup Policy resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/vaults/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a vault resource."),
	// 																																																																						Operation: to.Ptr("Read vault resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Vault resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/accountBackups/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads an account backup resource."),
	// 																																																																						Operation: to.Ptr("Read an account backup resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Account backup resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/accountBackups/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Writes an account backup resource."),
	// 																																																																						Operation: to.Ptr("Write an account backup resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Account backup resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/accountBackups/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Deletes an account backup resource."),
	// 																																																																						Operation: to.Ptr("Delete an account backup resource."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Account backup resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a volume group resource."),
	// 																																																																						Operation: to.Ptr("Read volume group resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Volume Group resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups/write"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Writes a volume group resource."),
	// 																																																																						Operation: to.Ptr("Write volume group resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Volume Group resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups/delete"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Deletes a volume group resource."),
	// 																																																																						Operation: to.Ptr("Delete volume group resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Volume Group resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/locations/quotaLimits/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a Quotalimit resource type."),
	// 																																																																						Operation: to.Ptr("Read QuotaLimit resource type"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("QuotaLimit resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/Operations/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads an operation resources."),
	// 																																																																						Operation: to.Ptr("Read operation resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Operations resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/locations/operationresults/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads an operation result resource."),
	// 																																																																						Operation: to.Ptr("Read operation result resource"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Operation results resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/locations/read"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Reads a location wide operation."),
	// 																																																																						Operation: to.Ptr("Read location wide operation"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Location wide operation"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/locations/checknameavailability/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Check if resource name is available"),
	// 																																																																						Operation: to.Ptr("Check if resource name is available"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("NetApp resources"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/locations/checkfilepathavailability/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Check if file path is available"),
	// 																																																																						Operation: to.Ptr("Check if file path is available"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Volumes resource type"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/unregister/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Unregisters Subscription with Microsoft.NetApp resource provider"),
	// 																																																																						Operation: to.Ptr("Unregister Subscription for Azure NetApp Files"),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("Subscription"),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Microsoft.NetApp/locations/checkinventory/action"),
	// 																																																																					Display: &armnetapp.OperationDisplay{
	// 																																																																						Description: to.Ptr("Checks ReservedCapacity inventory."),
	// 																																																																						Operation: to.Ptr("Checks ReservedCapacity inventory."),
	// 																																																																						Provider: to.Ptr("Microsoft.NetApp Resource Provider"),
	// 																																																																						Resource: to.Ptr("ReservedCapacity reservation resource."),
	// 																																																																					},
	// 																																																																					Origin: to.Ptr("user,system"),
	// 																																																																			}},
	// 																																																																		}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Result of the request to list Cloud Volume operations. It contains a list of operations and a URL link to get the next
	// set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PlacementKeyValuePairs 

type PlacementKeyValuePairs struct {
	// REQUIRED; Key for an application specific parameter for the placement of volumes in the volume group
	Key *string

	// REQUIRED; Value for an application specific parameter for the placement of volumes in the volume group
	Value *string
}

PlacementKeyValuePairs - Application specific parameters for the placement of volumes in the volume group

func (PlacementKeyValuePairs) MarshalJSON 

func (p PlacementKeyValuePairs) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlacementKeyValuePairs.

func (*PlacementKeyValuePairs) UnmarshalJSON 

func (p *PlacementKeyValuePairs) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlacementKeyValuePairs.

type PoolChangeRequest 

type PoolChangeRequest struct {
	// REQUIRED; Resource id of the pool to move volume to
	NewPoolResourceID *string
}

PoolChangeRequest - Pool change request

func (PoolChangeRequest) MarshalJSON 

func (p PoolChangeRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PoolChangeRequest.

func (*PoolChangeRequest) UnmarshalJSON 

func (p *PoolChangeRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PoolChangeRequest.

type PoolPatchProperties 

type PoolPatchProperties struct {
	// If enabled (true) the pool can contain cool Access enabled volumes.
	CoolAccess *bool

	// The qos type of the pool
	QosType *QosType

	// Provisioned size of the pool (in bytes). Allowed values are in 1TiB chunks (value must be multiply of 4398046511104).
	Size *int64
}

PoolPatchProperties - Patchable pool properties

func (PoolPatchProperties) MarshalJSON 

func (p PoolPatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PoolPatchProperties.

func (*PoolPatchProperties) UnmarshalJSON 

func (p *PoolPatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PoolPatchProperties.

type PoolProperties 

type PoolProperties struct {
	// REQUIRED; The service level of the file system
	ServiceLevel *ServiceLevel

	// REQUIRED; Provisioned size of the pool (in bytes). Allowed values are in 1TiB chunks (value must be multiply of 4398046511104).
	Size *int64

	// If enabled (true) the pool can contain cool Access enabled volumes.
	CoolAccess *bool

	// Encryption type of the capacity pool, set encryption type for data at rest for this pool and all volumes in it. This value
	// can only be set when creating new pool.
	EncryptionType *EncryptionType

	// The qos type of the pool
	QosType *QosType

	// READ-ONLY; UUID v4 used to identify the Pool
	PoolID *string

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string

	// READ-ONLY; Total throughput of pool in MiB/s
	TotalThroughputMibps *float32

	// READ-ONLY; Utilized throughput of pool in MiB/s
	UtilizedThroughputMibps *float32
}

PoolProperties - Pool properties

func (PoolProperties) MarshalJSON 

func (p PoolProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PoolProperties.

func (*PoolProperties) UnmarshalJSON 

func (p *PoolProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PoolProperties.

type PoolsClient 

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

PoolsClient contains the methods for the Pools group. Don't use this type directly, use NewPoolsClient() instead.

func NewPoolsClient 

func NewPoolsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PoolsClient, error)

NewPoolsClient creates a new instance of PoolsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PoolsClient) BeginCreateOrUpdate 

func (client *PoolsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, body CapacityPool, options *PoolsClientBeginCreateOrUpdateOptions) (*runtime.Poller[PoolsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or Update a capacity pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • body - Capacity pool object supplied in the body of the operation.
  • options - PoolsClientBeginCreateOrUpdateOptions contains the optional parameters for the PoolsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Pools_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginCreateOrUpdate(ctx, "myRG", "account1", "pool1", armnetapp.CapacityPool{
	Location: to.Ptr("eastus"),
	Properties: &armnetapp.PoolProperties{
		QosType:      to.Ptr(armnetapp.QosTypeAuto),
		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
		Size:         to.Ptr[int64](4398046511104),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CapacityPool = armnetapp.CapacityPool{
// 	Name: to.Ptr("account1/pool1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.PoolProperties{
// 		PoolID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		QosType: to.Ptr(armnetapp.QosTypeAuto),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		Size: to.Ptr[int64](4398046511104),
// 		TotalThroughputMibps: to.Ptr[float32](281.474),
// 	},
// }

Output:

func (*PoolsClient) BeginDelete 

func (client *PoolsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, options *PoolsClientBeginDeleteOptions) (*runtime.Poller[PoolsClientDeleteResponse], error)

BeginDelete - Delete the specified capacity pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • options - PoolsClientBeginDeleteOptions contains the optional parameters for the PoolsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Pools_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginDelete(ctx, "myRG", "account1", "pool1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*PoolsClient) BeginUpdate 

func (client *PoolsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, body CapacityPoolPatch, options *PoolsClientBeginUpdateOptions) (*runtime.Poller[PoolsClientUpdateResponse], error)

BeginUpdate - Patch the specified capacity pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • body - Capacity pool object supplied in the body of the operation.
  • options - PoolsClientBeginUpdateOptions contains the optional parameters for the PoolsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Pools_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginUpdate(ctx, "myRG", "account1", "pool1", armnetapp.CapacityPoolPatch{}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CapacityPool = armnetapp.CapacityPool{
// 	Name: to.Ptr("account1/pool1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.PoolProperties{
// 		PoolID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		QosType: to.Ptr(armnetapp.QosTypeManual),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		Size: to.Ptr[int64](4398046511104),
// 		TotalThroughputMibps: to.Ptr[float32](281.474),
// 		UtilizedThroughputMibps: to.Ptr[float32](100.47),
// 	},
// }

Output:

func (*PoolsClient) Get 

func (client *PoolsClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, options *PoolsClientGetOptions) (PoolsClientGetResponse, error)

Get - Get details of the specified capacity pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • options - PoolsClientGetOptions contains the optional parameters for the PoolsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Pools_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolsClient().Get(ctx, "myRG", "account1", "pool1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CapacityPool = armnetapp.CapacityPool{
// 	Name: to.Ptr("account1/pool1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.PoolProperties{
// 		PoolID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		QosType: to.Ptr(armnetapp.QosTypeManual),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		Size: to.Ptr[int64](4398046511104),
// 		TotalThroughputMibps: to.Ptr[float32](281.474),
// 		UtilizedThroughputMibps: to.Ptr[float32](100.47),
// 	},
// }

Output:

func (*PoolsClient) NewListPager 

func (client *PoolsClient) NewListPager(resourceGroupName string, accountName string, options *PoolsClientListOptions) *runtime.Pager[PoolsClientListResponse]

NewListPager - List all capacity pools in the NetApp Account

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - PoolsClientListOptions contains the optional parameters for the PoolsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Pools_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPoolsClient().NewListPager("myRG", "account1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.CapacityPoolList = armnetapp.CapacityPoolList{
	// 	Value: []*armnetapp.CapacityPool{
	// 		{
	// 			Name: to.Ptr("account1/pool1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.PoolProperties{
	// 				PoolID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				QosType: to.Ptr(armnetapp.QosTypeAuto),
	// 				ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
	// 				Size: to.Ptr[int64](4398046511104),
	// 				TotalThroughputMibps: to.Ptr[float32](281.474),
	// 			},
	// 	}},
	// }
}

Output:

type PoolsClientBeginCreateOrUpdateOptions 

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

PoolsClientBeginCreateOrUpdateOptions contains the optional parameters for the PoolsClient.BeginCreateOrUpdate method.

type PoolsClientBeginDeleteOptions 

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

PoolsClientBeginDeleteOptions contains the optional parameters for the PoolsClient.BeginDelete method.

type PoolsClientBeginUpdateOptions 

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

PoolsClientBeginUpdateOptions contains the optional parameters for the PoolsClient.BeginUpdate method.

type PoolsClientCreateOrUpdateResponse 

type PoolsClientCreateOrUpdateResponse struct {
	// Capacity pool resource
	CapacityPool
}

PoolsClientCreateOrUpdateResponse contains the response from method PoolsClient.BeginCreateOrUpdate.

type PoolsClientDeleteResponse 

type PoolsClientDeleteResponse struct {
}

PoolsClientDeleteResponse contains the response from method PoolsClient.BeginDelete.

type PoolsClientGetOptions 

type PoolsClientGetOptions struct {
}

PoolsClientGetOptions contains the optional parameters for the PoolsClient.Get method.

type PoolsClientGetResponse 

type PoolsClientGetResponse struct {
	// Capacity pool resource
	CapacityPool
}

PoolsClientGetResponse contains the response from method PoolsClient.Get.

type PoolsClientListOptions 

type PoolsClientListOptions struct {
}

PoolsClientListOptions contains the optional parameters for the PoolsClient.NewListPager method.

type PoolsClientListResponse 

type PoolsClientListResponse struct {
	// List of capacity pool resources
	CapacityPoolList
}

PoolsClientListResponse contains the response from method PoolsClient.NewListPager.

type PoolsClientUpdateResponse 

type PoolsClientUpdateResponse struct {
	// Capacity pool resource
	CapacityPool
}

PoolsClientUpdateResponse contains the response from method PoolsClient.BeginUpdate.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - Gets the status of the VolumeQuotaRule at the time the operation was called. 

const (
	ProvisioningStateAccepted  ProvisioningState = "Accepted"
	ProvisioningStateCreating  ProvisioningState = "Creating"
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateMoving    ProvisioningState = "Moving"
	ProvisioningStatePatching  ProvisioningState = "Patching"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type QosType 

type QosType string

QosType - The qos type of the pool 

const (
	// QosTypeAuto - qos type Auto
	QosTypeAuto QosType = "Auto"
	// QosTypeManual - qos type Manual
	QosTypeManual QosType = "Manual"
)

func PossibleQosTypeValues 

func PossibleQosTypeValues() []QosType

PossibleQosTypeValues returns the possible values for the QosType const type.

type QueryNetworkSiblingSetRequest 

type QueryNetworkSiblingSetRequest struct {
	// REQUIRED; Network Sibling Set ID for a group of volumes sharing networking resources in a subnet.
	NetworkSiblingSetID *string

	// REQUIRED; The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes. Example
	// /subscriptions/subscriptionId/resourceGroups/resourceGroup/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/{mySubnet}
	SubnetID *string
}

QueryNetworkSiblingSetRequest - Network sibling set query.

func (QueryNetworkSiblingSetRequest) MarshalJSON 

func (q QueryNetworkSiblingSetRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type QueryNetworkSiblingSetRequest.

func (*QueryNetworkSiblingSetRequest) UnmarshalJSON 

func (q *QueryNetworkSiblingSetRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type QueryNetworkSiblingSetRequest.

type QuotaAvailabilityRequest 

type QuotaAvailabilityRequest struct {
	// REQUIRED; Name of the resource to verify.
	Name *string

	// REQUIRED; Resource group name.
	ResourceGroup *string

	// REQUIRED; Resource type used for verification.
	Type *CheckQuotaNameResourceTypes
}

QuotaAvailabilityRequest - Quota availability request content.

func (QuotaAvailabilityRequest) MarshalJSON 

func (q QuotaAvailabilityRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type QuotaAvailabilityRequest.

func (*QuotaAvailabilityRequest) UnmarshalJSON 

func (q *QuotaAvailabilityRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type QuotaAvailabilityRequest.

type ReestablishReplicationRequest 

type ReestablishReplicationRequest struct {
	// Resource id of the source volume for the replication
	SourceVolumeID *string
}

ReestablishReplicationRequest - Re-establish request object supplied in the body of the operation.

func (ReestablishReplicationRequest) MarshalJSON 

func (r ReestablishReplicationRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ReestablishReplicationRequest.

func (*ReestablishReplicationRequest) UnmarshalJSON 

func (r *ReestablishReplicationRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ReestablishReplicationRequest.

type RegionInfo 

type RegionInfo struct {
	// Provides logical availability zone mappings for the subscription for a region.
	AvailabilityZoneMappings []*RegionInfoAvailabilityZoneMappingsItem

	// Provides storage to network proximity information in the region.
	StorageToNetworkProximity *RegionStorageToNetworkProximity
}

RegionInfo - Provides region specific information.

func (RegionInfo) MarshalJSON 

func (r RegionInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RegionInfo.

func (*RegionInfo) UnmarshalJSON 

func (r *RegionInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RegionInfo.

type RegionInfoAvailabilityZoneMappingsItem 

type RegionInfoAvailabilityZoneMappingsItem struct {
	// Logical availability zone.
	AvailabilityZone *string

	// Available availability zone
	IsAvailable *bool
}

func (RegionInfoAvailabilityZoneMappingsItem) MarshalJSON 

func (r RegionInfoAvailabilityZoneMappingsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RegionInfoAvailabilityZoneMappingsItem.

func (*RegionInfoAvailabilityZoneMappingsItem) UnmarshalJSON 

func (r *RegionInfoAvailabilityZoneMappingsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RegionInfoAvailabilityZoneMappingsItem.

type RegionStorageToNetworkProximity 

type RegionStorageToNetworkProximity string

RegionStorageToNetworkProximity - Provides storage to network proximity information in the region. 

const (
	// RegionStorageToNetworkProximityAcrossT2 - Standard AcrossT2 network connectivity.
	RegionStorageToNetworkProximityAcrossT2 RegionStorageToNetworkProximity = "AcrossT2"
	// RegionStorageToNetworkProximityDefault - Basic network connectivity.
	RegionStorageToNetworkProximityDefault RegionStorageToNetworkProximity = "Default"
	// RegionStorageToNetworkProximityT1 - Standard T1 network connectivity.
	RegionStorageToNetworkProximityT1 RegionStorageToNetworkProximity = "T1"
	// RegionStorageToNetworkProximityT1AndAcrossT2 - Standard T1 and AcrossT2 network connectivity.
	RegionStorageToNetworkProximityT1AndAcrossT2 RegionStorageToNetworkProximity = "T1AndAcrossT2"
	// RegionStorageToNetworkProximityT1AndT2 - Standard T1 and T2 network connectivity.
	RegionStorageToNetworkProximityT1AndT2 RegionStorageToNetworkProximity = "T1AndT2"
	// RegionStorageToNetworkProximityT1AndT2AndAcrossT2 - Standard T1, T2 and AcrossT2 network connectivity.
	RegionStorageToNetworkProximityT1AndT2AndAcrossT2 RegionStorageToNetworkProximity = "T1AndT2AndAcrossT2"
	// RegionStorageToNetworkProximityT2 - Standard T2 network connectivity.
	RegionStorageToNetworkProximityT2 RegionStorageToNetworkProximity = "T2"
	// RegionStorageToNetworkProximityT2AndAcrossT2 - Standard T2 and AcrossT2 network connectivity.
	RegionStorageToNetworkProximityT2AndAcrossT2 RegionStorageToNetworkProximity = "T2AndAcrossT2"
)

func PossibleRegionStorageToNetworkProximityValues 

func PossibleRegionStorageToNetworkProximityValues() []RegionStorageToNetworkProximity

PossibleRegionStorageToNetworkProximityValues returns the possible values for the RegionStorageToNetworkProximity const type.

type RelationshipStatus 

type RelationshipStatus string

RelationshipStatus - Status of the mirror relationship 

const (
	RelationshipStatusFailed       RelationshipStatus = "Failed"
	RelationshipStatusIdle         RelationshipStatus = "Idle"
	RelationshipStatusTransferring RelationshipStatus = "Transferring"
	RelationshipStatusUnknown      RelationshipStatus = "Unknown"
)

func PossibleRelationshipStatusValues 

func PossibleRelationshipStatusValues() []RelationshipStatus

PossibleRelationshipStatusValues returns the possible values for the RelationshipStatus const type.

type RelocateVolumeRequest 

type RelocateVolumeRequest struct {
	// New creation token for the volume that controls the mount point name
	CreationToken *string
}

RelocateVolumeRequest - Relocate volume request

func (RelocateVolumeRequest) MarshalJSON 

func (r RelocateVolumeRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RelocateVolumeRequest.

func (*RelocateVolumeRequest) UnmarshalJSON 

func (r *RelocateVolumeRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RelocateVolumeRequest.

type Replication 

type Replication struct {
	// REQUIRED; The resource ID of the remote volume.
	RemoteVolumeResourceID *string

	// Indicates whether the local volume is the source or destination for the Volume Replication
	EndpointType *EndpointType

	// The remote region for the other end of the Volume Replication.
	RemoteVolumeRegion *string

	// Schedule
	ReplicationSchedule *ReplicationSchedule
}

Replication properties

func (Replication) MarshalJSON 

func (r Replication) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Replication.

func (*Replication) UnmarshalJSON 

func (r *Replication) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Replication.

type ReplicationObject 

type ReplicationObject struct {
	// REQUIRED; The resource ID of the remote volume.
	RemoteVolumeResourceID *string

	// Indicates whether the local volume is the source or destination for the Volume Replication
	EndpointType *EndpointType

	// The remote region for the other end of the Volume Replication.
	RemoteVolumeRegion *string

	// Schedule
	ReplicationSchedule *ReplicationSchedule

	// READ-ONLY; Id
	ReplicationID *string
}

ReplicationObject - Replication properties

func (ReplicationObject) MarshalJSON 

func (r ReplicationObject) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ReplicationObject.

func (*ReplicationObject) UnmarshalJSON 

func (r *ReplicationObject) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ReplicationObject.

type ReplicationSchedule 

type ReplicationSchedule string

ReplicationSchedule - Schedule 

const (
	ReplicationSchedule10Minutely ReplicationSchedule = "_10minutely"
	ReplicationScheduleDaily      ReplicationSchedule = "daily"
	ReplicationScheduleHourly     ReplicationSchedule = "hourly"
)

func PossibleReplicationScheduleValues 

func PossibleReplicationScheduleValues() []ReplicationSchedule

PossibleReplicationScheduleValues returns the possible values for the ReplicationSchedule const type.

type ReplicationStatus 

type ReplicationStatus struct {
	// Displays error message if the replication is in an error state
	ErrorMessage *string

	// Replication health check
	Healthy *bool

	// The status of the replication
	MirrorState *MirrorState

	// Status of the mirror relationship
	RelationshipStatus *RelationshipStatus

	// The progress of the replication
	TotalProgress *string
}

ReplicationStatus - Replication status

func (ReplicationStatus) MarshalJSON 

func (r ReplicationStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ReplicationStatus.

func (*ReplicationStatus) UnmarshalJSON 

func (r *ReplicationStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ReplicationStatus.

type ResourceClient 

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

ResourceClient contains the methods for the NetAppResource group. Don't use this type directly, use NewResourceClient() instead.

func NewResourceClient 

func NewResourceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ResourceClient, error)

NewResourceClient creates a new instance of ResourceClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ResourceClient) BeginUpdateNetworkSiblingSet 

func (client *ResourceClient) BeginUpdateNetworkSiblingSet(ctx context.Context, location string, body UpdateNetworkSiblingSetRequest, options *ResourceClientBeginUpdateNetworkSiblingSetOptions) (*runtime.Poller[ResourceClientUpdateNetworkSiblingSetResponse], error)

BeginUpdateNetworkSiblingSet - Update the network features of the specified network sibling set. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • body - Update for the specified network sibling set.
  • options - ResourceClientBeginUpdateNetworkSiblingSetOptions contains the optional parameters for the ResourceClient.BeginUpdateNetworkSiblingSet method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/NetworkSiblingSet_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewResourceClient().BeginUpdateNetworkSiblingSet(ctx, "eastus", armnetapp.UpdateNetworkSiblingSetRequest{
	NetworkFeatures:          to.Ptr(armnetapp.NetworkFeaturesStandard),
	NetworkSiblingSetID:      to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
	NetworkSiblingSetStateID: to.Ptr("12345_44420.8001578125"),
	SubnetID:                 to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/testSubnet"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.NetworkSiblingSet = armnetapp.NetworkSiblingSet{
// 	NetworkFeatures: to.Ptr(armnetapp.NetworkFeaturesStandard),
// 	NetworkSiblingSetID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
// 	NetworkSiblingSetStateID: to.Ptr("12345_44420.8001578125"),
// 	NicInfoList: []*armnetapp.NicInfo{
// 		{
// 			IPAddress: to.Ptr("1.2.3.4"),
// 			VolumeResourceIDs: []*string{
// 				to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume10"),
// 				to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume11")},
// 			},
// 			{
// 				IPAddress: to.Ptr("1.2.3.5"),
// 				VolumeResourceIDs: []*string{
// 					to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account2/capacityPools/pool2/volumes/volume20"),
// 					to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account2/capacityPools/pool2/volumes/volume21")},
// 				},
// 				{
// 					IPAddress: to.Ptr("1.2.3.9"),
// 					VolumeResourceIDs: []*string{
// 					},
// 			}},
// 			ProvisioningState: to.Ptr(armnetapp.NetworkSiblingSetProvisioningStateSucceeded),
// 			SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/testSubnet"),
// 		}

Output:

func (*ResourceClient) CheckFilePathAvailability 

func (client *ResourceClient) CheckFilePathAvailability(ctx context.Context, location string, body FilePathAvailabilityRequest, options *ResourceClientCheckFilePathAvailabilityOptions) (ResourceClientCheckFilePathAvailabilityResponse, error)

CheckFilePathAvailability - Check if a file path is available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • body - File path availability request.
  • options - ResourceClientCheckFilePathAvailabilityOptions contains the optional parameters for the ResourceClient.CheckFilePathAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/CheckFilePathAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResourceClient().CheckFilePathAvailability(ctx, "eastus", armnetapp.FilePathAvailabilityRequest{
	Name:     to.Ptr("my-exact-filepth"),
	SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckAvailabilityResponse = armnetapp.CheckAvailabilityResponse{
// 	IsAvailable: to.Ptr(true),
// }

Output:

func (*ResourceClient) CheckNameAvailability 

func (client *ResourceClient) CheckNameAvailability(ctx context.Context, location string, body ResourceNameAvailabilityRequest, options *ResourceClientCheckNameAvailabilityOptions) (ResourceClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check if a resource name is available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • body - Name availability request.
  • options - ResourceClientCheckNameAvailabilityOptions contains the optional parameters for the ResourceClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/CheckNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResourceClient().CheckNameAvailability(ctx, "eastus", armnetapp.ResourceNameAvailabilityRequest{
	Name:          to.Ptr("accName"),
	Type:          to.Ptr(armnetapp.CheckNameResourceTypesMicrosoftNetAppNetAppAccounts),
	ResourceGroup: to.Ptr("myRG"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckAvailabilityResponse = armnetapp.CheckAvailabilityResponse{
// 	IsAvailable: to.Ptr(true),
// }

Output:

func (*ResourceClient) CheckQuotaAvailability 

func (client *ResourceClient) CheckQuotaAvailability(ctx context.Context, location string, body QuotaAvailabilityRequest, options *ResourceClientCheckQuotaAvailabilityOptions) (ResourceClientCheckQuotaAvailabilityResponse, error)

CheckQuotaAvailability - Check if a quota is available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • body - Quota availability request.
  • options - ResourceClientCheckQuotaAvailabilityOptions contains the optional parameters for the ResourceClient.CheckQuotaAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/CheckQuotaAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResourceClient().CheckQuotaAvailability(ctx, "eastus", armnetapp.QuotaAvailabilityRequest{
	Name:          to.Ptr("resource1"),
	Type:          to.Ptr(armnetapp.CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccounts),
	ResourceGroup: to.Ptr("myRG"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.CheckAvailabilityResponse = armnetapp.CheckAvailabilityResponse{
// 	IsAvailable: to.Ptr(true),
// }

Output:

func (*ResourceClient) QueryNetworkSiblingSet 

func (client *ResourceClient) QueryNetworkSiblingSet(ctx context.Context, location string, body QueryNetworkSiblingSetRequest, options *ResourceClientQueryNetworkSiblingSetOptions) (ResourceClientQueryNetworkSiblingSetResponse, error)

QueryNetworkSiblingSet - Get details of the specified network sibling set. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • body - Network sibling set to query.
  • options - ResourceClientQueryNetworkSiblingSetOptions contains the optional parameters for the ResourceClient.QueryNetworkSiblingSet method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/NetworkSiblingSet_Query.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResourceClient().QueryNetworkSiblingSet(ctx, "eastus", armnetapp.QueryNetworkSiblingSetRequest{
	NetworkSiblingSetID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
	SubnetID:            to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/testSubnet"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.NetworkSiblingSet = armnetapp.NetworkSiblingSet{
// 	NetworkFeatures: to.Ptr(armnetapp.NetworkFeaturesStandard),
// 	NetworkSiblingSetID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
// 	NetworkSiblingSetStateID: to.Ptr("12345_44420.8001578125"),
// 	NicInfoList: []*armnetapp.NicInfo{
// 		{
// 			IPAddress: to.Ptr("1.2.3.4"),
// 			VolumeResourceIDs: []*string{
// 				to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume10"),
// 				to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume11")},
// 			},
// 			{
// 				IPAddress: to.Ptr("1.2.3.5"),
// 				VolumeResourceIDs: []*string{
// 					to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account2/capacityPools/pool2/volumes/volume20"),
// 					to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account2/capacityPools/pool2/volumes/volume21")},
// 				},
// 				{
// 					IPAddress: to.Ptr("1.2.3.9"),
// 					VolumeResourceIDs: []*string{
// 					},
// 			}},
// 			ProvisioningState: to.Ptr(armnetapp.NetworkSiblingSetProvisioningStateSucceeded),
// 			SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/testSubnet"),
// 		}

Output:

func (*ResourceClient) QueryRegionInfo 

func (client *ResourceClient) QueryRegionInfo(ctx context.Context, location string, options *ResourceClientQueryRegionInfoOptions) (ResourceClientQueryRegionInfoResponse, error)

QueryRegionInfo - Provides storage to network proximity and logical zone mapping information. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • options - ResourceClientQueryRegionInfoOptions contains the optional parameters for the ResourceClient.QueryRegionInfo method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/RegionInfo.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResourceClient().QueryRegionInfo(ctx, "eastus", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.RegionInfo = armnetapp.RegionInfo{
// 	AvailabilityZoneMappings: []*armnetapp.RegionInfoAvailabilityZoneMappingsItem{
// 		{
// 			AvailabilityZone: to.Ptr("1"),
// 			IsAvailable: to.Ptr(true),
// 	}},
// 	StorageToNetworkProximity: to.Ptr(armnetapp.RegionStorageToNetworkProximityT2),
// }

Output:

type ResourceClientBeginUpdateNetworkSiblingSetOptions 

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

ResourceClientBeginUpdateNetworkSiblingSetOptions contains the optional parameters for the ResourceClient.BeginUpdateNetworkSiblingSet method.

type ResourceClientCheckFilePathAvailabilityOptions 

type ResourceClientCheckFilePathAvailabilityOptions struct {
}

ResourceClientCheckFilePathAvailabilityOptions contains the optional parameters for the ResourceClient.CheckFilePathAvailability method.

type ResourceClientCheckFilePathAvailabilityResponse 

type ResourceClientCheckFilePathAvailabilityResponse struct {
	// Information regarding availability of a resource.
	CheckAvailabilityResponse
}

ResourceClientCheckFilePathAvailabilityResponse contains the response from method ResourceClient.CheckFilePathAvailability.

type ResourceClientCheckNameAvailabilityOptions 

type ResourceClientCheckNameAvailabilityOptions struct {
}

ResourceClientCheckNameAvailabilityOptions contains the optional parameters for the ResourceClient.CheckNameAvailability method.

type ResourceClientCheckNameAvailabilityResponse 

type ResourceClientCheckNameAvailabilityResponse struct {
	// Information regarding availability of a resource.
	CheckAvailabilityResponse
}

ResourceClientCheckNameAvailabilityResponse contains the response from method ResourceClient.CheckNameAvailability.

type ResourceClientCheckQuotaAvailabilityOptions 

type ResourceClientCheckQuotaAvailabilityOptions struct {
}

ResourceClientCheckQuotaAvailabilityOptions contains the optional parameters for the ResourceClient.CheckQuotaAvailability method.

type ResourceClientCheckQuotaAvailabilityResponse 

type ResourceClientCheckQuotaAvailabilityResponse struct {
	// Information regarding availability of a resource.
	CheckAvailabilityResponse
}

ResourceClientCheckQuotaAvailabilityResponse contains the response from method ResourceClient.CheckQuotaAvailability.

type ResourceClientQueryNetworkSiblingSetOptions 

type ResourceClientQueryNetworkSiblingSetOptions struct {
}

ResourceClientQueryNetworkSiblingSetOptions contains the optional parameters for the ResourceClient.QueryNetworkSiblingSet method.

type ResourceClientQueryNetworkSiblingSetResponse 

type ResourceClientQueryNetworkSiblingSetResponse struct {
	// Describes the contents of a network sibling set.
	NetworkSiblingSet
}

ResourceClientQueryNetworkSiblingSetResponse contains the response from method ResourceClient.QueryNetworkSiblingSet.

type ResourceClientQueryRegionInfoOptions 

type ResourceClientQueryRegionInfoOptions struct {
}

ResourceClientQueryRegionInfoOptions contains the optional parameters for the ResourceClient.QueryRegionInfo method.

type ResourceClientQueryRegionInfoResponse 

type ResourceClientQueryRegionInfoResponse struct {
	// Provides region specific information.
	RegionInfo
}

ResourceClientQueryRegionInfoResponse contains the response from method ResourceClient.QueryRegionInfo.

type ResourceClientUpdateNetworkSiblingSetResponse 

type ResourceClientUpdateNetworkSiblingSetResponse struct {
	// Describes the contents of a network sibling set.
	NetworkSiblingSet
}

ResourceClientUpdateNetworkSiblingSetResponse contains the response from method ResourceClient.BeginUpdateNetworkSiblingSet.

type ResourceNameAvailabilityRequest 

type ResourceNameAvailabilityRequest struct {
	// REQUIRED; Resource name to verify.
	Name *string

	// REQUIRED; Resource group name.
	ResourceGroup *string

	// REQUIRED; Resource type used for verification.
	Type *CheckNameResourceTypes
}

ResourceNameAvailabilityRequest - Resource name availability request content.

func (ResourceNameAvailabilityRequest) MarshalJSON 

func (r ResourceNameAvailabilityRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceNameAvailabilityRequest.

func (*ResourceNameAvailabilityRequest) UnmarshalJSON 

func (r *ResourceNameAvailabilityRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceNameAvailabilityRequest.

type ResourceQuotaLimitsClient 

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

ResourceQuotaLimitsClient contains the methods for the NetAppResourceQuotaLimits group. Don't use this type directly, use NewResourceQuotaLimitsClient() instead.

func NewResourceQuotaLimitsClient 

func NewResourceQuotaLimitsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ResourceQuotaLimitsClient, error)

NewResourceQuotaLimitsClient creates a new instance of ResourceQuotaLimitsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ResourceQuotaLimitsClient) Get 

func (client *ResourceQuotaLimitsClient) Get(ctx context.Context, location string, quotaLimitName string, options *ResourceQuotaLimitsClientGetOptions) (ResourceQuotaLimitsClientGetResponse, error)

Get - Get the default and current subscription quota limit If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • quotaLimitName - The name of the Quota Limit
  • options - ResourceQuotaLimitsClientGetOptions contains the optional parameters for the ResourceQuotaLimitsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/QuotaLimits_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResourceQuotaLimitsClient().Get(ctx, "eastus", "totalCoolAccessVolumesPerSubscription", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SubscriptionQuotaItem = armnetapp.SubscriptionQuotaItem{
// 	Name: to.Ptr("eastus/totalCoolAccessVolumesPerSubscription"),
// 	Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/totalCoolAccessVolumesPerSubscription"),
// 	Properties: &armnetapp.SubscriptionQuotaItemProperties{
// 		Default: to.Ptr[int32](10),
// 		Current: to.Ptr[int32](10),
// 	},
// }

Output:

func (*ResourceQuotaLimitsClient) NewListPager 

func (client *ResourceQuotaLimitsClient) NewListPager(location string, options *ResourceQuotaLimitsClientListOptions) *runtime.Pager[ResourceQuotaLimitsClientListResponse]

NewListPager - Get the default and current limits for quotas

Generated from API version 2023-07-01

  • location - The name of the Azure region.
  • options - ResourceQuotaLimitsClientListOptions contains the optional parameters for the ResourceQuotaLimitsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/QuotaLimits_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewResourceQuotaLimitsClient().NewListPager("eastus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SubscriptionQuotaItemList = armnetapp.SubscriptionQuotaItemList{
	// 	Value: []*armnetapp.SubscriptionQuotaItem{
	// 		{
	// 			Name: to.Ptr("eastus/accountsPerSubscription"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/accountsPerSubscription"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](10),
	// 				Current: to.Ptr[int32](10),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/poolsPerAccount"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/poolsPerAccount"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](25),
	// 				Current: to.Ptr[int32](25),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/volumesPerPool"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/volumesPerPool"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](500),
	// 				Current: to.Ptr[int32](500),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/snapshotsPerVolume"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/snapshotsPerVolume"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](255),
	// 				Current: to.Ptr[int32](255),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/totalTiBsPerSubscription"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/totalTiBsPerSubscription"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](25),
	// 				Current: to.Ptr[int32](1000),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/totalDPVolumesPerSubscription"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/totalDPVolumesPerSubscription"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](10),
	// 				Current: to.Ptr[int32](10),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/totalVolumesPerSubscription"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/totalVolumesPerSubscription"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](500),
	// 				Current: to.Ptr[int32](500),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("eastus/totalCoolAccessVolumesPerSubscription"),
	// 			Type: to.Ptr("Microsoft.NetApp/locations/quotaLimits"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/providers/Microsoft.NetApp/locations/eastus/quotaLimits/totalCoolAccessVolumesPerSubscription"),
	// 			Properties: &armnetapp.SubscriptionQuotaItemProperties{
	// 				Default: to.Ptr[int32](10),
	// 				Current: to.Ptr[int32](10),
	// 			},
	// 	}},
	// }
}

Output:

type ResourceQuotaLimitsClientGetOptions 

type ResourceQuotaLimitsClientGetOptions struct {
}

ResourceQuotaLimitsClientGetOptions contains the optional parameters for the ResourceQuotaLimitsClient.Get method.

type ResourceQuotaLimitsClientGetResponse 

type ResourceQuotaLimitsClientGetResponse struct {
	// Information regarding Subscription Quota Item.
	SubscriptionQuotaItem
}

ResourceQuotaLimitsClientGetResponse contains the response from method ResourceQuotaLimitsClient.Get.

type ResourceQuotaLimitsClientListOptions 

type ResourceQuotaLimitsClientListOptions struct {
}

ResourceQuotaLimitsClientListOptions contains the optional parameters for the ResourceQuotaLimitsClient.NewListPager method.

type ResourceQuotaLimitsClientListResponse 

type ResourceQuotaLimitsClientListResponse struct {
	// List of Subscription Quota Items
	SubscriptionQuotaItemList
}

ResourceQuotaLimitsClientListResponse contains the response from method ResourceQuotaLimitsClient.NewListPager.

type RestoreStatus 

type RestoreStatus struct {
	// READ-ONLY; Displays error message if the restore is in an error state
	ErrorMessage *string

	// READ-ONLY; Restore health status
	Healthy *bool

	// READ-ONLY; The status of the restore
	MirrorState *MirrorState

	// READ-ONLY; Status of the restore SnapMirror relationship
	RelationshipStatus *RelationshipStatus

	// READ-ONLY; Displays the total bytes transferred
	TotalTransferBytes *int64

	// READ-ONLY; Reason for the unhealthy restore relationship
	UnhealthyReason *string
}

RestoreStatus - Restore status

func (RestoreStatus) MarshalJSON 

func (r RestoreStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RestoreStatus.

func (*RestoreStatus) UnmarshalJSON 

func (r *RestoreStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RestoreStatus.

type SecurityStyle 

type SecurityStyle string

SecurityStyle - The security style of volume, default unix, defaults to ntfs for dual protocol or CIFS protocol 

const (
	SecurityStyleNtfs SecurityStyle = "ntfs"
	SecurityStyleUnix SecurityStyle = "unix"
)

func PossibleSecurityStyleValues 

func PossibleSecurityStyleValues() []SecurityStyle

PossibleSecurityStyleValues returns the possible values for the SecurityStyle const type.

type ServiceLevel 

type ServiceLevel string

ServiceLevel - The service level of the file system 

const (
	// ServiceLevelPremium - Premium service level
	ServiceLevelPremium ServiceLevel = "Premium"
	// ServiceLevelStandard - Standard service level
	ServiceLevelStandard ServiceLevel = "Standard"
	// ServiceLevelStandardZRS - Zone redundant storage service level
	ServiceLevelStandardZRS ServiceLevel = "StandardZRS"
	// ServiceLevelUltra - Ultra service level
	ServiceLevelUltra ServiceLevel = "Ultra"
)

func PossibleServiceLevelValues 

func PossibleServiceLevelValues() []ServiceLevel

PossibleServiceLevelValues returns the possible values for the ServiceLevel const type.

type ServiceSpecification 

type ServiceSpecification struct {
	// Log specification of operation.
	LogSpecifications []*LogSpecification

	// Metric specifications of operation.
	MetricSpecifications []*MetricSpecification
}

ServiceSpecification - One property of operation, include metric specifications.

func (ServiceSpecification) MarshalJSON 

func (s ServiceSpecification) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServiceSpecification.

func (*ServiceSpecification) UnmarshalJSON 

func (s *ServiceSpecification) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceSpecification.

type SmbAccessBasedEnumeration 

type SmbAccessBasedEnumeration string

SmbAccessBasedEnumeration - Enables access-based enumeration share property for SMB Shares. Only applicable for SMB/DualProtocol volume 

const (
	// SmbAccessBasedEnumerationDisabled - smbAccessBasedEnumeration share setting is disabled
	SmbAccessBasedEnumerationDisabled SmbAccessBasedEnumeration = "Disabled"
	// SmbAccessBasedEnumerationEnabled - smbAccessBasedEnumeration share setting is enabled
	SmbAccessBasedEnumerationEnabled SmbAccessBasedEnumeration = "Enabled"
)

func PossibleSmbAccessBasedEnumerationValues 

func PossibleSmbAccessBasedEnumerationValues() []SmbAccessBasedEnumeration

PossibleSmbAccessBasedEnumerationValues returns the possible values for the SmbAccessBasedEnumeration const type.

type SmbNonBrowsable 

type SmbNonBrowsable string

SmbNonBrowsable - Enables non-browsable property for SMB Shares. Only applicable for SMB/DualProtocol volume 

const (
	// SmbNonBrowsableDisabled - smbNonBrowsable share setting is disabled
	SmbNonBrowsableDisabled SmbNonBrowsable = "Disabled"
	// SmbNonBrowsableEnabled - smbNonBrowsable share setting is enabled
	SmbNonBrowsableEnabled SmbNonBrowsable = "Enabled"
)

func PossibleSmbNonBrowsableValues 

func PossibleSmbNonBrowsableValues() []SmbNonBrowsable

PossibleSmbNonBrowsableValues returns the possible values for the SmbNonBrowsable const type.

type Snapshot 

type Snapshot struct {
	// REQUIRED; Resource location
	Location *string

	// Snapshot Properties
	Properties *SnapshotProperties

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

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

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

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

Snapshot of a Volume

func (Snapshot) MarshalJSON 

func (s Snapshot) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Snapshot.

func (*Snapshot) UnmarshalJSON 

func (s *Snapshot) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Snapshot.

type SnapshotPoliciesClient 

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

SnapshotPoliciesClient contains the methods for the SnapshotPolicies group. Don't use this type directly, use NewSnapshotPoliciesClient() instead.

func NewSnapshotPoliciesClient 

func NewSnapshotPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SnapshotPoliciesClient, error)

NewSnapshotPoliciesClient creates a new instance of SnapshotPoliciesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SnapshotPoliciesClient) BeginDelete 

func (client *SnapshotPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, options *SnapshotPoliciesClientBeginDeleteOptions) (*runtime.Poller[SnapshotPoliciesClientDeleteResponse], error)

BeginDelete - Delete snapshot policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • snapshotPolicyName - The name of the snapshot policy
  • options - SnapshotPoliciesClientBeginDeleteOptions contains the optional parameters for the SnapshotPoliciesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/SnapshotPolicies_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSnapshotPoliciesClient().BeginDelete(ctx, "resourceGroup", "accountName", "snapshotPolicyName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SnapshotPoliciesClient) BeginUpdate 

func (client *SnapshotPoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, body SnapshotPolicyPatch, options *SnapshotPoliciesClientBeginUpdateOptions) (*runtime.Poller[SnapshotPoliciesClientUpdateResponse], error)

BeginUpdate - Patch a snapshot policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • snapshotPolicyName - The name of the snapshot policy
  • body - Snapshot policy object supplied in the body of the operation.
  • options - SnapshotPoliciesClientBeginUpdateOptions contains the optional parameters for the SnapshotPoliciesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/SnapshotPolicies_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSnapshotPoliciesClient().BeginUpdate(ctx, "myRG", "account1", "snapshotPolicyName", armnetapp.SnapshotPolicyPatch{
	Location: to.Ptr("eastus"),
	Properties: &armnetapp.SnapshotPolicyProperties{
		DailySchedule: &armnetapp.DailySchedule{
			Hour:            to.Ptr[int32](14),
			Minute:          to.Ptr[int32](30),
			SnapshotsToKeep: to.Ptr[int32](4),
		},
		Enabled: to.Ptr(true),
		HourlySchedule: &armnetapp.HourlySchedule{
			Minute:          to.Ptr[int32](50),
			SnapshotsToKeep: to.Ptr[int32](2),
		},
		MonthlySchedule: &armnetapp.MonthlySchedule{
			DaysOfMonth:     to.Ptr("10,11,12"),
			Hour:            to.Ptr[int32](14),
			Minute:          to.Ptr[int32](15),
			SnapshotsToKeep: to.Ptr[int32](5),
		},
		WeeklySchedule: &armnetapp.WeeklySchedule{
			Day:             to.Ptr("Wednesday"),
			Hour:            to.Ptr[int32](14),
			Minute:          to.Ptr[int32](45),
			SnapshotsToKeep: to.Ptr[int32](3),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SnapshotPolicy = armnetapp.SnapshotPolicy{
// 	Name: to.Ptr("account1/snapshotPolicy1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/snapshotPolicies/snapshotPolicy1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.SnapshotPolicyProperties{
// 		DailySchedule: &armnetapp.DailySchedule{
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](30),
// 			SnapshotsToKeep: to.Ptr[int32](4),
// 		},
// 		Enabled: to.Ptr(true),
// 		HourlySchedule: &armnetapp.HourlySchedule{
// 			Minute: to.Ptr[int32](50),
// 			SnapshotsToKeep: to.Ptr[int32](2),
// 		},
// 		MonthlySchedule: &armnetapp.MonthlySchedule{
// 			DaysOfMonth: to.Ptr("10,11,12"),
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](15),
// 			SnapshotsToKeep: to.Ptr[int32](5),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		WeeklySchedule: &armnetapp.WeeklySchedule{
// 			Day: to.Ptr("Wednesday"),
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](45),
// 			SnapshotsToKeep: to.Ptr[int32](3),
// 		},
// 	},
// }

Output:

func (*SnapshotPoliciesClient) Create 

func (client *SnapshotPoliciesClient) Create(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, body SnapshotPolicy, options *SnapshotPoliciesClientCreateOptions) (SnapshotPoliciesClientCreateResponse, error)

Create - Create a snapshot policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • snapshotPolicyName - The name of the snapshot policy
  • body - Snapshot policy object supplied in the body of the operation.
  • options - SnapshotPoliciesClientCreateOptions contains the optional parameters for the SnapshotPoliciesClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/SnapshotPolicies_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotPoliciesClient().Create(ctx, "myRG", "account1", "snapshotPolicyName", armnetapp.SnapshotPolicy{
	Location: to.Ptr("eastus"),
	Properties: &armnetapp.SnapshotPolicyProperties{
		DailySchedule: &armnetapp.DailySchedule{
			Hour:            to.Ptr[int32](14),
			Minute:          to.Ptr[int32](30),
			SnapshotsToKeep: to.Ptr[int32](4),
		},
		Enabled: to.Ptr(true),
		HourlySchedule: &armnetapp.HourlySchedule{
			Minute:          to.Ptr[int32](50),
			SnapshotsToKeep: to.Ptr[int32](2),
		},
		MonthlySchedule: &armnetapp.MonthlySchedule{
			DaysOfMonth:     to.Ptr("10,11,12"),
			Hour:            to.Ptr[int32](14),
			Minute:          to.Ptr[int32](15),
			SnapshotsToKeep: to.Ptr[int32](5),
		},
		WeeklySchedule: &armnetapp.WeeklySchedule{
			Day:             to.Ptr("Wednesday"),
			Hour:            to.Ptr[int32](14),
			Minute:          to.Ptr[int32](45),
			SnapshotsToKeep: to.Ptr[int32](3),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SnapshotPolicy = armnetapp.SnapshotPolicy{
// 	Name: to.Ptr("account1/snapshotPolicy1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/snapshotPolicies/snapshotPolicy1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.SnapshotPolicyProperties{
// 		DailySchedule: &armnetapp.DailySchedule{
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](30),
// 			SnapshotsToKeep: to.Ptr[int32](4),
// 		},
// 		Enabled: to.Ptr(true),
// 		HourlySchedule: &armnetapp.HourlySchedule{
// 			Minute: to.Ptr[int32](50),
// 			SnapshotsToKeep: to.Ptr[int32](2),
// 		},
// 		MonthlySchedule: &armnetapp.MonthlySchedule{
// 			DaysOfMonth: to.Ptr("10,11,12"),
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](15),
// 			SnapshotsToKeep: to.Ptr[int32](5),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		WeeklySchedule: &armnetapp.WeeklySchedule{
// 			Day: to.Ptr("Wednesday"),
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](45),
// 			SnapshotsToKeep: to.Ptr[int32](3),
// 		},
// 	},
// }

Output:

func (*SnapshotPoliciesClient) Get 

func (client *SnapshotPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, options *SnapshotPoliciesClientGetOptions) (SnapshotPoliciesClientGetResponse, error)

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

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • snapshotPolicyName - The name of the snapshot policy
  • options - SnapshotPoliciesClientGetOptions contains the optional parameters for the SnapshotPoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/SnapshotPolicies_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotPoliciesClient().Get(ctx, "myRG", "account1", "snapshotPolicyName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SnapshotPolicy = armnetapp.SnapshotPolicy{
// 	Name: to.Ptr("account1/snapshotPolicy1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/snapshotPolicies/snapshotPolicy1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.SnapshotPolicyProperties{
// 		DailySchedule: &armnetapp.DailySchedule{
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](30),
// 			SnapshotsToKeep: to.Ptr[int32](4),
// 		},
// 		Enabled: to.Ptr(true),
// 		HourlySchedule: &armnetapp.HourlySchedule{
// 			Minute: to.Ptr[int32](50),
// 			SnapshotsToKeep: to.Ptr[int32](2),
// 		},
// 		MonthlySchedule: &armnetapp.MonthlySchedule{
// 			DaysOfMonth: to.Ptr("10,11,12"),
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](15),
// 			SnapshotsToKeep: to.Ptr[int32](5),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		WeeklySchedule: &armnetapp.WeeklySchedule{
// 			Day: to.Ptr("Wednesday"),
// 			Hour: to.Ptr[int32](14),
// 			Minute: to.Ptr[int32](45),
// 			SnapshotsToKeep: to.Ptr[int32](3),
// 		},
// 	},
// }

Output:

func (*SnapshotPoliciesClient) ListVolumes 

func (client *SnapshotPoliciesClient) ListVolumes(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, options *SnapshotPoliciesClientListVolumesOptions) (SnapshotPoliciesClientListVolumesResponse, error)

ListVolumes - Get volumes associated with snapshot policy If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • snapshotPolicyName - The name of the snapshot policy
  • options - SnapshotPoliciesClientListVolumesOptions contains the optional parameters for the SnapshotPoliciesClient.ListVolumes method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/SnapshotPolicies_ListVolumes.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotPoliciesClient().ListVolumes(ctx, "myRG", "account1", "snapshotPolicyName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SnapshotPolicyVolumeList = armnetapp.SnapshotPolicyVolumeList{
// 	Value: []*armnetapp.Volume{
// 		{
// 			Name: to.Ptr("account1/pool1/volume1"),
// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1"),
// 			Location: to.Ptr("eastus"),
// 			Properties: &armnetapp.VolumeProperties{
// 				CreationToken: to.Ptr("some-amazing-filepath"),
// 				FileSystemID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 				SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 				ThroughputMibps: to.Ptr[float32](128),
// 				UsageThreshold: to.Ptr[int64](107374182400),
// 			},
// 	}},
// }

Output:

func (*SnapshotPoliciesClient) NewListPager 

func (client *SnapshotPoliciesClient) NewListPager(resourceGroupName string, accountName string, options *SnapshotPoliciesClientListOptions) *runtime.Pager[SnapshotPoliciesClientListResponse]

NewListPager - List snapshot policy

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - SnapshotPoliciesClientListOptions contains the optional parameters for the SnapshotPoliciesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/SnapshotPolicies_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSnapshotPoliciesClient().NewListPager("myRG", "account1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SnapshotPoliciesList = armnetapp.SnapshotPoliciesList{
	// 	Value: []*armnetapp.SnapshotPolicy{
	// 		{
	// 			Name: to.Ptr("account1/snapshotPolicy1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/snapshotPolicies"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/snapshotPolicies/snapshotPolicy1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.SnapshotPolicyProperties{
	// 				DailySchedule: &armnetapp.DailySchedule{
	// 					Hour: to.Ptr[int32](14),
	// 					Minute: to.Ptr[int32](30),
	// 					SnapshotsToKeep: to.Ptr[int32](4),
	// 				},
	// 				Enabled: to.Ptr(true),
	// 				HourlySchedule: &armnetapp.HourlySchedule{
	// 					Minute: to.Ptr[int32](50),
	// 					SnapshotsToKeep: to.Ptr[int32](2),
	// 				},
	// 				MonthlySchedule: &armnetapp.MonthlySchedule{
	// 					DaysOfMonth: to.Ptr("10,11,12"),
	// 					Hour: to.Ptr[int32](14),
	// 					Minute: to.Ptr[int32](15),
	// 					SnapshotsToKeep: to.Ptr[int32](5),
	// 				},
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				WeeklySchedule: &armnetapp.WeeklySchedule{
	// 					Day: to.Ptr("Wednesday"),
	// 					Hour: to.Ptr[int32](14),
	// 					Minute: to.Ptr[int32](45),
	// 					SnapshotsToKeep: to.Ptr[int32](3),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type SnapshotPoliciesClientBeginDeleteOptions 

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

SnapshotPoliciesClientBeginDeleteOptions contains the optional parameters for the SnapshotPoliciesClient.BeginDelete method.

type SnapshotPoliciesClientBeginUpdateOptions 

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

SnapshotPoliciesClientBeginUpdateOptions contains the optional parameters for the SnapshotPoliciesClient.BeginUpdate method.

type SnapshotPoliciesClientCreateOptions 

type SnapshotPoliciesClientCreateOptions struct {
}

SnapshotPoliciesClientCreateOptions contains the optional parameters for the SnapshotPoliciesClient.Create method.

type SnapshotPoliciesClientCreateResponse 

type SnapshotPoliciesClientCreateResponse struct {
	// Snapshot policy information
	SnapshotPolicy
}

SnapshotPoliciesClientCreateResponse contains the response from method SnapshotPoliciesClient.Create.

type SnapshotPoliciesClientDeleteResponse 

type SnapshotPoliciesClientDeleteResponse struct {
}

SnapshotPoliciesClientDeleteResponse contains the response from method SnapshotPoliciesClient.BeginDelete.

type SnapshotPoliciesClientGetOptions 

type SnapshotPoliciesClientGetOptions struct {
}

SnapshotPoliciesClientGetOptions contains the optional parameters for the SnapshotPoliciesClient.Get method.

type SnapshotPoliciesClientGetResponse 

type SnapshotPoliciesClientGetResponse struct {
	// Snapshot policy information
	SnapshotPolicy
}

SnapshotPoliciesClientGetResponse contains the response from method SnapshotPoliciesClient.Get.

type SnapshotPoliciesClientListOptions 

type SnapshotPoliciesClientListOptions struct {
}

SnapshotPoliciesClientListOptions contains the optional parameters for the SnapshotPoliciesClient.NewListPager method.

type SnapshotPoliciesClientListResponse 

type SnapshotPoliciesClientListResponse struct {
	// List of Snapshot Policies
	SnapshotPoliciesList
}

SnapshotPoliciesClientListResponse contains the response from method SnapshotPoliciesClient.NewListPager.

type SnapshotPoliciesClientListVolumesOptions 

type SnapshotPoliciesClientListVolumesOptions struct {
}

SnapshotPoliciesClientListVolumesOptions contains the optional parameters for the SnapshotPoliciesClient.ListVolumes method.

type SnapshotPoliciesClientListVolumesResponse 

type SnapshotPoliciesClientListVolumesResponse struct {
	// Volumes associated with snapshot policy
	SnapshotPolicyVolumeList
}

SnapshotPoliciesClientListVolumesResponse contains the response from method SnapshotPoliciesClient.ListVolumes.

type SnapshotPoliciesClientUpdateResponse 

type SnapshotPoliciesClientUpdateResponse struct {
	// Snapshot policy information
	SnapshotPolicy
}

SnapshotPoliciesClientUpdateResponse contains the response from method SnapshotPoliciesClient.BeginUpdate.

type SnapshotPoliciesList 

type SnapshotPoliciesList struct {
	// A list of snapshot policies
	Value []*SnapshotPolicy
}

SnapshotPoliciesList - List of Snapshot Policies

func (SnapshotPoliciesList) MarshalJSON 

func (s SnapshotPoliciesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotPoliciesList.

func (*SnapshotPoliciesList) UnmarshalJSON 

func (s *SnapshotPoliciesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotPoliciesList.

type SnapshotPolicy 

type SnapshotPolicy struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Snapshot policy Properties
	Properties *SnapshotPolicyProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

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

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

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

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

SnapshotPolicy - Snapshot policy information

func (SnapshotPolicy) MarshalJSON 

func (s SnapshotPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicy.

func (*SnapshotPolicy) UnmarshalJSON 

func (s *SnapshotPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotPolicy.

type SnapshotPolicyPatch 

type SnapshotPolicyPatch struct {
	// Resource location
	Location *string

	// Snapshot Policy properties
	Properties *SnapshotPolicyProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

SnapshotPolicyPatch - Snapshot policy Details for create and update

func (SnapshotPolicyPatch) MarshalJSON 

func (s SnapshotPolicyPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicyPatch.

func (*SnapshotPolicyPatch) UnmarshalJSON 

func (s *SnapshotPolicyPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotPolicyPatch.

type SnapshotPolicyProperties 

type SnapshotPolicyProperties struct {
	// Schedule for daily snapshots
	DailySchedule *DailySchedule

	// The property to decide policy is enabled or not
	Enabled *bool

	// Schedule for hourly snapshots
	HourlySchedule *HourlySchedule

	// Schedule for monthly snapshots
	MonthlySchedule *MonthlySchedule

	// Schedule for weekly snapshots
	WeeklySchedule *WeeklySchedule

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string
}

SnapshotPolicyProperties - Snapshot policy properties

func (SnapshotPolicyProperties) MarshalJSON 

func (s SnapshotPolicyProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicyProperties.

func (*SnapshotPolicyProperties) UnmarshalJSON 

func (s *SnapshotPolicyProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotPolicyProperties.

type SnapshotPolicyVolumeList 

type SnapshotPolicyVolumeList struct {
	// List of volumes
	Value []*Volume
}

SnapshotPolicyVolumeList - Volumes associated with snapshot policy

func (SnapshotPolicyVolumeList) MarshalJSON 

func (s SnapshotPolicyVolumeList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicyVolumeList.

func (*SnapshotPolicyVolumeList) UnmarshalJSON 

func (s *SnapshotPolicyVolumeList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotPolicyVolumeList.

type SnapshotProperties 

type SnapshotProperties struct {
	// READ-ONLY; The creation date of the snapshot
	Created *time.Time

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string

	// READ-ONLY; UUID v4 used to identify the Snapshot
	SnapshotID *string
}

SnapshotProperties - Snapshot properties

func (SnapshotProperties) MarshalJSON 

func (s SnapshotProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotProperties.

func (*SnapshotProperties) UnmarshalJSON 

func (s *SnapshotProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotProperties.

type SnapshotRestoreFiles 

type SnapshotRestoreFiles struct {
	// REQUIRED; List of files to be restored
	FilePaths []*string

	// Destination folder where the files will be restored
	DestinationPath *string
}

SnapshotRestoreFiles - Restore payload for Single File Snapshot Restore

func (SnapshotRestoreFiles) MarshalJSON 

func (s SnapshotRestoreFiles) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotRestoreFiles.

func (*SnapshotRestoreFiles) UnmarshalJSON 

func (s *SnapshotRestoreFiles) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotRestoreFiles.

type SnapshotsClient 

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

SnapshotsClient contains the methods for the Snapshots group. Don't use this type directly, use NewSnapshotsClient() instead.

func NewSnapshotsClient 

func NewSnapshotsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SnapshotsClient, error)

NewSnapshotsClient creates a new instance of SnapshotsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SnapshotsClient) BeginCreate 

func (client *SnapshotsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, body Snapshot, options *SnapshotsClientBeginCreateOptions) (*runtime.Poller[SnapshotsClientCreateResponse], error)

BeginCreate - Create the specified snapshot within the given volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • snapshotName - The name of the snapshot
  • body - Snapshot object supplied in the body of the operation.
  • options - SnapshotsClientBeginCreateOptions contains the optional parameters for the SnapshotsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Snapshots_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSnapshotsClient().BeginCreate(ctx, "myRG", "account1", "pool1", "volume1", "snapshot1", armnetapp.Snapshot{
	Location: to.Ptr("eastus"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SnapshotsClient) BeginDelete 

func (client *SnapshotsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, options *SnapshotsClientBeginDeleteOptions) (*runtime.Poller[SnapshotsClientDeleteResponse], error)

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

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • snapshotName - The name of the snapshot
  • options - SnapshotsClientBeginDeleteOptions contains the optional parameters for the SnapshotsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Snapshots_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSnapshotsClient().BeginDelete(ctx, "myRG", "account1", "pool1", "volume1", "snapshot1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SnapshotsClient) BeginRestoreFiles 

func (client *SnapshotsClient) BeginRestoreFiles(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, body SnapshotRestoreFiles, options *SnapshotsClientBeginRestoreFilesOptions) (*runtime.Poller[SnapshotsClientRestoreFilesResponse], error)

BeginRestoreFiles - Restore the specified files from the specified snapshot to the active filesystem If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • snapshotName - The name of the snapshot
  • body - Restore payload supplied in the body of the operation.
  • options - SnapshotsClientBeginRestoreFilesOptions contains the optional parameters for the SnapshotsClient.BeginRestoreFiles method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Snapshots_SingleFileRestore.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSnapshotsClient().BeginRestoreFiles(ctx, "myRG", "account1", "pool1", "volume1", "snapshot1", armnetapp.SnapshotRestoreFiles{
	FilePaths: []*string{
		to.Ptr("/dir1/customer1.db"),
		to.Ptr("/dir1/customer2.db")},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SnapshotsClient) BeginUpdate 

func (client *SnapshotsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, body any, options *SnapshotsClientBeginUpdateOptions) (*runtime.Poller[SnapshotsClientUpdateResponse], error)

BeginUpdate - Patch a snapshot If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • snapshotName - The name of the snapshot
  • body - Snapshot object supplied in the body of the operation.
  • options - SnapshotsClientBeginUpdateOptions contains the optional parameters for the SnapshotsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Snapshots_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSnapshotsClient().BeginUpdate(ctx, "myRG", "account1", "pool1", "volume1", "snapshot1", map[string]any{}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Snapshot = armnetapp.Snapshot{
// 	Name: to.Ptr("account1/pool1/volume1/snapshot1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/snapshots/snapshot1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.SnapshotProperties{
// 		Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		SnapshotID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
// 	},
// }

Output:

func (*SnapshotsClient) Get 

func (client *SnapshotsClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, options *SnapshotsClientGetOptions) (SnapshotsClientGetResponse, error)

Get - Get details of the specified snapshot If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • snapshotName - The name of the snapshot
  • options - SnapshotsClientGetOptions contains the optional parameters for the SnapshotsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Snapshots_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotsClient().Get(ctx, "myRG", "account1", "pool1", "volume1", "snapshot1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Snapshot = armnetapp.Snapshot{
// 	Name: to.Ptr("account1/pool1/volume1/snapshot1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/snapshots/snapshot1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.SnapshotProperties{
// 		Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		SnapshotID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
// 	},
// }

Output:

func (*SnapshotsClient) NewListPager 

func (client *SnapshotsClient) NewListPager(resourceGroupName string, accountName string, poolName string, volumeName string, options *SnapshotsClientListOptions) *runtime.Pager[SnapshotsClientListResponse]

NewListPager - List all snapshots associated with the volume

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - SnapshotsClientListOptions contains the optional parameters for the SnapshotsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Snapshots_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSnapshotsClient().NewListPager("myRG", "account1", "pool1", "volume1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SnapshotsList = armnetapp.SnapshotsList{
	// 	Value: []*armnetapp.Snapshot{
	// 		{
	// 			Name: to.Ptr("account1/pool1/volume1/snapshot1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/snapshots/snapshot1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.SnapshotProperties{
	// 				Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				SnapshotID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca3333"),
	// 			},
	// 	}},
	// }
}

Output:

type SnapshotsClientBeginCreateOptions 

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

SnapshotsClientBeginCreateOptions contains the optional parameters for the SnapshotsClient.BeginCreate method.

type SnapshotsClientBeginDeleteOptions 

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

SnapshotsClientBeginDeleteOptions contains the optional parameters for the SnapshotsClient.BeginDelete method.

type SnapshotsClientBeginRestoreFilesOptions 

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

SnapshotsClientBeginRestoreFilesOptions contains the optional parameters for the SnapshotsClient.BeginRestoreFiles method.

type SnapshotsClientBeginUpdateOptions 

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

SnapshotsClientBeginUpdateOptions contains the optional parameters for the SnapshotsClient.BeginUpdate method.

type SnapshotsClientCreateResponse 

type SnapshotsClientCreateResponse struct {
	// Snapshot of a Volume
	Snapshot
}

SnapshotsClientCreateResponse contains the response from method SnapshotsClient.BeginCreate.

type SnapshotsClientDeleteResponse 

type SnapshotsClientDeleteResponse struct {
}

SnapshotsClientDeleteResponse contains the response from method SnapshotsClient.BeginDelete.

type SnapshotsClientGetOptions 

type SnapshotsClientGetOptions struct {
}

SnapshotsClientGetOptions contains the optional parameters for the SnapshotsClient.Get method.

type SnapshotsClientGetResponse 

type SnapshotsClientGetResponse struct {
	// Snapshot of a Volume
	Snapshot
}

SnapshotsClientGetResponse contains the response from method SnapshotsClient.Get.

type SnapshotsClientListOptions 

type SnapshotsClientListOptions struct {
}

SnapshotsClientListOptions contains the optional parameters for the SnapshotsClient.NewListPager method.

type SnapshotsClientListResponse 

type SnapshotsClientListResponse struct {
	// List of Snapshots
	SnapshotsList
}

SnapshotsClientListResponse contains the response from method SnapshotsClient.NewListPager.

type SnapshotsClientRestoreFilesResponse 

type SnapshotsClientRestoreFilesResponse struct {
}

SnapshotsClientRestoreFilesResponse contains the response from method SnapshotsClient.BeginRestoreFiles.

type SnapshotsClientUpdateResponse 

type SnapshotsClientUpdateResponse struct {
	// Snapshot of a Volume
	Snapshot
}

SnapshotsClientUpdateResponse contains the response from method SnapshotsClient.BeginUpdate.

type SnapshotsList 

type SnapshotsList struct {
	// A list of Snapshots
	Value []*Snapshot
}

SnapshotsList - List of Snapshots

func (SnapshotsList) MarshalJSON 

func (s SnapshotsList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotsList.

func (*SnapshotsList) UnmarshalJSON 

func (s *SnapshotsList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotsList.

type SubscriptionQuotaItem 

type SubscriptionQuotaItem struct {
	// SubscriptionQuotaItem properties
	Properties *SubscriptionQuotaItemProperties

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

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

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

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

SubscriptionQuotaItem - Information regarding Subscription Quota Item.

func (SubscriptionQuotaItem) MarshalJSON 

func (s SubscriptionQuotaItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubscriptionQuotaItem.

func (*SubscriptionQuotaItem) UnmarshalJSON 

func (s *SubscriptionQuotaItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubscriptionQuotaItem.

type SubscriptionQuotaItemList 

type SubscriptionQuotaItemList struct {
	// A list of SubscriptionQuotaItems
	Value []*SubscriptionQuotaItem
}

SubscriptionQuotaItemList - List of Subscription Quota Items

func (SubscriptionQuotaItemList) MarshalJSON 

func (s SubscriptionQuotaItemList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubscriptionQuotaItemList.

func (*SubscriptionQuotaItemList) UnmarshalJSON 

func (s *SubscriptionQuotaItemList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubscriptionQuotaItemList.

type SubscriptionQuotaItemProperties 

type SubscriptionQuotaItemProperties struct {
	// READ-ONLY; The current quota value.
	Current *int32

	// READ-ONLY; The default quota value.
	Default *int32
}

SubscriptionQuotaItemProperties - SubscriptionQuotaItem Properties

func (SubscriptionQuotaItemProperties) MarshalJSON 

func (s SubscriptionQuotaItemProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubscriptionQuotaItemProperties.

func (*SubscriptionQuotaItemProperties) UnmarshalJSON 

func (s *SubscriptionQuotaItemProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubscriptionQuotaItemProperties.

type SubvolumeInfo 

type SubvolumeInfo struct {
	// Subvolume Properties
	Properties *SubvolumeProperties

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

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

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

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

SubvolumeInfo - Subvolume Information properties

func (SubvolumeInfo) MarshalJSON 

func (s SubvolumeInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumeInfo.

func (*SubvolumeInfo) UnmarshalJSON 

func (s *SubvolumeInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumeInfo.

type SubvolumeModel 

type SubvolumeModel struct {
	// It represents the minimal properties of the subvolume.
	Properties *SubvolumeModelProperties

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

SubvolumeModel - Result of the post subvolume and action is to get metadata of the subvolume.

func (SubvolumeModel) MarshalJSON 

func (s SubvolumeModel) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumeModel.

func (*SubvolumeModel) UnmarshalJSON 

func (s *SubvolumeModel) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumeModel.

type SubvolumeModelProperties 

type SubvolumeModelProperties struct {
	// Most recent access time and date
	AccessedTimeStamp *time.Time

	// Bytes used
	BytesUsed *int64

	// Most recent change time and date
	ChangedTimeStamp *time.Time

	// Creation time and date
	CreationTimeStamp *time.Time

	// Most recent modification time and date
	ModifiedTimeStamp *time.Time

	// Path to the parent subvolume
	ParentPath *string

	// Path to the subvolume
	Path *string

	// Permissions of the subvolume
	Permissions *string

	// Azure lifecycle management
	ProvisioningState *string

	// Size of subvolume
	Size *int64
}

SubvolumeModelProperties - Properties which represents actual subvolume model which is stored as a file in the system.

func (SubvolumeModelProperties) MarshalJSON 

func (s SubvolumeModelProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumeModelProperties.

func (*SubvolumeModelProperties) UnmarshalJSON 

func (s *SubvolumeModelProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumeModelProperties.

type SubvolumePatchParams 

type SubvolumePatchParams struct {
	// path to the subvolume
	Path *string

	// Truncate subvolume to the provided size in bytes
	Size *int64
}

SubvolumePatchParams - Parameters with which a subvolume can be updated

func (SubvolumePatchParams) MarshalJSON 

func (s SubvolumePatchParams) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumePatchParams.

func (*SubvolumePatchParams) UnmarshalJSON 

func (s *SubvolumePatchParams) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumePatchParams.

type SubvolumePatchRequest 

type SubvolumePatchRequest struct {
	// Subvolume Properties
	Properties *SubvolumePatchParams
}

SubvolumePatchRequest - Subvolume Patch Request properties

func (SubvolumePatchRequest) MarshalJSON 

func (s SubvolumePatchRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumePatchRequest.

func (*SubvolumePatchRequest) UnmarshalJSON 

func (s *SubvolumePatchRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumePatchRequest.

type SubvolumeProperties 

type SubvolumeProperties struct {
	// parent path to the subvolume
	ParentPath *string

	// Path to the subvolume
	Path *string

	// Truncate subvolume to the provided size in bytes
	Size *int64

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string
}

SubvolumeProperties - This represents path associated with the subvolume

func (SubvolumeProperties) MarshalJSON 

func (s SubvolumeProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumeProperties.

func (*SubvolumeProperties) UnmarshalJSON 

func (s *SubvolumeProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumeProperties.

type SubvolumesClient 

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

SubvolumesClient contains the methods for the Subvolumes group. Don't use this type directly, use NewSubvolumesClient() instead.

func NewSubvolumesClient 

func NewSubvolumesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SubvolumesClient, error)

NewSubvolumesClient creates a new instance of SubvolumesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SubvolumesClient) BeginCreate 

func (client *SubvolumesClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, subvolumeName string, body SubvolumeInfo, options *SubvolumesClientBeginCreateOptions) (*runtime.Poller[SubvolumesClientCreateResponse], error)

BeginCreate - Creates a subvolume in the path or clones the subvolume mentioned in the parentPath If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • subvolumeName - The name of the subvolume.
  • body - Subvolume object supplied in the body of the operation.
  • options - SubvolumesClientBeginCreateOptions contains the optional parameters for the SubvolumesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Subvolumes_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSubvolumesClient().BeginCreate(ctx, "myRG", "account1", "pool1", "volume1", "subvolume1", armnetapp.SubvolumeInfo{
	Properties: &armnetapp.SubvolumeProperties{
		Path: to.Ptr("/subvolumePath"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SubvolumeInfo = armnetapp.SubvolumeInfo{
// 	Name: to.Ptr("account1/pool1/volume1/subvolume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/subvolumes/subvolume1"),
// 	Properties: &armnetapp.SubvolumeProperties{
// 		Path: to.Ptr("/subvolumePath"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:

func (*SubvolumesClient) BeginDelete 

func (client *SubvolumesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, subvolumeName string, options *SubvolumesClientBeginDeleteOptions) (*runtime.Poller[SubvolumesClientDeleteResponse], error)

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

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • subvolumeName - The name of the subvolume.
  • options - SubvolumesClientBeginDeleteOptions contains the optional parameters for the SubvolumesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Subvolumes_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSubvolumesClient().BeginDelete(ctx, "myRG", "account1", "pool1", "volume1", "subvolume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SubvolumesClient) BeginGetMetadata 

func (client *SubvolumesClient) BeginGetMetadata(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, subvolumeName string, options *SubvolumesClientBeginGetMetadataOptions) (*runtime.Poller[SubvolumesClientGetMetadataResponse], error)

BeginGetMetadata - Get details of the specified subvolume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • subvolumeName - The name of the subvolume.
  • options - SubvolumesClientBeginGetMetadataOptions contains the optional parameters for the SubvolumesClient.BeginGetMetadata method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Subvolumes_Metadata.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSubvolumesClient().BeginGetMetadata(ctx, "myRG", "account1", "pool1", "volume1", "subvolume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SubvolumeModel = armnetapp.SubvolumeModel{
// 	Name: to.Ptr("account1/pool1/volume1/subvolume1/metadata"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes/metadata"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/subvolumes/subvolume1/metadata"),
// 	Properties: &armnetapp.SubvolumeModelProperties{
// 		Path: to.Ptr("/pathToSubvol"),
// 		AccessedTimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
// 		BytesUsed: to.Ptr[int64](5),
// 		ChangedTimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
// 		CreationTimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
// 		ModifiedTimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T13:23:33.000Z"); return t}()),
// 		Permissions: to.Ptr("777"),
// 		Size: to.Ptr[int64](5),
// 	},
// }

Output:

func (*SubvolumesClient) BeginUpdate 

func (client *SubvolumesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, subvolumeName string, body SubvolumePatchRequest, options *SubvolumesClientBeginUpdateOptions) (*runtime.Poller[SubvolumesClientUpdateResponse], error)

BeginUpdate - Patch a subvolume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • subvolumeName - The name of the subvolume.
  • body - Subvolume object supplied in the body of the operation.
  • options - SubvolumesClientBeginUpdateOptions contains the optional parameters for the SubvolumesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Subvolumes_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSubvolumesClient().BeginUpdate(ctx, "myRG", "account1", "pool1", "volume1", "subvolume1", armnetapp.SubvolumePatchRequest{
	Properties: &armnetapp.SubvolumePatchParams{
		Path: to.Ptr("/subvolumePath"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SubvolumeInfo = armnetapp.SubvolumeInfo{
// 	Name: to.Ptr("account1/pool1/volume1/subvolume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolume1"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/subvolumes/subvolume1"),
// 	Properties: &armnetapp.SubvolumeProperties{
// 		Path: to.Ptr("/subvolumePath"),
// 	},
// }

Output:

func (*SubvolumesClient) Get 

func (client *SubvolumesClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, subvolumeName string, options *SubvolumesClientGetOptions) (SubvolumesClientGetResponse, error)

Get - Returns the path associated with the subvolumeName provided If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • subvolumeName - The name of the subvolume.
  • options - SubvolumesClientGetOptions contains the optional parameters for the SubvolumesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Subvolumes_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSubvolumesClient().Get(ctx, "myRG", "account1", "pool1", "volume1", "subvolume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.SubvolumeInfo = armnetapp.SubvolumeInfo{
// 	Name: to.Ptr("account1/pool1/volume1/subvolume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/subvolumes/subvolume1"),
// 	Properties: &armnetapp.SubvolumeProperties{
// 		Path: to.Ptr("/pathToSubvol"),
// 	},
// }

Output:

func (*SubvolumesClient) NewListByVolumePager 

func (client *SubvolumesClient) NewListByVolumePager(resourceGroupName string, accountName string, poolName string, volumeName string, options *SubvolumesClientListByVolumeOptions) *runtime.Pager[SubvolumesClientListByVolumeResponse]

NewListByVolumePager - Returns a list of the subvolumes in the volume

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - SubvolumesClientListByVolumeOptions contains the optional parameters for the SubvolumesClient.NewListByVolumePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Subvolumes_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSubvolumesClient().NewListByVolumePager("myRG", "account1", "pool1", "volume1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.SubvolumesList = armnetapp.SubvolumesList{
	// 	Value: []*armnetapp.SubvolumeInfo{
	// 		{
	// 			Name: to.Ptr("account1/pool1/volume1/subvolume1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/subvolumes"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/subvolumes/subvolume1"),
	// 			Properties: &armnetapp.SubvolumeProperties{
	// 				Path: to.Ptr("/pathToSubvol"),
	// 			},
	// 	}},
	// }
}

Output:

type SubvolumesClientBeginCreateOptions 

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

SubvolumesClientBeginCreateOptions contains the optional parameters for the SubvolumesClient.BeginCreate method.

type SubvolumesClientBeginDeleteOptions 

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

SubvolumesClientBeginDeleteOptions contains the optional parameters for the SubvolumesClient.BeginDelete method.

type SubvolumesClientBeginGetMetadataOptions 

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

SubvolumesClientBeginGetMetadataOptions contains the optional parameters for the SubvolumesClient.BeginGetMetadata method.

type SubvolumesClientBeginUpdateOptions 

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

SubvolumesClientBeginUpdateOptions contains the optional parameters for the SubvolumesClient.BeginUpdate method.

type SubvolumesClientCreateResponse 

type SubvolumesClientCreateResponse struct {
	// Subvolume Information properties
	SubvolumeInfo
}

SubvolumesClientCreateResponse contains the response from method SubvolumesClient.BeginCreate.

type SubvolumesClientDeleteResponse 

type SubvolumesClientDeleteResponse struct {
}

SubvolumesClientDeleteResponse contains the response from method SubvolumesClient.BeginDelete.

type SubvolumesClientGetMetadataResponse 

type SubvolumesClientGetMetadataResponse struct {
	// Result of the post subvolume and action is to get metadata of the subvolume.
	SubvolumeModel
}

SubvolumesClientGetMetadataResponse contains the response from method SubvolumesClient.BeginGetMetadata.

type SubvolumesClientGetOptions 

type SubvolumesClientGetOptions struct {
}

SubvolumesClientGetOptions contains the optional parameters for the SubvolumesClient.Get method.

type SubvolumesClientGetResponse 

type SubvolumesClientGetResponse struct {
	// Subvolume Information properties
	SubvolumeInfo
}

SubvolumesClientGetResponse contains the response from method SubvolumesClient.Get.

type SubvolumesClientListByVolumeOptions 

type SubvolumesClientListByVolumeOptions struct {
}

SubvolumesClientListByVolumeOptions contains the optional parameters for the SubvolumesClient.NewListByVolumePager method.

type SubvolumesClientListByVolumeResponse 

type SubvolumesClientListByVolumeResponse struct {
	// List of Subvolumes
	SubvolumesList
}

SubvolumesClientListByVolumeResponse contains the response from method SubvolumesClient.NewListByVolumePager.

type SubvolumesClientUpdateResponse 

type SubvolumesClientUpdateResponse struct {
	// Subvolume Information properties
	SubvolumeInfo
}

SubvolumesClientUpdateResponse contains the response from method SubvolumesClient.BeginUpdate.

type SubvolumesList 

type SubvolumesList struct {
	// URL to get the next set of results.
	NextLink *string

	// A list of Subvolumes
	Value []*SubvolumeInfo
}

SubvolumesList - List of Subvolumes

func (SubvolumesList) MarshalJSON 

func (s SubvolumesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SubvolumesList.

func (*SubvolumesList) UnmarshalJSON 

func (s *SubvolumesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SubvolumesList.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type Type 

type Type string

Type - Type of quota 

const (
	// TypeDefaultGroupQuota - Default group quota
	TypeDefaultGroupQuota Type = "DefaultGroupQuota"
	// TypeDefaultUserQuota - Default user quota
	TypeDefaultUserQuota Type = "DefaultUserQuota"
	// TypeIndividualGroupQuota - Individual group quota
	TypeIndividualGroupQuota Type = "IndividualGroupQuota"
	// TypeIndividualUserQuota - Individual user quota
	TypeIndividualUserQuota Type = "IndividualUserQuota"
)

func PossibleTypeValues 

func PossibleTypeValues() []Type

PossibleTypeValues returns the possible values for the Type const type.

type UpdateNetworkSiblingSetRequest 

type UpdateNetworkSiblingSetRequest struct {
	// REQUIRED; Network features available to the volume, some such
	NetworkFeatures *NetworkFeatures

	// REQUIRED; Network Sibling Set ID for a group of volumes sharing networking resources in a subnet.
	NetworkSiblingSetID *string

	// REQUIRED; Network sibling set state Id identifying the current state of the sibling set.
	NetworkSiblingSetStateID *string

	// REQUIRED; The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes. Example
	// /subscriptions/subscriptionId/resourceGroups/resourceGroup/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/{mySubnet}
	SubnetID *string
}

UpdateNetworkSiblingSetRequest - Network sibling set update.

func (UpdateNetworkSiblingSetRequest) MarshalJSON 

func (u UpdateNetworkSiblingSetRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdateNetworkSiblingSetRequest.

func (*UpdateNetworkSiblingSetRequest) UnmarshalJSON 

func (u *UpdateNetworkSiblingSetRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateNetworkSiblingSetRequest.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type Volume 

type Volume struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Volume properties
	Properties *VolumeProperties

	// Resource tags.
	Tags map[string]*string

	// Availability Zone
	Zones []*string

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string

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

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

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

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

Volume resource

func (Volume) MarshalJSON 

func (v Volume) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Volume.

func (*Volume) UnmarshalJSON 

func (v *Volume) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Volume.

type VolumeBackups 

type VolumeBackups struct {
	// Total count of backups for volume
	BackupsCount *int32

	// Policy enabled
	PolicyEnabled *bool

	// Volume name
	VolumeName *string
}

VolumeBackups - Volume details using the backup policy

func (VolumeBackups) MarshalJSON 

func (v VolumeBackups) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeBackups.

func (*VolumeBackups) UnmarshalJSON 

func (v *VolumeBackups) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeBackups.

type VolumeGroup 

type VolumeGroup struct {
	// Resource location
	Location *string

	// Volume group properties
	Properties *VolumeGroupListProperties

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

VolumeGroup - Volume group resource

func (VolumeGroup) MarshalJSON 

func (v VolumeGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroup.

func (*VolumeGroup) UnmarshalJSON 

func (v *VolumeGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroup.

type VolumeGroupDetails 

type VolumeGroupDetails struct {
	// Resource location
	Location *string

	// Volume group properties
	Properties *VolumeGroupProperties

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

VolumeGroupDetails - Volume group resource for create

func (VolumeGroupDetails) MarshalJSON 

func (v VolumeGroupDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroupDetails.

func (*VolumeGroupDetails) UnmarshalJSON 

func (v *VolumeGroupDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroupDetails.

type VolumeGroupList 

type VolumeGroupList struct {
	// List of volume Groups
	Value []*VolumeGroup
}

VolumeGroupList - List of volume group resources

func (VolumeGroupList) MarshalJSON 

func (v VolumeGroupList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroupList.

func (*VolumeGroupList) UnmarshalJSON 

func (v *VolumeGroupList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroupList.

type VolumeGroupListProperties 

type VolumeGroupListProperties struct {
	// Volume group details
	GroupMetaData *VolumeGroupMetaData

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string
}

VolumeGroupListProperties - Volume group properties

func (VolumeGroupListProperties) MarshalJSON 

func (v VolumeGroupListProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroupListProperties.

func (*VolumeGroupListProperties) UnmarshalJSON 

func (v *VolumeGroupListProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroupListProperties.

type VolumeGroupMetaData 

type VolumeGroupMetaData struct {
	// Application specific identifier
	ApplicationIdentifier *string

	// Application Type
	ApplicationType *ApplicationType

	// Application specific placement rules for the volume group
	GlobalPlacementRules []*PlacementKeyValuePairs

	// Group Description
	GroupDescription *string

	// READ-ONLY; Number of volumes in volume group
	VolumesCount *int64
}

VolumeGroupMetaData - Volume group properties

func (VolumeGroupMetaData) MarshalJSON 

func (v VolumeGroupMetaData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroupMetaData.

func (*VolumeGroupMetaData) UnmarshalJSON 

func (v *VolumeGroupMetaData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroupMetaData.

type VolumeGroupProperties 

type VolumeGroupProperties struct {
	// Volume group details
	GroupMetaData *VolumeGroupMetaData

	// List of volumes from group
	Volumes []*VolumeGroupVolumeProperties

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string
}

VolumeGroupProperties - Volume group properties

func (VolumeGroupProperties) MarshalJSON 

func (v VolumeGroupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroupProperties.

func (*VolumeGroupProperties) UnmarshalJSON 

func (v *VolumeGroupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroupProperties.

type VolumeGroupVolumeProperties 

type VolumeGroupVolumeProperties struct {
	// REQUIRED; Volume properties
	Properties *VolumeProperties

	// Resource name
	Name *string

	// Resource tags
	Tags map[string]*string

	// Availability Zone
	Zones []*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource type
	Type *string
}

VolumeGroupVolumeProperties - Volume resource

func (VolumeGroupVolumeProperties) MarshalJSON 

func (v VolumeGroupVolumeProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeGroupVolumeProperties.

func (*VolumeGroupVolumeProperties) UnmarshalJSON 

func (v *VolumeGroupVolumeProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeGroupVolumeProperties.

type VolumeGroupsClient 

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

VolumeGroupsClient contains the methods for the VolumeGroups group. Don't use this type directly, use NewVolumeGroupsClient() instead.

func NewVolumeGroupsClient 

func NewVolumeGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VolumeGroupsClient, error)

NewVolumeGroupsClient creates a new instance of VolumeGroupsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VolumeGroupsClient) BeginCreate 

func (client *VolumeGroupsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, volumeGroupName string, body VolumeGroupDetails, options *VolumeGroupsClientBeginCreateOptions) (*runtime.Poller[VolumeGroupsClientCreateResponse], error)

BeginCreate - Create a volume group along with specified volumes If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • volumeGroupName - The name of the volumeGroup
  • body - Volume Group object supplied in the body of the operation.
  • options - VolumeGroupsClientBeginCreateOptions contains the optional parameters for the VolumeGroupsClient.BeginCreate method.
Example (VolumeGroupsCreateOracle)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_Create_Oracle.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumeGroupsClient().BeginCreate(ctx, "myRG", "account1", "group1", armnetapp.VolumeGroupDetails{
	Location: to.Ptr("westus"),
	Properties: &armnetapp.VolumeGroupProperties{
		GroupMetaData: &armnetapp.VolumeGroupMetaData{
			ApplicationIdentifier: to.Ptr("OR2"),
			ApplicationType:       to.Ptr(armnetapp.ApplicationTypeORACLE),
			GroupDescription:      to.Ptr("Volume group"),
		},
		Volumes: []*armnetapp.VolumeGroupVolumeProperties{
			{
				Name: to.Ptr("test-ora-data1"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data1"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data1"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data2"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data2"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data2"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data3"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data3"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data3"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data4"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data4"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data4"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data5"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data5"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data5"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data6"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data6"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data6"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data7"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data7"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data7"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-data8"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-data8"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-data8"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-log"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-log"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-log"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-log-mirror"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-log-mirror"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-log-mirror"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-binary"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-binary"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-binary"),
				},
				Zones: []*string{
					to.Ptr("1")},
			},
			{
				Name: to.Ptr("test-ora-backup"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-ora-backup"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ServiceLevel:    to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:        to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps: to.Ptr[float32](10),
					UsageThreshold:  to.Ptr[int64](107374182400),
					VolumeSpecName:  to.Ptr("ora-backup"),
				},
				Zones: []*string{
					to.Ptr("1")},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:
Example (VolumeGroupsCreateSapHana)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_Create_SapHana.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumeGroupsClient().BeginCreate(ctx, "myRG", "account1", "group1", armnetapp.VolumeGroupDetails{
	Location: to.Ptr("westus"),
	Properties: &armnetapp.VolumeGroupProperties{
		GroupMetaData: &armnetapp.VolumeGroupMetaData{
			ApplicationIdentifier: to.Ptr("SH9"),
			ApplicationType:       to.Ptr(armnetapp.ApplicationTypeSAPHANA),
			GroupDescription:      to.Ptr("Volume group"),
		},
		Volumes: []*armnetapp.VolumeGroupVolumeProperties{
			{
				Name: to.Ptr("test-data-mnt00001"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-data-mnt00001"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
					ServiceLevel:            to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:                to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps:         to.Ptr[float32](10),
					UsageThreshold:          to.Ptr[int64](107374182400),
					VolumeSpecName:          to.Ptr("data"),
				},
			},
			{
				Name: to.Ptr("test-log-mnt00001"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-log-mnt00001"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
					ServiceLevel:            to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:                to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps:         to.Ptr[float32](10),
					UsageThreshold:          to.Ptr[int64](107374182400),
					VolumeSpecName:          to.Ptr("log"),
				},
			},
			{
				Name: to.Ptr("test-shared"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-shared"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
					ServiceLevel:            to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:                to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps:         to.Ptr[float32](10),
					UsageThreshold:          to.Ptr[int64](107374182400),
					VolumeSpecName:          to.Ptr("shared"),
				},
			},
			{
				Name: to.Ptr("test-data-backup"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-data-backup"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
					ServiceLevel:            to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:                to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps:         to.Ptr[float32](10),
					UsageThreshold:          to.Ptr[int64](107374182400),
					VolumeSpecName:          to.Ptr("data-backup"),
				},
			},
			{
				Name: to.Ptr("test-log-backup"),
				Properties: &armnetapp.VolumeProperties{
					CapacityPoolResourceID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
					CreationToken:          to.Ptr("test-log-backup"),
					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
						Rules: []*armnetapp.ExportPolicyRule{
							{
								AllowedClients:      to.Ptr("0.0.0.0/0"),
								Cifs:                to.Ptr(false),
								HasRootAccess:       to.Ptr(true),
								Kerberos5ReadOnly:   to.Ptr(false),
								Kerberos5ReadWrite:  to.Ptr(false),
								Kerberos5IReadOnly:  to.Ptr(false),
								Kerberos5IReadWrite: to.Ptr(false),
								Kerberos5PReadOnly:  to.Ptr(false),
								Kerberos5PReadWrite: to.Ptr(false),
								Nfsv3:               to.Ptr(false),
								Nfsv41:              to.Ptr(true),
								RuleIndex:           to.Ptr[int32](1),
								UnixReadOnly:        to.Ptr(true),
								UnixReadWrite:       to.Ptr(true),
							}},
					},
					ProtocolTypes: []*string{
						to.Ptr("NFSv4.1")},
					ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
					ServiceLevel:            to.Ptr(armnetapp.ServiceLevelPremium),
					SubnetID:                to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
					ThroughputMibps:         to.Ptr[float32](10),
					UsageThreshold:          to.Ptr[int64](107374182400),
					VolumeSpecName:          to.Ptr("log-backup"),
				},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumeGroupsClient) BeginDelete 

func (client *VolumeGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, volumeGroupName string, options *VolumeGroupsClientBeginDeleteOptions) (*runtime.Poller[VolumeGroupsClientDeleteResponse], error)

BeginDelete - Delete the specified volume group only if there are no volumes under volume group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • volumeGroupName - The name of the volumeGroup
  • options - VolumeGroupsClientBeginDeleteOptions contains the optional parameters for the VolumeGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumeGroupsClient().BeginDelete(ctx, "myRG", "account1", "group1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumeGroupsClient) Get 

func (client *VolumeGroupsClient) Get(ctx context.Context, resourceGroupName string, accountName string, volumeGroupName string, options *VolumeGroupsClientGetOptions) (VolumeGroupsClientGetResponse, error)

Get - Get details of the specified volume group If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • volumeGroupName - The name of the volumeGroup
  • options - VolumeGroupsClientGetOptions contains the optional parameters for the VolumeGroupsClient.Get method.
Example (VolumeGroupsGetOracle)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_Get_Oracle.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVolumeGroupsClient().Get(ctx, "myRG", "account1", "group1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VolumeGroupDetails = armnetapp.VolumeGroupDetails{
// 	Name: to.Ptr("group1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups"),
// 	ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/volumeGroups/group1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.VolumeGroupProperties{
// 		GroupMetaData: &armnetapp.VolumeGroupMetaData{
// 			ApplicationIdentifier: to.Ptr("OR2"),
// 			ApplicationType: to.Ptr(armnetapp.ApplicationTypeORACLE),
// 			GroupDescription: to.Ptr("Volume group"),
// 			VolumesCount: to.Ptr[int64](12),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		Volumes: []*armnetapp.VolumeGroupVolumeProperties{
// 			{
// 				Name: to.Ptr("account1/pool1/test-ora-data1"),
// 				Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 				ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data1"),
// 				Properties: &armnetapp.VolumeProperties{
// 					CreationToken: to.Ptr("test-ora-data1"),
// 					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 						Rules: []*armnetapp.ExportPolicyRule{
// 							{
// 								AllowedClients: to.Ptr("0.0.0.0/0"),
// 								Cifs: to.Ptr(false),
// 								HasRootAccess: to.Ptr(true),
// 								Kerberos5ReadOnly: to.Ptr(false),
// 								Kerberos5ReadWrite: to.Ptr(false),
// 								Kerberos5IReadOnly: to.Ptr(false),
// 								Kerberos5IReadWrite: to.Ptr(false),
// 								Kerberos5PReadOnly: to.Ptr(false),
// 								Kerberos5PReadWrite: to.Ptr(false),
// 								Nfsv3: to.Ptr(false),
// 								Nfsv41: to.Ptr(true),
// 								RuleIndex: to.Ptr[int32](1),
// 								UnixReadOnly: to.Ptr(true),
// 								UnixReadWrite: to.Ptr(true),
// 						}},
// 					},
// 					ProtocolTypes: []*string{
// 						to.Ptr("NFSv4.1")},
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 						SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 						ThroughputMibps: to.Ptr[float32](10),
// 						UsageThreshold: to.Ptr[int64](107374182400),
// 						VolumeSpecName: to.Ptr("ora-data1"),
// 					},
// 					Zones: []*string{
// 						to.Ptr("1")},
// 					},
// 					{
// 						Name: to.Ptr("account1/pool1/test-ora-data2"),
// 						Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 						ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data2"),
// 						Properties: &armnetapp.VolumeProperties{
// 							CreationToken: to.Ptr("test-ora-data2"),
// 							ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 								Rules: []*armnetapp.ExportPolicyRule{
// 									{
// 										AllowedClients: to.Ptr("0.0.0.0/0"),
// 										Cifs: to.Ptr(false),
// 										HasRootAccess: to.Ptr(true),
// 										Kerberos5ReadOnly: to.Ptr(false),
// 										Kerberos5ReadWrite: to.Ptr(false),
// 										Kerberos5IReadOnly: to.Ptr(false),
// 										Kerberos5IReadWrite: to.Ptr(false),
// 										Kerberos5PReadOnly: to.Ptr(false),
// 										Kerberos5PReadWrite: to.Ptr(false),
// 										Nfsv3: to.Ptr(false),
// 										Nfsv41: to.Ptr(true),
// 										RuleIndex: to.Ptr[int32](1),
// 										UnixReadOnly: to.Ptr(true),
// 										UnixReadWrite: to.Ptr(true),
// 								}},
// 							},
// 							ProtocolTypes: []*string{
// 								to.Ptr("NFSv4.1")},
// 								ProvisioningState: to.Ptr("Succeeded"),
// 								ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 								SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 								ThroughputMibps: to.Ptr[float32](10),
// 								UsageThreshold: to.Ptr[int64](107374182400),
// 								VolumeSpecName: to.Ptr("ora-data2"),
// 							},
// 							Zones: []*string{
// 								to.Ptr("1")},
// 							},
// 							{
// 								Name: to.Ptr("account1/pool1/test-ora-data3"),
// 								Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 								ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data3"),
// 								Properties: &armnetapp.VolumeProperties{
// 									CreationToken: to.Ptr("test-ora-data3"),
// 									ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 										Rules: []*armnetapp.ExportPolicyRule{
// 											{
// 												AllowedClients: to.Ptr("0.0.0.0/0"),
// 												Cifs: to.Ptr(false),
// 												HasRootAccess: to.Ptr(true),
// 												Kerberos5ReadOnly: to.Ptr(false),
// 												Kerberos5ReadWrite: to.Ptr(false),
// 												Kerberos5IReadOnly: to.Ptr(false),
// 												Kerberos5IReadWrite: to.Ptr(false),
// 												Kerberos5PReadOnly: to.Ptr(false),
// 												Kerberos5PReadWrite: to.Ptr(false),
// 												Nfsv3: to.Ptr(false),
// 												Nfsv41: to.Ptr(true),
// 												RuleIndex: to.Ptr[int32](1),
// 												UnixReadOnly: to.Ptr(true),
// 												UnixReadWrite: to.Ptr(true),
// 										}},
// 									},
// 									ProtocolTypes: []*string{
// 										to.Ptr("NFSv4.1")},
// 										ProvisioningState: to.Ptr("Succeeded"),
// 										ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 										SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 										ThroughputMibps: to.Ptr[float32](10),
// 										UsageThreshold: to.Ptr[int64](107374182400),
// 										VolumeSpecName: to.Ptr("ora-data3"),
// 									},
// 									Zones: []*string{
// 										to.Ptr("1")},
// 									},
// 									{
// 										Name: to.Ptr("account1/pool1/test-ora-data4"),
// 										Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 										ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data4"),
// 										Properties: &armnetapp.VolumeProperties{
// 											CreationToken: to.Ptr("test-ora-data4"),
// 											ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 												Rules: []*armnetapp.ExportPolicyRule{
// 													{
// 														AllowedClients: to.Ptr("0.0.0.0/0"),
// 														Cifs: to.Ptr(false),
// 														HasRootAccess: to.Ptr(true),
// 														Kerberos5ReadOnly: to.Ptr(false),
// 														Kerberos5ReadWrite: to.Ptr(false),
// 														Kerberos5IReadOnly: to.Ptr(false),
// 														Kerberos5IReadWrite: to.Ptr(false),
// 														Kerberos5PReadOnly: to.Ptr(false),
// 														Kerberos5PReadWrite: to.Ptr(false),
// 														Nfsv3: to.Ptr(false),
// 														Nfsv41: to.Ptr(true),
// 														RuleIndex: to.Ptr[int32](1),
// 														UnixReadOnly: to.Ptr(true),
// 														UnixReadWrite: to.Ptr(true),
// 												}},
// 											},
// 											ProtocolTypes: []*string{
// 												to.Ptr("NFSv4.1")},
// 												ProvisioningState: to.Ptr("Succeeded"),
// 												ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 												SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 												ThroughputMibps: to.Ptr[float32](10),
// 												UsageThreshold: to.Ptr[int64](107374182400),
// 												VolumeSpecName: to.Ptr("ora-data4"),
// 											},
// 											Zones: []*string{
// 												to.Ptr("1")},
// 											},
// 											{
// 												Name: to.Ptr("account1/pool1/test-ora-data5"),
// 												Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 												ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data5"),
// 												Properties: &armnetapp.VolumeProperties{
// 													CreationToken: to.Ptr("test-ora-data5"),
// 													ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 														Rules: []*armnetapp.ExportPolicyRule{
// 															{
// 																AllowedClients: to.Ptr("0.0.0.0/0"),
// 																Cifs: to.Ptr(false),
// 																HasRootAccess: to.Ptr(true),
// 																Kerberos5ReadOnly: to.Ptr(false),
// 																Kerberos5ReadWrite: to.Ptr(false),
// 																Kerberos5IReadOnly: to.Ptr(false),
// 																Kerberos5IReadWrite: to.Ptr(false),
// 																Kerberos5PReadOnly: to.Ptr(false),
// 																Kerberos5PReadWrite: to.Ptr(false),
// 																Nfsv3: to.Ptr(false),
// 																Nfsv41: to.Ptr(true),
// 																RuleIndex: to.Ptr[int32](1),
// 																UnixReadOnly: to.Ptr(true),
// 																UnixReadWrite: to.Ptr(true),
// 														}},
// 													},
// 													ProtocolTypes: []*string{
// 														to.Ptr("NFSv4.1")},
// 														ProvisioningState: to.Ptr("Succeeded"),
// 														ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 														SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 														ThroughputMibps: to.Ptr[float32](10),
// 														UsageThreshold: to.Ptr[int64](107374182400),
// 														VolumeSpecName: to.Ptr("ora-data5"),
// 													},
// 													Zones: []*string{
// 														to.Ptr("1")},
// 													},
// 													{
// 														Name: to.Ptr("account1/pool1/test-ora-data6"),
// 														Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 														ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data6"),
// 														Properties: &armnetapp.VolumeProperties{
// 															CreationToken: to.Ptr("test-ora-data6"),
// 															ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																Rules: []*armnetapp.ExportPolicyRule{
// 																	{
// 																		AllowedClients: to.Ptr("0.0.0.0/0"),
// 																		Cifs: to.Ptr(false),
// 																		HasRootAccess: to.Ptr(true),
// 																		Kerberos5ReadOnly: to.Ptr(false),
// 																		Kerberos5ReadWrite: to.Ptr(false),
// 																		Kerberos5IReadOnly: to.Ptr(false),
// 																		Kerberos5IReadWrite: to.Ptr(false),
// 																		Kerberos5PReadOnly: to.Ptr(false),
// 																		Kerberos5PReadWrite: to.Ptr(false),
// 																		Nfsv3: to.Ptr(false),
// 																		Nfsv41: to.Ptr(true),
// 																		RuleIndex: to.Ptr[int32](1),
// 																		UnixReadOnly: to.Ptr(true),
// 																		UnixReadWrite: to.Ptr(true),
// 																}},
// 															},
// 															ProtocolTypes: []*string{
// 																to.Ptr("NFSv4.1")},
// 																ProvisioningState: to.Ptr("Succeeded"),
// 																ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																ThroughputMibps: to.Ptr[float32](10),
// 																UsageThreshold: to.Ptr[int64](107374182400),
// 																VolumeSpecName: to.Ptr("ora-data6"),
// 															},
// 															Zones: []*string{
// 																to.Ptr("1")},
// 															},
// 															{
// 																Name: to.Ptr("account1/pool1/test-ora-data7"),
// 																Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 																ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data7"),
// 																Properties: &armnetapp.VolumeProperties{
// 																	CreationToken: to.Ptr("test-ora-data7"),
// 																	ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																		Rules: []*armnetapp.ExportPolicyRule{
// 																			{
// 																				AllowedClients: to.Ptr("0.0.0.0/0"),
// 																				Cifs: to.Ptr(false),
// 																				HasRootAccess: to.Ptr(true),
// 																				Kerberos5ReadOnly: to.Ptr(false),
// 																				Kerberos5ReadWrite: to.Ptr(false),
// 																				Kerberos5IReadOnly: to.Ptr(false),
// 																				Kerberos5IReadWrite: to.Ptr(false),
// 																				Kerberos5PReadOnly: to.Ptr(false),
// 																				Kerberos5PReadWrite: to.Ptr(false),
// 																				Nfsv3: to.Ptr(false),
// 																				Nfsv41: to.Ptr(true),
// 																				RuleIndex: to.Ptr[int32](1),
// 																				UnixReadOnly: to.Ptr(true),
// 																				UnixReadWrite: to.Ptr(true),
// 																		}},
// 																	},
// 																	ProtocolTypes: []*string{
// 																		to.Ptr("NFSv4.1")},
// 																		ProvisioningState: to.Ptr("Succeeded"),
// 																		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																		SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																		ThroughputMibps: to.Ptr[float32](10),
// 																		UsageThreshold: to.Ptr[int64](107374182400),
// 																		VolumeSpecName: to.Ptr("ora-data7"),
// 																	},
// 																	Zones: []*string{
// 																		to.Ptr("1")},
// 																	},
// 																	{
// 																		Name: to.Ptr("account1/pool1/test-ora-data8"),
// 																		Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 																		ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-data8"),
// 																		Properties: &armnetapp.VolumeProperties{
// 																			CreationToken: to.Ptr("test-ora-data8"),
// 																			ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																				Rules: []*armnetapp.ExportPolicyRule{
// 																					{
// 																						AllowedClients: to.Ptr("0.0.0.0/0"),
// 																						Cifs: to.Ptr(false),
// 																						HasRootAccess: to.Ptr(true),
// 																						Kerberos5ReadOnly: to.Ptr(false),
// 																						Kerberos5ReadWrite: to.Ptr(false),
// 																						Kerberos5IReadOnly: to.Ptr(false),
// 																						Kerberos5IReadWrite: to.Ptr(false),
// 																						Kerberos5PReadOnly: to.Ptr(false),
// 																						Kerberos5PReadWrite: to.Ptr(false),
// 																						Nfsv3: to.Ptr(false),
// 																						Nfsv41: to.Ptr(true),
// 																						RuleIndex: to.Ptr[int32](1),
// 																						UnixReadOnly: to.Ptr(true),
// 																						UnixReadWrite: to.Ptr(true),
// 																				}},
// 																			},
// 																			ProtocolTypes: []*string{
// 																				to.Ptr("NFSv4.1")},
// 																				ProvisioningState: to.Ptr("Succeeded"),
// 																				ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																				SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																				ThroughputMibps: to.Ptr[float32](10),
// 																				UsageThreshold: to.Ptr[int64](107374182400),
// 																				VolumeSpecName: to.Ptr("ora-data8"),
// 																			},
// 																			Zones: []*string{
// 																				to.Ptr("1")},
// 																			},
// 																			{
// 																				Name: to.Ptr("account1/pool1/test-ora-log"),
// 																				Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 																				ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-log"),
// 																				Properties: &armnetapp.VolumeProperties{
// 																					CreationToken: to.Ptr("test-ora-log"),
// 																					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																						Rules: []*armnetapp.ExportPolicyRule{
// 																							{
// 																								AllowedClients: to.Ptr("0.0.0.0/0"),
// 																								Cifs: to.Ptr(false),
// 																								HasRootAccess: to.Ptr(true),
// 																								Kerberos5ReadOnly: to.Ptr(false),
// 																								Kerberos5ReadWrite: to.Ptr(false),
// 																								Kerberos5IReadOnly: to.Ptr(false),
// 																								Kerberos5IReadWrite: to.Ptr(false),
// 																								Kerberos5PReadOnly: to.Ptr(false),
// 																								Kerberos5PReadWrite: to.Ptr(false),
// 																								Nfsv3: to.Ptr(false),
// 																								Nfsv41: to.Ptr(true),
// 																								RuleIndex: to.Ptr[int32](1),
// 																								UnixReadOnly: to.Ptr(true),
// 																								UnixReadWrite: to.Ptr(true),
// 																						}},
// 																					},
// 																					ProtocolTypes: []*string{
// 																						to.Ptr("NFSv4.1")},
// 																						ProvisioningState: to.Ptr("Succeeded"),
// 																						ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																						SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																						ThroughputMibps: to.Ptr[float32](10),
// 																						UsageThreshold: to.Ptr[int64](107374182400),
// 																						VolumeSpecName: to.Ptr("ora-log"),
// 																					},
// 																					Zones: []*string{
// 																						to.Ptr("1")},
// 																					},
// 																					{
// 																						Name: to.Ptr("account1/pool1/test-ora-log-mirror"),
// 																						Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 																						ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-log-mirror"),
// 																						Properties: &armnetapp.VolumeProperties{
// 																							CreationToken: to.Ptr("test-ora-log-mirror"),
// 																							ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																								Rules: []*armnetapp.ExportPolicyRule{
// 																									{
// 																										AllowedClients: to.Ptr("0.0.0.0/0"),
// 																										Cifs: to.Ptr(false),
// 																										HasRootAccess: to.Ptr(true),
// 																										Kerberos5ReadOnly: to.Ptr(false),
// 																										Kerberos5ReadWrite: to.Ptr(false),
// 																										Kerberos5IReadOnly: to.Ptr(false),
// 																										Kerberos5IReadWrite: to.Ptr(false),
// 																										Kerberos5PReadOnly: to.Ptr(false),
// 																										Kerberos5PReadWrite: to.Ptr(false),
// 																										Nfsv3: to.Ptr(false),
// 																										Nfsv41: to.Ptr(true),
// 																										RuleIndex: to.Ptr[int32](1),
// 																										UnixReadOnly: to.Ptr(true),
// 																										UnixReadWrite: to.Ptr(true),
// 																								}},
// 																							},
// 																							ProtocolTypes: []*string{
// 																								to.Ptr("NFSv4.1")},
// 																								ProvisioningState: to.Ptr("Succeeded"),
// 																								ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																								SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																								ThroughputMibps: to.Ptr[float32](10),
// 																								UsageThreshold: to.Ptr[int64](107374182400),
// 																								VolumeSpecName: to.Ptr("ora-log-mirror"),
// 																							},
// 																							Zones: []*string{
// 																								to.Ptr("1")},
// 																							},
// 																							{
// 																								Name: to.Ptr("account1/pool1/test-ora-binary"),
// 																								Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 																								ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-binary"),
// 																								Properties: &armnetapp.VolumeProperties{
// 																									CreationToken: to.Ptr("test-ora-binary"),
// 																									ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																										Rules: []*armnetapp.ExportPolicyRule{
// 																											{
// 																												AllowedClients: to.Ptr("0.0.0.0/0"),
// 																												Cifs: to.Ptr(false),
// 																												HasRootAccess: to.Ptr(true),
// 																												Kerberos5ReadOnly: to.Ptr(false),
// 																												Kerberos5ReadWrite: to.Ptr(false),
// 																												Kerberos5IReadOnly: to.Ptr(false),
// 																												Kerberos5IReadWrite: to.Ptr(false),
// 																												Kerberos5PReadOnly: to.Ptr(false),
// 																												Kerberos5PReadWrite: to.Ptr(false),
// 																												Nfsv3: to.Ptr(false),
// 																												Nfsv41: to.Ptr(true),
// 																												RuleIndex: to.Ptr[int32](1),
// 																												UnixReadOnly: to.Ptr(true),
// 																												UnixReadWrite: to.Ptr(true),
// 																										}},
// 																									},
// 																									ProtocolTypes: []*string{
// 																										to.Ptr("NFSv4.1")},
// 																										ProvisioningState: to.Ptr("Succeeded"),
// 																										ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																										SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																										ThroughputMibps: to.Ptr[float32](10),
// 																										UsageThreshold: to.Ptr[int64](107374182400),
// 																										VolumeSpecName: to.Ptr("ora-binary"),
// 																									},
// 																									Zones: []*string{
// 																										to.Ptr("1")},
// 																									},
// 																									{
// 																										Name: to.Ptr("account1/pool1/test-ora-backup"),
// 																										Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 																										ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-ora-backup"),
// 																										Properties: &armnetapp.VolumeProperties{
// 																											CreationToken: to.Ptr("test-ora-backup"),
// 																											ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 																												Rules: []*armnetapp.ExportPolicyRule{
// 																													{
// 																														AllowedClients: to.Ptr("0.0.0.0/0"),
// 																														Cifs: to.Ptr(false),
// 																														HasRootAccess: to.Ptr(true),
// 																														Kerberos5ReadOnly: to.Ptr(false),
// 																														Kerberos5ReadWrite: to.Ptr(false),
// 																														Kerberos5IReadOnly: to.Ptr(false),
// 																														Kerberos5IReadWrite: to.Ptr(false),
// 																														Kerberos5PReadOnly: to.Ptr(false),
// 																														Kerberos5PReadWrite: to.Ptr(false),
// 																														Nfsv3: to.Ptr(false),
// 																														Nfsv41: to.Ptr(true),
// 																														RuleIndex: to.Ptr[int32](1),
// 																														UnixReadOnly: to.Ptr(true),
// 																														UnixReadWrite: to.Ptr(true),
// 																												}},
// 																											},
// 																											ProtocolTypes: []*string{
// 																												to.Ptr("NFSv4.1")},
// 																												ProvisioningState: to.Ptr("Succeeded"),
// 																												ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 																												SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 																												ThroughputMibps: to.Ptr[float32](10),
// 																												UsageThreshold: to.Ptr[int64](107374182400),
// 																												VolumeSpecName: to.Ptr("ora-backup"),
// 																											},
// 																											Zones: []*string{
// 																												to.Ptr("1")},
// 																										}},
// 																									},
// 																								}

Output:
Example (VolumeGroupsGetSapHana)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_Get_SapHana.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVolumeGroupsClient().Get(ctx, "myRG", "account1", "group1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VolumeGroupDetails = armnetapp.VolumeGroupDetails{
// 	Name: to.Ptr("group1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups"),
// 	ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/volumeGroups/group1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.VolumeGroupProperties{
// 		GroupMetaData: &armnetapp.VolumeGroupMetaData{
// 			ApplicationIdentifier: to.Ptr("SH9"),
// 			ApplicationType: to.Ptr(armnetapp.ApplicationTypeSAPHANA),
// 			GroupDescription: to.Ptr("Volume group"),
// 			VolumesCount: to.Ptr[int64](5),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		Volumes: []*armnetapp.VolumeGroupVolumeProperties{
// 			{
// 				Name: to.Ptr("account1/pool1/test-data-mnt00001"),
// 				Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 				ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-data-mnt00001"),
// 				Properties: &armnetapp.VolumeProperties{
// 					CreationToken: to.Ptr("test-data-mnt00001"),
// 					ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 						Rules: []*armnetapp.ExportPolicyRule{
// 							{
// 								AllowedClients: to.Ptr("0.0.0.0/0"),
// 								Cifs: to.Ptr(false),
// 								HasRootAccess: to.Ptr(true),
// 								Kerberos5ReadOnly: to.Ptr(false),
// 								Kerberos5ReadWrite: to.Ptr(false),
// 								Kerberos5IReadOnly: to.Ptr(false),
// 								Kerberos5IReadWrite: to.Ptr(false),
// 								Kerberos5PReadOnly: to.Ptr(false),
// 								Kerberos5PReadWrite: to.Ptr(false),
// 								Nfsv3: to.Ptr(false),
// 								Nfsv41: to.Ptr(true),
// 								RuleIndex: to.Ptr[int32](1),
// 								UnixReadOnly: to.Ptr(true),
// 								UnixReadWrite: to.Ptr(true),
// 						}},
// 					},
// 					ProtocolTypes: []*string{
// 						to.Ptr("NFSv4.1")},
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
// 						ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 						SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 						ThroughputMibps: to.Ptr[float32](10),
// 						UsageThreshold: to.Ptr[int64](107374182400),
// 						VolumeSpecName: to.Ptr("data"),
// 					},
// 				},
// 				{
// 					Name: to.Ptr("account1/pool1/test-log-mnt00001"),
// 					Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 					ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-log-mnt00001"),
// 					Properties: &armnetapp.VolumeProperties{
// 						CreationToken: to.Ptr("test-log-mnt00001"),
// 						ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 							Rules: []*armnetapp.ExportPolicyRule{
// 								{
// 									AllowedClients: to.Ptr("0.0.0.0/0"),
// 									Cifs: to.Ptr(false),
// 									HasRootAccess: to.Ptr(true),
// 									Kerberos5ReadOnly: to.Ptr(false),
// 									Kerberos5ReadWrite: to.Ptr(false),
// 									Kerberos5IReadOnly: to.Ptr(false),
// 									Kerberos5IReadWrite: to.Ptr(false),
// 									Kerberos5PReadOnly: to.Ptr(false),
// 									Kerberos5PReadWrite: to.Ptr(false),
// 									Nfsv3: to.Ptr(false),
// 									Nfsv41: to.Ptr(true),
// 									RuleIndex: to.Ptr[int32](1),
// 									UnixReadOnly: to.Ptr(true),
// 									UnixReadWrite: to.Ptr(true),
// 							}},
// 						},
// 						ProtocolTypes: []*string{
// 							to.Ptr("NFSv4.1")},
// 							ProvisioningState: to.Ptr("Succeeded"),
// 							ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
// 							ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 							SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 							ThroughputMibps: to.Ptr[float32](10),
// 							UsageThreshold: to.Ptr[int64](107374182400),
// 							VolumeSpecName: to.Ptr("log"),
// 						},
// 					},
// 					{
// 						Name: to.Ptr("account1/pool1/test-shared"),
// 						Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 						ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-shared"),
// 						Properties: &armnetapp.VolumeProperties{
// 							CreationToken: to.Ptr("test-shared"),
// 							ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 								Rules: []*armnetapp.ExportPolicyRule{
// 									{
// 										AllowedClients: to.Ptr("0.0.0.0/0"),
// 										Cifs: to.Ptr(false),
// 										HasRootAccess: to.Ptr(true),
// 										Kerberos5ReadOnly: to.Ptr(false),
// 										Kerberos5ReadWrite: to.Ptr(false),
// 										Kerberos5IReadOnly: to.Ptr(false),
// 										Kerberos5IReadWrite: to.Ptr(false),
// 										Kerberos5PReadOnly: to.Ptr(false),
// 										Kerberos5PReadWrite: to.Ptr(false),
// 										Nfsv3: to.Ptr(false),
// 										Nfsv41: to.Ptr(true),
// 										RuleIndex: to.Ptr[int32](1),
// 										UnixReadOnly: to.Ptr(true),
// 										UnixReadWrite: to.Ptr(true),
// 								}},
// 							},
// 							ProtocolTypes: []*string{
// 								to.Ptr("NFSv4.1")},
// 								ProvisioningState: to.Ptr("Succeeded"),
// 								ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
// 								ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 								SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 								ThroughputMibps: to.Ptr[float32](10),
// 								UsageThreshold: to.Ptr[int64](107374182400),
// 								VolumeSpecName: to.Ptr("shared"),
// 							},
// 						},
// 						{
// 							Name: to.Ptr("account1/pool1/test-data-backup"),
// 							Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 							ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-data-backup"),
// 							Properties: &armnetapp.VolumeProperties{
// 								CreationToken: to.Ptr("test-data-backup"),
// 								ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 									Rules: []*armnetapp.ExportPolicyRule{
// 										{
// 											AllowedClients: to.Ptr("0.0.0.0/0"),
// 											Cifs: to.Ptr(false),
// 											HasRootAccess: to.Ptr(true),
// 											Kerberos5ReadOnly: to.Ptr(false),
// 											Kerberos5ReadWrite: to.Ptr(false),
// 											Kerberos5IReadOnly: to.Ptr(false),
// 											Kerberos5IReadWrite: to.Ptr(false),
// 											Kerberos5PReadOnly: to.Ptr(false),
// 											Kerberos5PReadWrite: to.Ptr(false),
// 											Nfsv3: to.Ptr(false),
// 											Nfsv41: to.Ptr(true),
// 											RuleIndex: to.Ptr[int32](1),
// 											UnixReadOnly: to.Ptr(true),
// 											UnixReadWrite: to.Ptr(true),
// 									}},
// 								},
// 								ProtocolTypes: []*string{
// 									to.Ptr("NFSv4.1")},
// 									ProvisioningState: to.Ptr("Succeeded"),
// 									ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
// 									ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 									SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 									ThroughputMibps: to.Ptr[float32](10),
// 									UsageThreshold: to.Ptr[int64](107374182400),
// 									VolumeSpecName: to.Ptr("data-backup"),
// 								},
// 							},
// 							{
// 								Name: to.Ptr("account1/pool1/test-log-backup"),
// 								Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 								ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/test-log-backup"),
// 								Properties: &armnetapp.VolumeProperties{
// 									CreationToken: to.Ptr("test-log-backup"),
// 									ExportPolicy: &armnetapp.VolumePropertiesExportPolicy{
// 										Rules: []*armnetapp.ExportPolicyRule{
// 											{
// 												AllowedClients: to.Ptr("0.0.0.0/0"),
// 												Cifs: to.Ptr(false),
// 												HasRootAccess: to.Ptr(true),
// 												Kerberos5ReadOnly: to.Ptr(false),
// 												Kerberos5ReadWrite: to.Ptr(false),
// 												Kerberos5IReadOnly: to.Ptr(false),
// 												Kerberos5IReadWrite: to.Ptr(false),
// 												Kerberos5PReadOnly: to.Ptr(false),
// 												Kerberos5PReadWrite: to.Ptr(false),
// 												Nfsv3: to.Ptr(false),
// 												Nfsv41: to.Ptr(true),
// 												RuleIndex: to.Ptr[int32](1),
// 												UnixReadOnly: to.Ptr(true),
// 												UnixReadWrite: to.Ptr(true),
// 										}},
// 									},
// 									ProtocolTypes: []*string{
// 										to.Ptr("NFSv4.1")},
// 										ProvisioningState: to.Ptr("Succeeded"),
// 										ProximityPlacementGroup: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/cys_sjain_fcp_rg/providers/Microsoft.Compute/proximityPlacementGroups/svlqa_sjain_multivolume_ppg"),
// 										ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 										SubnetID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 										ThroughputMibps: to.Ptr[float32](10),
// 										UsageThreshold: to.Ptr[int64](107374182400),
// 										VolumeSpecName: to.Ptr("log-backup"),
// 									},
// 							}},
// 						},
// 					}

Output:

func (*VolumeGroupsClient) NewListByNetAppAccountPager 

func (client *VolumeGroupsClient) NewListByNetAppAccountPager(resourceGroupName string, accountName string, options *VolumeGroupsClientListByNetAppAccountOptions) *runtime.Pager[VolumeGroupsClientListByNetAppAccountResponse]

NewListByNetAppAccountPager - List all volume groups for given account

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • options - VolumeGroupsClientListByNetAppAccountOptions contains the optional parameters for the VolumeGroupsClient.NewListByNetAppAccountPager method.
Example (VolumeGroupsListOracle)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_List_Oracle.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewVolumeGroupsClient().NewListByNetAppAccountPager("myRG", "account1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.VolumeGroupList = armnetapp.VolumeGroupList{
	// 	Value: []*armnetapp.VolumeGroup{
	// 		{
	// 			Name: to.Ptr("group1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups"),
	// 			ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/volumeGroups/group1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.VolumeGroupListProperties{
	// 				GroupMetaData: &armnetapp.VolumeGroupMetaData{
	// 					ApplicationIdentifier: to.Ptr("DEV"),
	// 					ApplicationType: to.Ptr(armnetapp.ApplicationTypeORACLE),
	// 					GroupDescription: to.Ptr("Volume group"),
	// 					VolumesCount: to.Ptr[int64](12),
	// 				},
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 			},
	// 	}},
	// }
}

Output:
Example (VolumeGroupsListSapHana)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeGroups_List_SapHana.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewVolumeGroupsClient().NewListByNetAppAccountPager("myRG", "account1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.VolumeGroupList = armnetapp.VolumeGroupList{
	// 	Value: []*armnetapp.VolumeGroup{
	// 		{
	// 			Name: to.Ptr("group1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/volumeGroups"),
	// 			ID: to.Ptr("/subscriptions/d633cc2e-722b-4ae1-b636-bbd9e4c60ed9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/volumeGroups/group1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.VolumeGroupListProperties{
	// 				GroupMetaData: &armnetapp.VolumeGroupMetaData{
	// 					ApplicationIdentifier: to.Ptr("SH9"),
	// 					ApplicationType: to.Ptr(armnetapp.ApplicationTypeSAPHANA),
	// 					GroupDescription: to.Ptr("Volume group"),
	// 					VolumesCount: to.Ptr[int64](5),
	// 				},
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 			},
	// 	}},
	// }
}

Output:

type VolumeGroupsClientBeginCreateOptions 

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

VolumeGroupsClientBeginCreateOptions contains the optional parameters for the VolumeGroupsClient.BeginCreate method.

type VolumeGroupsClientBeginDeleteOptions 

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

VolumeGroupsClientBeginDeleteOptions contains the optional parameters for the VolumeGroupsClient.BeginDelete method.

type VolumeGroupsClientCreateResponse 

type VolumeGroupsClientCreateResponse struct {
	// Volume group resource for create
	VolumeGroupDetails
}

VolumeGroupsClientCreateResponse contains the response from method VolumeGroupsClient.BeginCreate.

type VolumeGroupsClientDeleteResponse 

type VolumeGroupsClientDeleteResponse struct {
}

VolumeGroupsClientDeleteResponse contains the response from method VolumeGroupsClient.BeginDelete.

type VolumeGroupsClientGetOptions 

type VolumeGroupsClientGetOptions struct {
}

VolumeGroupsClientGetOptions contains the optional parameters for the VolumeGroupsClient.Get method.

type VolumeGroupsClientGetResponse 

type VolumeGroupsClientGetResponse struct {
	// Volume group resource for create
	VolumeGroupDetails
}

VolumeGroupsClientGetResponse contains the response from method VolumeGroupsClient.Get.

type VolumeGroupsClientListByNetAppAccountOptions 

type VolumeGroupsClientListByNetAppAccountOptions struct {
}

VolumeGroupsClientListByNetAppAccountOptions contains the optional parameters for the VolumeGroupsClient.NewListByNetAppAccountPager method.

type VolumeGroupsClientListByNetAppAccountResponse 

type VolumeGroupsClientListByNetAppAccountResponse struct {
	// List of volume group resources
	VolumeGroupList
}

VolumeGroupsClientListByNetAppAccountResponse contains the response from method VolumeGroupsClient.NewListByNetAppAccountPager.

type VolumeList 

type VolumeList struct {
	// URL to get the next set of results.
	NextLink *string

	// List of volumes
	Value []*Volume
}

VolumeList - List of volume resources

func (VolumeList) MarshalJSON 

func (v VolumeList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeList.

func (*VolumeList) UnmarshalJSON 

func (v *VolumeList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeList.

type VolumePatch 

type VolumePatch struct {
	// Resource location
	Location *string

	// Patchable volume properties
	Properties *VolumePatchProperties

	// Resource tags
	Tags map[string]*string

	// READ-ONLY; Resource Id
	ID *string

	// READ-ONLY; Resource name
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

VolumePatch - Volume patch resource

func (VolumePatch) MarshalJSON 

func (v VolumePatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumePatch.

func (*VolumePatch) UnmarshalJSON 

func (v *VolumePatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumePatch.

type VolumePatchProperties 

type VolumePatchProperties struct {
	// Specifies whether Cool Access(tiering) is enabled for the volume.
	CoolAccess *bool

	// coolAccessRetrievalPolicy determines the data retrieval behavior from the cool tier to standard storage based on the read
	// pattern for cool access enabled volumes. The possible values for this field
	// are: Default - Data will be pulled from cool tier to standard storage on random reads. This policy is the default. OnRead
	// - All client-driven data read is pulled from cool tier to standard storage on
	// both sequential and random reads. Never - No client-driven data is pulled from cool tier to standard storage.
	CoolAccessRetrievalPolicy *CoolAccessRetrievalPolicy

	// Specifies the number of days after which data that is not accessed by clients will be tiered.
	CoolnessPeriod *int32

	// DataProtection type volumes include an object containing details of the replication
	DataProtection *VolumePatchPropertiesDataProtection

	// Default group quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies.
	DefaultGroupQuotaInKiBs *int64

	// Default user quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies .
	DefaultUserQuotaInKiBs *int64

	// Set of export policy rules
	ExportPolicy *VolumePatchPropertiesExportPolicy

	// Specifies if default quota is enabled for the volume.
	IsDefaultQuotaEnabled *bool

	// The service level of the file system
	ServiceLevel *ServiceLevel

	// Enables access-based enumeration share property for SMB Shares. Only applicable for SMB/DualProtocol volume
	SmbAccessBasedEnumeration *SmbAccessBasedEnumeration

	// Enables non-browsable property for SMB Shares. Only applicable for SMB/DualProtocol volume
	SmbNonBrowsable *SmbNonBrowsable

	// If enabled (true) the volume will contain a read-only snapshot directory which provides access to each of the volume's
	// snapshots.
	SnapshotDirectoryVisible *bool

	// Maximum throughput in MiB/s that can be achieved by this volume and this will be accepted as input only for manual qosType
	// volume
	ThroughputMibps *float32

	// UNIX permissions for NFS volume accepted in octal 4 digit format. First digit selects the set user ID(4), set group ID
	// (2) and sticky (1) attributes. Second digit selects permission for the owner of
	// the file: read (4), write (2) and execute (1). Third selects permissions for other users in the same group. the fourth
	// for other users not in the group. 0755 - gives read/write/execute permissions to
	// owner and read/execute to group and other users.
	UnixPermissions *string

	// Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. Minimum size is
	// 100 GiB. Upper limit is 100TiB, 500Tib for LargeVolume or 2400Tib for LargeVolume
	// on exceptional basis. Specified in bytes.
	UsageThreshold *int64
}

VolumePatchProperties - Patchable volume properties

func (VolumePatchProperties) MarshalJSON 

func (v VolumePatchProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumePatchProperties.

func (*VolumePatchProperties) UnmarshalJSON 

func (v *VolumePatchProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumePatchProperties.

type VolumePatchPropertiesDataProtection 

type VolumePatchPropertiesDataProtection struct {
	// Snapshot properties.
	Snapshot *VolumeSnapshotProperties
}

VolumePatchPropertiesDataProtection - DataProtection type volumes include an object containing details of the replication

func (VolumePatchPropertiesDataProtection) MarshalJSON 

func (v VolumePatchPropertiesDataProtection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumePatchPropertiesDataProtection.

func (*VolumePatchPropertiesDataProtection) UnmarshalJSON 

func (v *VolumePatchPropertiesDataProtection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumePatchPropertiesDataProtection.

type VolumePatchPropertiesExportPolicy 

type VolumePatchPropertiesExportPolicy struct {
	// Export policy rule
	Rules []*ExportPolicyRule
}

VolumePatchPropertiesExportPolicy - Set of export policy rules

func (VolumePatchPropertiesExportPolicy) MarshalJSON 

func (v VolumePatchPropertiesExportPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumePatchPropertiesExportPolicy.

func (*VolumePatchPropertiesExportPolicy) UnmarshalJSON 

func (v *VolumePatchPropertiesExportPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumePatchPropertiesExportPolicy.

type VolumeProperties 

type VolumeProperties struct {
	// REQUIRED; A unique file path for the volume. Used when creating mount targets
	CreationToken *string

	// REQUIRED; The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes
	SubnetID *string

	// REQUIRED; Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. Minimum
	// size is 100 GiB. Upper limit is 100TiB, 500Tib for LargeVolume or 2400Tib for LargeVolume
	// on exceptional basis. Specified in bytes.
	UsageThreshold *int64

	// Specifies whether the volume is enabled for Azure VMware Solution (AVS) datastore purpose
	AvsDataStore *AvsDataStore

	// UUID v4 or resource identifier used to identify the Backup.
	BackupID *string

	// Pool Resource Id used in case of creating a volume through volume group
	CapacityPoolResourceID *string

	// Specifies whether Cool Access(tiering) is enabled for the volume.
	CoolAccess *bool

	// coolAccessRetrievalPolicy determines the data retrieval behavior from the cool tier to standard storage based on the read
	// pattern for cool access enabled volumes. The possible values for this field
	// are: Default - Data will be pulled from cool tier to standard storage on random reads. This policy is the default. OnRead
	// - All client-driven data read is pulled from cool tier to standard storage on
	// both sequential and random reads. Never - No client-driven data is pulled from cool tier to standard storage.
	CoolAccessRetrievalPolicy *CoolAccessRetrievalPolicy

	// Specifies the number of days after which data that is not accessed by clients will be tiered.
	CoolnessPeriod *int32

	// DataProtection type volumes include an object containing details of the replication
	DataProtection *VolumePropertiesDataProtection

	// Default group quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies.
	DefaultGroupQuotaInKiBs *int64

	// Default user quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies .
	DefaultUserQuotaInKiBs *int64

	// If enabled (true) the snapshot the volume was created from will be automatically deleted after the volume create operation
	// has finished. Defaults to false
	DeleteBaseSnapshot *bool

	// Flag indicating whether subvolume operations are enabled on the volume
	EnableSubvolumes *EnableSubvolumes

	// Source of key used to encrypt data in volume. Applicable if NetApp account has encryption.keySource = 'Microsoft.KeyVault'.
	// Possible values (case-insensitive) are: 'Microsoft.NetApp,
	// Microsoft.KeyVault'
	EncryptionKeySource *EncryptionKeySource

	// Set of export policy rules
	ExportPolicy *VolumePropertiesExportPolicy

	// Specifies if default quota is enabled for the volume.
	IsDefaultQuotaEnabled *bool

	// Specifies whether volume is a Large Volume or Regular Volume.
	IsLargeVolume *bool

	// Restoring
	IsRestoring *bool

	// Describe if a volume is KerberosEnabled. To be use with swagger version 2020-05-01 or later
	KerberosEnabled *bool

	// The resource ID of private endpoint for KeyVault. It must reside in the same VNET as the volume. Only applicable if encryptionKeySource
	// = 'Microsoft.KeyVault'.
	KeyVaultPrivateEndpointResourceID *string

	// Specifies whether LDAP is enabled or not for a given NFS volume.
	LdapEnabled *bool

	// Network features available to the volume, or current state of update.
	NetworkFeatures *NetworkFeatures

	// Application specific placement rules for the particular volume
	PlacementRules []*PlacementKeyValuePairs

	// Set of protocol types, default NFSv3, CIFS for SMB protocol
	ProtocolTypes []*string

	// Proximity placement group associated with the volume
	ProximityPlacementGroup *string

	// The security style of volume, default unix, defaults to ntfs for dual protocol or CIFS protocol
	SecurityStyle *SecurityStyle

	// The service level of the file system
	ServiceLevel *ServiceLevel

	// Enables access-based enumeration share property for SMB Shares. Only applicable for SMB/DualProtocol volume
	SmbAccessBasedEnumeration *SmbAccessBasedEnumeration

	// Enables continuously available share property for smb volume. Only applicable for SMB volume
	SmbContinuouslyAvailable *bool

	// Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol volume. To be used with swagger version
	// 2020-08-01 or later
	SmbEncryption *bool

	// Enables non-browsable property for SMB Shares. Only applicable for SMB/DualProtocol volume
	SmbNonBrowsable *SmbNonBrowsable

	// If enabled (true) the volume will contain a read-only snapshot directory which provides access to each of the volume's
	// snapshots (defaults to true).
	SnapshotDirectoryVisible *bool

	// UUID v4 or resource identifier used to identify the Snapshot.
	SnapshotID *string

	// Maximum throughput in MiB/s that can be achieved by this volume and this will be accepted as input only for manual qosType
	// volume
	ThroughputMibps *float32

	// UNIX permissions for NFS volume accepted in octal 4 digit format. First digit selects the set user ID(4), set group ID
	// (2) and sticky (1) attributes. Second digit selects permission for the owner of
	// the file: read (4), write (2) and execute (1). Third selects permissions for other users in the same group. the fourth
	// for other users not in the group. 0755 - gives read/write/execute permissions to
	// owner and read/execute to group and other users.
	UnixPermissions *string

	// Volume spec name is the application specific designation or identifier for the particular volume in a volume group for
	// e.g. data, log
	VolumeSpecName *string

	// What type of volume is this. For destination volumes in Cross Region Replication, set type to DataProtection
	VolumeType *string

	// READ-ONLY; Actual throughput in MiB/s for auto qosType volumes calculated based on size and serviceLevel
	ActualThroughputMibps *float32

	// READ-ONLY; Unique Baremetal Tenant Identifier.
	BaremetalTenantID *string

	// READ-ONLY; When a volume is being restored from another volume's snapshot, will show the percentage completion of this
	// cloning process. When this value is empty/null there is no cloning process currently
	// happening on this volume. This value will update every 5 minutes during cloning.
	CloneProgress *int32

	// READ-ONLY; Data store resource unique identifier
	DataStoreResourceID []*string

	// READ-ONLY; Specifies if the volume is encrypted or not. Only available on volumes created or updated after 2022-01-01.
	Encrypted *bool

	// READ-ONLY; Flag indicating whether file access logs are enabled for the volume, based on active diagnostic settings present
	// on the volume.
	FileAccessLogs *FileAccessLogs

	// READ-ONLY; Unique FileSystem Identifier.
	FileSystemID *string

	// READ-ONLY; Maximum number of files allowed. Needs a service request in order to be changed. Only allowed to be changed
	// if volume quota is more than 4TiB.
	MaximumNumberOfFiles *int64

	// READ-ONLY; List of mount targets
	MountTargets []*MountTargetProperties

	// READ-ONLY; Network Sibling Set ID for the the group of volumes sharing networking resources.
	NetworkSiblingSetID *string

	// READ-ONLY; Id of the snapshot or backup that the volume is restored from.
	OriginatingResourceID *string

	// READ-ONLY; The availability zone where the volume is provisioned. This refers to the logical availability zone where the
	// volume resides.
	ProvisionedAvailabilityZone *string

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string

	// READ-ONLY; Provides storage to network proximity information for the volume.
	StorageToNetworkProximity *VolumeStorageToNetworkProximity

	// READ-ONLY; T2 network information
	T2Network *string

	// READ-ONLY; Volume Group Name
	VolumeGroupName *string
}

VolumeProperties - Volume properties

func (VolumeProperties) MarshalJSON 

func (v VolumeProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeProperties.

func (*VolumeProperties) UnmarshalJSON 

func (v *VolumeProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeProperties.

type VolumePropertiesDataProtection 

type VolumePropertiesDataProtection struct {
	// Replication properties
	Replication *ReplicationObject

	// Snapshot properties.
	Snapshot *VolumeSnapshotProperties

	// VolumeRelocation properties
	VolumeRelocation *VolumeRelocationProperties
}

VolumePropertiesDataProtection - DataProtection type volumes include an object containing details of the replication

func (VolumePropertiesDataProtection) MarshalJSON 

func (v VolumePropertiesDataProtection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumePropertiesDataProtection.

func (*VolumePropertiesDataProtection) UnmarshalJSON 

func (v *VolumePropertiesDataProtection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumePropertiesDataProtection.

type VolumePropertiesExportPolicy 

type VolumePropertiesExportPolicy struct {
	// Export policy rule
	Rules []*ExportPolicyRule
}

VolumePropertiesExportPolicy - Set of export policy rules

func (VolumePropertiesExportPolicy) MarshalJSON 

func (v VolumePropertiesExportPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumePropertiesExportPolicy.

func (*VolumePropertiesExportPolicy) UnmarshalJSON 

func (v *VolumePropertiesExportPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumePropertiesExportPolicy.

type VolumeQuotaRule 

type VolumeQuotaRule struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Volume Quota Rule Properties
	Properties *VolumeQuotaRulesProperties

	// Resource tags.
	Tags map[string]*string

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

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

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

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

VolumeQuotaRule - Quota Rule of a Volume

func (VolumeQuotaRule) MarshalJSON 

func (v VolumeQuotaRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeQuotaRule.

func (*VolumeQuotaRule) UnmarshalJSON 

func (v *VolumeQuotaRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeQuotaRule.

type VolumeQuotaRulePatch 

type VolumeQuotaRulePatch struct {
	// Volume Quota Rule Properties
	Properties *VolumeQuotaRulesProperties

	// Resource tags
	Tags map[string]*string
}

VolumeQuotaRulePatch - Patchable Quota Rule of a Volume

func (VolumeQuotaRulePatch) MarshalJSON 

func (v VolumeQuotaRulePatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeQuotaRulePatch.

func (*VolumeQuotaRulePatch) UnmarshalJSON 

func (v *VolumeQuotaRulePatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeQuotaRulePatch.

type VolumeQuotaRulesClient 

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

VolumeQuotaRulesClient contains the methods for the VolumeQuotaRules group. Don't use this type directly, use NewVolumeQuotaRulesClient() instead.

func NewVolumeQuotaRulesClient 

func NewVolumeQuotaRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VolumeQuotaRulesClient, error)

NewVolumeQuotaRulesClient creates a new instance of VolumeQuotaRulesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VolumeQuotaRulesClient) BeginCreate 

func (client *VolumeQuotaRulesClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, volumeQuotaRuleName string, body VolumeQuotaRule, options *VolumeQuotaRulesClientBeginCreateOptions) (*runtime.Poller[VolumeQuotaRulesClientCreateResponse], error)

BeginCreate - Create the specified quota rule within the given volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • volumeQuotaRuleName - The name of volume quota rule
  • body - Quota rule object supplied in the body of the operation.
  • options - VolumeQuotaRulesClientBeginCreateOptions contains the optional parameters for the VolumeQuotaRulesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeQuotaRules_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumeQuotaRulesClient().BeginCreate(ctx, "myRG", "account-9957", "pool-5210", "volume-6387", "rule-0004", armnetapp.VolumeQuotaRule{
	Location: to.Ptr("westus"),
	Properties: &armnetapp.VolumeQuotaRulesProperties{
		QuotaSizeInKiBs: to.Ptr[int64](100005),
		QuotaTarget:     to.Ptr("1821"),
		QuotaType:       to.Ptr(armnetapp.TypeIndividualUserQuota),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VolumeQuotaRule = armnetapp.VolumeQuotaRule{
// 	Name: to.Ptr("account-9957/pool-5210/volume-6387/rule-0004"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/volumeQuotaRules"),
// 	ID: to.Ptr("/subscriptions/5275316f-a498-48d6-b324-2cbfdc4311b9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account-9957/capacityPools/pool-5210/volumes/volume-6387/volumeQuotaRules/rule-0004"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetapp.VolumeQuotaRulesProperties{
// 		ProvisioningState: to.Ptr(armnetapp.ProvisioningStateSucceeded),
// 		QuotaSizeInKiBs: to.Ptr[int64](100005),
// 		QuotaTarget: to.Ptr("1821"),
// 		QuotaType: to.Ptr(armnetapp.TypeIndividualUserQuota),
// 	},
// }

Output:

func (*VolumeQuotaRulesClient) BeginDelete 

func (client *VolumeQuotaRulesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, volumeQuotaRuleName string, options *VolumeQuotaRulesClientBeginDeleteOptions) (*runtime.Poller[VolumeQuotaRulesClientDeleteResponse], error)

BeginDelete - Delete quota rule If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • volumeQuotaRuleName - The name of volume quota rule
  • options - VolumeQuotaRulesClientBeginDeleteOptions contains the optional parameters for the VolumeQuotaRulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeQuotaRules_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumeQuotaRulesClient().BeginDelete(ctx, "myRG", "account-9957", "pool-5210", "volume-6387", "rule-0004", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumeQuotaRulesClient) BeginUpdate 

func (client *VolumeQuotaRulesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, volumeQuotaRuleName string, body VolumeQuotaRulePatch, options *VolumeQuotaRulesClientBeginUpdateOptions) (*runtime.Poller[VolumeQuotaRulesClientUpdateResponse], error)

BeginUpdate - Patch a quota rule If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • volumeQuotaRuleName - The name of volume quota rule
  • body - Quota rule object supplied in the body of the operation.
  • options - VolumeQuotaRulesClientBeginUpdateOptions contains the optional parameters for the VolumeQuotaRulesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeQuotaRules_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumeQuotaRulesClient().BeginUpdate(ctx, "myRG", "account-9957", "pool-5210", "volume-6387", "rule-0004", armnetapp.VolumeQuotaRulePatch{
	Properties: &armnetapp.VolumeQuotaRulesProperties{
		QuotaSizeInKiBs: to.Ptr[int64](100009),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VolumeQuotaRule = armnetapp.VolumeQuotaRule{
// 	Name: to.Ptr("account-9957/pool-5210/volume-6387/rule-0004"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/volumeQuotaRules"),
// 	ID: to.Ptr("/subscriptions/5275316f-a498-48d6-b324-2cbfdc4311b9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account-9957/capacityPools/pool-5210/volumes/volume-6387/volumeQuotaRules/rule-0004"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetapp.VolumeQuotaRulesProperties{
// 		ProvisioningState: to.Ptr(armnetapp.ProvisioningStateSucceeded),
// 		QuotaSizeInKiBs: to.Ptr[int64](100005),
// 		QuotaTarget: to.Ptr("1821"),
// 		QuotaType: to.Ptr(armnetapp.TypeIndividualUserQuota),
// 	},
// }

Output:

func (*VolumeQuotaRulesClient) Get 

func (client *VolumeQuotaRulesClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, volumeQuotaRuleName string, options *VolumeQuotaRulesClientGetOptions) (VolumeQuotaRulesClientGetResponse, error)

Get - Get details of the specified quota rule If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • volumeQuotaRuleName - The name of volume quota rule
  • options - VolumeQuotaRulesClientGetOptions contains the optional parameters for the VolumeQuotaRulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeQuotaRules_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVolumeQuotaRulesClient().Get(ctx, "myRG", "account-9957", "pool-5210", "volume-6387", "rule-0004", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.VolumeQuotaRule = armnetapp.VolumeQuotaRule{
// 	Name: to.Ptr("account-9957/pool-5210/volume-6387/rule-0004"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/volumeQuotaRules"),
// 	ID: to.Ptr("/subscriptions/5275316f-a498-48d6-b324-2cbfdc4311b9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account-9957/capacityPools/pool-5210/volumes/volume-6387/volumeQuotaRules/rule-0004"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armnetapp.VolumeQuotaRulesProperties{
// 		ProvisioningState: to.Ptr(armnetapp.ProvisioningStateSucceeded),
// 		QuotaSizeInKiBs: to.Ptr[int64](100005),
// 		QuotaTarget: to.Ptr("1821"),
// 		QuotaType: to.Ptr(armnetapp.TypeIndividualUserQuota),
// 	},
// }

Output:

func (*VolumeQuotaRulesClient) NewListByVolumePager 

func (client *VolumeQuotaRulesClient) NewListByVolumePager(resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumeQuotaRulesClientListByVolumeOptions) *runtime.Pager[VolumeQuotaRulesClientListByVolumeResponse]

NewListByVolumePager - List all quota rules associated with the volume

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumeQuotaRulesClientListByVolumeOptions contains the optional parameters for the VolumeQuotaRulesClient.NewListByVolumePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/VolumeQuotaRules_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewVolumeQuotaRulesClient().NewListByVolumePager("myRG", "account-9957", "pool-5210", "volume-6387", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.VolumeQuotaRulesList = armnetapp.VolumeQuotaRulesList{
	// 	Value: []*armnetapp.VolumeQuotaRule{
	// 		{
	// 			Name: to.Ptr("account-9957/pool-5210/volume-6387/rule-0004"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes/volumeQuotaRules"),
	// 			ID: to.Ptr("/subscriptions/5275316f-a498-48d6-b324-2cbfdc4311b9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account-9957/capacityPools/pool-5210/volumes/volume-6387/volumeQuotaRules/rule-0004"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armnetapp.VolumeQuotaRulesProperties{
	// 				ProvisioningState: to.Ptr(armnetapp.ProvisioningStateSucceeded),
	// 				QuotaSizeInKiBs: to.Ptr[int64](100005),
	// 				QuotaTarget: to.Ptr("1821"),
	// 				QuotaType: to.Ptr(armnetapp.TypeIndividualUserQuota),
	// 			},
	// 	}},
	// }
}

Output:

type VolumeQuotaRulesClientBeginCreateOptions 

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

VolumeQuotaRulesClientBeginCreateOptions contains the optional parameters for the VolumeQuotaRulesClient.BeginCreate method.

type VolumeQuotaRulesClientBeginDeleteOptions 

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

VolumeQuotaRulesClientBeginDeleteOptions contains the optional parameters for the VolumeQuotaRulesClient.BeginDelete method.

type VolumeQuotaRulesClientBeginUpdateOptions 

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

VolumeQuotaRulesClientBeginUpdateOptions contains the optional parameters for the VolumeQuotaRulesClient.BeginUpdate method.

type VolumeQuotaRulesClientCreateResponse 

type VolumeQuotaRulesClientCreateResponse struct {
	// Quota Rule of a Volume
	VolumeQuotaRule
}

VolumeQuotaRulesClientCreateResponse contains the response from method VolumeQuotaRulesClient.BeginCreate.

type VolumeQuotaRulesClientDeleteResponse 

type VolumeQuotaRulesClientDeleteResponse struct {
}

VolumeQuotaRulesClientDeleteResponse contains the response from method VolumeQuotaRulesClient.BeginDelete.

type VolumeQuotaRulesClientGetOptions 

type VolumeQuotaRulesClientGetOptions struct {
}

VolumeQuotaRulesClientGetOptions contains the optional parameters for the VolumeQuotaRulesClient.Get method.

type VolumeQuotaRulesClientGetResponse 

type VolumeQuotaRulesClientGetResponse struct {
	// Quota Rule of a Volume
	VolumeQuotaRule
}

VolumeQuotaRulesClientGetResponse contains the response from method VolumeQuotaRulesClient.Get.

type VolumeQuotaRulesClientListByVolumeOptions 

type VolumeQuotaRulesClientListByVolumeOptions struct {
}

VolumeQuotaRulesClientListByVolumeOptions contains the optional parameters for the VolumeQuotaRulesClient.NewListByVolumePager method.

type VolumeQuotaRulesClientListByVolumeResponse 

type VolumeQuotaRulesClientListByVolumeResponse struct {
	// List of Volume Quota Rules
	VolumeQuotaRulesList
}

VolumeQuotaRulesClientListByVolumeResponse contains the response from method VolumeQuotaRulesClient.NewListByVolumePager.

type VolumeQuotaRulesClientUpdateResponse 

type VolumeQuotaRulesClientUpdateResponse struct {
	// Quota Rule of a Volume
	VolumeQuotaRule
}

VolumeQuotaRulesClientUpdateResponse contains the response from method VolumeQuotaRulesClient.BeginUpdate.

type VolumeQuotaRulesList 

type VolumeQuotaRulesList struct {
	// A list of Volume Quota Rules
	Value []*VolumeQuotaRule
}

VolumeQuotaRulesList - List of Volume Quota Rules

func (VolumeQuotaRulesList) MarshalJSON 

func (v VolumeQuotaRulesList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeQuotaRulesList.

func (*VolumeQuotaRulesList) UnmarshalJSON 

func (v *VolumeQuotaRulesList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeQuotaRulesList.

type VolumeQuotaRulesProperties 

type VolumeQuotaRulesProperties struct {
	// Size of quota
	QuotaSizeInKiBs *int64

	// UserID/GroupID/SID based on the quota target type. UserID and groupID can be found by running ‘id’ or ‘getent’ command
	// for the user or group and SID can be found by running
	QuotaTarget *string

	// Type of quota
	QuotaType *Type

	// READ-ONLY; Gets the status of the VolumeQuotaRule at the time the operation was called.
	ProvisioningState *ProvisioningState
}

VolumeQuotaRulesProperties - Volume Quota Rule properties

func (VolumeQuotaRulesProperties) MarshalJSON 

func (v VolumeQuotaRulesProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeQuotaRulesProperties.

func (*VolumeQuotaRulesProperties) UnmarshalJSON 

func (v *VolumeQuotaRulesProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeQuotaRulesProperties.

type VolumeRelocationProperties 

type VolumeRelocationProperties struct {
	// Has relocation been requested for this volume
	RelocationRequested *bool

	// READ-ONLY; Has relocation finished and is ready to be cleaned up
	ReadyToBeFinalized *bool
}

VolumeRelocationProperties - Volume relocation properties

func (VolumeRelocationProperties) MarshalJSON 

func (v VolumeRelocationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeRelocationProperties.

func (*VolumeRelocationProperties) UnmarshalJSON 

func (v *VolumeRelocationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeRelocationProperties.

type VolumeRevert 

type VolumeRevert struct {
	// Resource id of the snapshot
	SnapshotID *string
}

VolumeRevert - revert a volume to the snapshot

func (VolumeRevert) MarshalJSON 

func (v VolumeRevert) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeRevert.

func (*VolumeRevert) UnmarshalJSON 

func (v *VolumeRevert) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeRevert.

type VolumeSnapshotProperties 

type VolumeSnapshotProperties struct {
	// Snapshot Policy ResourceId
	SnapshotPolicyID *string
}

VolumeSnapshotProperties - Volume Snapshot Properties

func (VolumeSnapshotProperties) MarshalJSON 

func (v VolumeSnapshotProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeSnapshotProperties.

func (*VolumeSnapshotProperties) UnmarshalJSON 

func (v *VolumeSnapshotProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeSnapshotProperties.

type VolumeStorageToNetworkProximity 

type VolumeStorageToNetworkProximity string

VolumeStorageToNetworkProximity - Provides storage to network proximity information for the volume. 

const (
	// VolumeStorageToNetworkProximityAcrossT2 - Standard AcrossT2 storage to network connectivity.
	VolumeStorageToNetworkProximityAcrossT2 VolumeStorageToNetworkProximity = "AcrossT2"
	// VolumeStorageToNetworkProximityDefault - Basic storage to network connectivity.
	VolumeStorageToNetworkProximityDefault VolumeStorageToNetworkProximity = "Default"
	// VolumeStorageToNetworkProximityT1 - Standard T1 storage to network connectivity.
	VolumeStorageToNetworkProximityT1 VolumeStorageToNetworkProximity = "T1"
	// VolumeStorageToNetworkProximityT2 - Standard T2 storage to network connectivity.
	VolumeStorageToNetworkProximityT2 VolumeStorageToNetworkProximity = "T2"
)

func PossibleVolumeStorageToNetworkProximityValues 

func PossibleVolumeStorageToNetworkProximityValues() []VolumeStorageToNetworkProximity

PossibleVolumeStorageToNetworkProximityValues returns the possible values for the VolumeStorageToNetworkProximity const type.

type VolumesClient 

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

VolumesClient contains the methods for the Volumes group. Don't use this type directly, use NewVolumesClient() instead.

func NewVolumesClient 

func NewVolumesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VolumesClient, error)

NewVolumesClient creates a new instance of VolumesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VolumesClient) BeginAuthorizeReplication 

func (client *VolumesClient) BeginAuthorizeReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body AuthorizeRequest, options *VolumesClientBeginAuthorizeReplicationOptions) (*runtime.Poller[VolumesClientAuthorizeReplicationResponse], error)

BeginAuthorizeReplication - Authorize the replication connection on the source volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - Authorize request object supplied in the body of the operation.
  • options - VolumesClientBeginAuthorizeReplicationOptions contains the optional parameters for the VolumesClient.BeginAuthorizeReplication method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_AuthorizeReplication.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginAuthorizeReplication(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.AuthorizeRequest{
	RemoteVolumeResourceID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRemoteRG/providers/Microsoft.NetApp/netAppAccounts/remoteAccount1/capacityPools/remotePool1/volumes/remoteVolume1"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginBreakFileLocks 

func (client *VolumesClient) BeginBreakFileLocks(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginBreakFileLocksOptions) (*runtime.Poller[VolumesClientBreakFileLocksResponse], error)

BeginBreakFileLocks - Break all the file locks on a volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginBreakFileLocksOptions contains the optional parameters for the VolumesClient.BeginBreakFileLocks method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_BreakFileLocks.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginBreakFileLocks(ctx, "myRG", "account1", "pool1", "volume1", &armnetapp.VolumesClientBeginBreakFileLocksOptions{Body: &armnetapp.BreakFileLocksRequest{
	ClientIP:                          to.Ptr("101.102.103.104"),
	ConfirmRunningDisruptiveOperation: to.Ptr(true),
},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginBreakReplication 

func (client *VolumesClient) BeginBreakReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginBreakReplicationOptions) (*runtime.Poller[VolumesClientBreakReplicationResponse], error)

BeginBreakReplication - Break the replication connection on the destination volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginBreakReplicationOptions contains the optional parameters for the VolumesClient.BeginBreakReplication method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_BreakReplication.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginBreakReplication(ctx, "myRG", "account1", "pool1", "volume1", &armnetapp.VolumesClientBeginBreakReplicationOptions{Body: &armnetapp.BreakReplicationRequest{
	ForceBreakReplication: to.Ptr(false),
},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginCreateOrUpdate 

func (client *VolumesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body Volume, options *VolumesClientBeginCreateOrUpdateOptions) (*runtime.Poller[VolumesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the specified volume within the capacity pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - Volume object supplied in the body of the operation.
  • options - VolumesClientBeginCreateOrUpdateOptions contains the optional parameters for the VolumesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginCreateOrUpdate(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.Volume{
	Location: to.Ptr("eastus"),
	Properties: &armnetapp.VolumeProperties{
		CreationToken:  to.Ptr("my-unique-file-path"),
		ServiceLevel:   to.Ptr(armnetapp.ServiceLevelPremium),
		SubnetID:       to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
		UsageThreshold: to.Ptr[int64](107374182400),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Volume = armnetapp.Volume{
// 	Name: to.Ptr("account1/pool1/volume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.VolumeProperties{
// 		CreationToken: to.Ptr("some-amazing-filepath"),
// 		EncryptionKeySource: to.Ptr(armnetapp.EncryptionKeySourceMicrosoftNetApp),
// 		FileSystemID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 		ThroughputMibps: to.Ptr[float32](128),
// 		UsageThreshold: to.Ptr[int64](107374182400),
// 	},
// }

Output:

func (*VolumesClient) BeginDelete 

func (client *VolumesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginDeleteOptions) (*runtime.Poller[VolumesClientDeleteResponse], error)

BeginDelete - Delete the specified volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginDeleteOptions contains the optional parameters for the VolumesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginDelete(ctx, "myRG", "account1", "pool1", "volume1", &armnetapp.VolumesClientBeginDeleteOptions{ForceDelete: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginDeleteReplication 

func (client *VolumesClient) BeginDeleteReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginDeleteReplicationOptions) (*runtime.Poller[VolumesClientDeleteReplicationResponse], error)

BeginDeleteReplication - Delete the replication connection on the destination volume, and send release to the source replication If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginDeleteReplicationOptions contains the optional parameters for the VolumesClient.BeginDeleteReplication method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_DeleteReplication.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginDeleteReplication(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginFinalizeRelocation 

func (client *VolumesClient) BeginFinalizeRelocation(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginFinalizeRelocationOptions) (*runtime.Poller[VolumesClientFinalizeRelocationResponse], error)

BeginFinalizeRelocation - Finalizes the relocation of the volume and cleans up the old volume. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginFinalizeRelocationOptions contains the optional parameters for the VolumesClient.BeginFinalizeRelocation method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_FinalizeRelocation.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginFinalizeRelocation(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginListGetGroupIDListForLdapUser 

func (client *VolumesClient) BeginListGetGroupIDListForLdapUser(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body GetGroupIDListForLDAPUserRequest, options *VolumesClientBeginListGetGroupIDListForLdapUserOptions) (*runtime.Poller[VolumesClientListGetGroupIDListForLdapUserResponse], error)

BeginListGetGroupIDListForLdapUser - Returns the list of group Ids for a specific LDAP User If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - Returns group Id list for a specific LDAP user
  • options - VolumesClientBeginListGetGroupIDListForLdapUserOptions contains the optional parameters for the VolumesClient.BeginListGetGroupIDListForLdapUser method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/GroupIdListForLDAPUser.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginListGetGroupIDListForLdapUser(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.GetGroupIDListForLDAPUserRequest{
	Username: to.Ptr("user1"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.GetGroupIDListForLDAPUserResponse = armnetapp.GetGroupIDListForLDAPUserResponse{
// 	GroupIDsForLdapUser: []*string{
// 		to.Ptr("123"),
// 		to.Ptr("224")},
// 	}

Output:

func (*VolumesClient) BeginPoolChange 

func (client *VolumesClient) BeginPoolChange(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body PoolChangeRequest, options *VolumesClientBeginPoolChangeOptions) (*runtime.Poller[VolumesClientPoolChangeResponse], error)

BeginPoolChange - Moves volume to another pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - Move volume to the pool supplied in the body of the operation.
  • options - VolumesClientBeginPoolChangeOptions contains the optional parameters for the VolumesClient.BeginPoolChange method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_PoolChange.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginPoolChange(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.PoolChangeRequest{
	NewPoolResourceID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginPopulateAvailabilityZone 

func (client *VolumesClient) BeginPopulateAvailabilityZone(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginPopulateAvailabilityZoneOptions) (*runtime.Poller[VolumesClientPopulateAvailabilityZoneResponse], error)

BeginPopulateAvailabilityZone - This operation will populate availability zone information for a volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginPopulateAvailabilityZoneOptions contains the optional parameters for the VolumesClient.BeginPopulateAvailabilityZone method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_PopulateAvailabilityZones.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginPopulateAvailabilityZone(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Volume = armnetapp.Volume{
// 	Name: to.Ptr("account1/pool1/volume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.VolumeProperties{
// 		CreationToken: to.Ptr("some-amazing-filepath"),
// 		FileSystemID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		NetworkFeatures: to.Ptr(armnetapp.NetworkFeaturesStandard),
// 		NetworkSiblingSetID: to.Ptr("0f434a03-ce0b-4935-81af-d98652ffb1c4"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		StorageToNetworkProximity: to.Ptr(armnetapp.VolumeStorageToNetworkProximityT2),
// 		SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 		ThroughputMibps: to.Ptr[float32](128),
// 		UsageThreshold: to.Ptr[int64](107374182400),
// 	},
// }

Output:

func (*VolumesClient) BeginReInitializeReplication 

func (client *VolumesClient) BeginReInitializeReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginReInitializeReplicationOptions) (*runtime.Poller[VolumesClientReInitializeReplicationResponse], error)

BeginReInitializeReplication - Re-Initializes the replication connection on the destination volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginReInitializeReplicationOptions contains the optional parameters for the VolumesClient.BeginReInitializeReplication method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_ReInitializeReplication.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginReInitializeReplication(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginReestablishReplication 

func (client *VolumesClient) BeginReestablishReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body ReestablishReplicationRequest, options *VolumesClientBeginReestablishReplicationOptions) (*runtime.Poller[VolumesClientReestablishReplicationResponse], error)

BeginReestablishReplication - Re-establish a previously deleted replication between 2 volumes that have a common ad-hoc or policy-based snapshots If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - body for the id of the source volume.
  • options - VolumesClientBeginReestablishReplicationOptions contains the optional parameters for the VolumesClient.BeginReestablishReplication method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_ReestablishReplication.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginReestablishReplication(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.ReestablishReplicationRequest{
	SourceVolumeID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/mySourceRG/providers/Microsoft.NetApp/netAppAccounts/sourceAccount1/capacityPools/sourcePool1/volumes/sourceVolume1"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginRelocate 

func (client *VolumesClient) BeginRelocate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginRelocateOptions) (*runtime.Poller[VolumesClientRelocateResponse], error)

BeginRelocate - Relocates volume to a new stamp If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginRelocateOptions contains the optional parameters for the VolumesClient.BeginRelocate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_Relocate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginRelocate(ctx, "myRG", "account1", "pool1", "volume1", &armnetapp.VolumesClientBeginRelocateOptions{Body: &armnetapp.RelocateVolumeRequest{}})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginResetCifsPassword 

func (client *VolumesClient) BeginResetCifsPassword(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginResetCifsPasswordOptions) (*runtime.Poller[VolumesClientResetCifsPasswordResponse], error)

BeginResetCifsPassword - Reset cifs password from volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginResetCifsPasswordOptions contains the optional parameters for the VolumesClient.BeginResetCifsPassword method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_ResetCifsPassword.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginResetCifsPassword(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginResyncReplication 

func (client *VolumesClient) BeginResyncReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginResyncReplicationOptions) (*runtime.Poller[VolumesClientResyncReplicationResponse], error)

BeginResyncReplication - Resync the connection on the destination volume. If the operation is ran on the source volume it will reverse-resync the connection and sync from destination to source. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginResyncReplicationOptions contains the optional parameters for the VolumesClient.BeginResyncReplication method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_ResyncReplication.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginResyncReplication(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginRevert 

func (client *VolumesClient) BeginRevert(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body VolumeRevert, options *VolumesClientBeginRevertOptions) (*runtime.Poller[VolumesClientRevertResponse], error)

BeginRevert - Revert a volume to the snapshot specified in the body If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - Object for snapshot to revert supplied in the body of the operation.
  • options - VolumesClientBeginRevertOptions contains the optional parameters for the VolumesClient.BeginRevert method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_Revert.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginRevert(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.VolumeRevert{
	SnapshotID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1/snapshots/snapshot1"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginRevertRelocation 

func (client *VolumesClient) BeginRevertRelocation(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientBeginRevertRelocationOptions) (*runtime.Poller[VolumesClientRevertRelocationResponse], error)

BeginRevertRelocation - Reverts the volume relocation process, cleans up the new volume and starts using the former-existing volume. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientBeginRevertRelocationOptions contains the optional parameters for the VolumesClient.BeginRevertRelocation method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_RevertRelocation.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginRevertRelocation(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*VolumesClient) BeginUpdate 

func (client *VolumesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body VolumePatch, options *VolumesClientBeginUpdateOptions) (*runtime.Poller[VolumesClientUpdateResponse], error)

BeginUpdate - Patch the specified volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • body - Volume object supplied in the body of the operation.
  • options - VolumesClientBeginUpdateOptions contains the optional parameters for the VolumesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVolumesClient().BeginUpdate(ctx, "myRG", "account1", "pool1", "volume1", armnetapp.VolumePatch{}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Volume = armnetapp.Volume{
// 	Name: to.Ptr("account1/pool1/volume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 	ID: to.Ptr("/subscriptions/subscriptionId/resourceGroups/resourceGroup/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.VolumeProperties{
// 		CreationToken: to.Ptr("some-amazing-filepath"),
// 		DataProtection: &armnetapp.VolumePropertiesDataProtection{
// 			Snapshot: &armnetapp.VolumeSnapshotProperties{
// 				SnapshotPolicyID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRP/providers/Microsoft.NetApp/netAppAccounts/account1/snapshotPolicies/snapshotPolicy1"),
// 			},
// 		},
// 		FileSystemID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		NetworkFeatures: to.Ptr(armnetapp.NetworkFeaturesStandard),
// 		NetworkSiblingSetID: to.Ptr("0f434a03-ce0b-4935-81af-d98652ffb1c4"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		StorageToNetworkProximity: to.Ptr(armnetapp.VolumeStorageToNetworkProximityT2),
// 		SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 		ThroughputMibps: to.Ptr[float32](128),
// 		UsageThreshold: to.Ptr[int64](107374182400),
// 	},
// }

Output:

func (*VolumesClient) Get 

func (client *VolumesClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientGetOptions) (VolumesClientGetResponse, error)

Get - Get the details of the specified volume If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientGetOptions contains the optional parameters for the VolumesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVolumesClient().Get(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.Volume = armnetapp.Volume{
// 	Name: to.Ptr("account1/pool1/volume1"),
// 	Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
// 	ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armnetapp.VolumeProperties{
// 		CreationToken: to.Ptr("some-amazing-filepath"),
// 		FileSystemID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
// 		NetworkFeatures: to.Ptr(armnetapp.NetworkFeaturesStandard),
// 		NetworkSiblingSetID: to.Ptr("0f434a03-ce0b-4935-81af-d98652ffb1c4"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
// 		StorageToNetworkProximity: to.Ptr(armnetapp.VolumeStorageToNetworkProximityT2),
// 		SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
// 		ThroughputMibps: to.Ptr[float32](128),
// 		UsageThreshold: to.Ptr[int64](107374182400),
// 	},
// }

Output:

func (*VolumesClient) NewListPager 

func (client *VolumesClient) NewListPager(resourceGroupName string, accountName string, poolName string, options *VolumesClientListOptions) *runtime.Pager[VolumesClientListResponse]

NewListPager - List all volumes within the capacity pool

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • options - VolumesClientListOptions contains the optional parameters for the VolumesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewVolumesClient().NewListPager("myRG", "account1", "pool1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.VolumeList = armnetapp.VolumeList{
	// 	Value: []*armnetapp.Volume{
	// 		{
	// 			Name: to.Ptr("account1/pool1/volume1"),
	// 			Type: to.Ptr("Microsoft.NetApp/netAppAccounts/capacityPools/volumes"),
	// 			ID: to.Ptr("/subscriptions/D633CC2E-722B-4AE1-B636-BBD9E4C60ED9/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account1/capacityPools/pool1/volumes/volume1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armnetapp.VolumeProperties{
	// 				CreationToken: to.Ptr("some-amazing-filepath"),
	// 				FileSystemID: to.Ptr("9760acf5-4638-11e7-9bdb-020073ca7778"),
	// 				NetworkFeatures: to.Ptr(armnetapp.NetworkFeaturesStandard),
	// 				NetworkSiblingSetID: to.Ptr("0f434a03-ce0b-4935-81af-d98652ffb1c4"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				ServiceLevel: to.Ptr(armnetapp.ServiceLevelPremium),
	// 				StorageToNetworkProximity: to.Ptr(armnetapp.VolumeStorageToNetworkProximityT2),
	// 				SubnetID: to.Ptr("/subscriptions/9760acf5-4638-11e7-9bdb-020073ca7778/resourceGroups/myRP/providers/Microsoft.Network/virtualNetworks/testvnet3/subnets/testsubnet3"),
	// 				ThroughputMibps: to.Ptr[float32](128),
	// 				UsageThreshold: to.Ptr[int64](107374182400),
	// 			},
	// 	}},
	// }
}

Output:

func (*VolumesClient) NewListReplicationsPager 

func (client *VolumesClient) NewListReplicationsPager(resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientListReplicationsOptions) *runtime.Pager[VolumesClientListReplicationsResponse]

NewListReplicationsPager - List all replications for a specified volume

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientListReplicationsOptions contains the optional parameters for the VolumesClient.NewListReplicationsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_ListReplications.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewVolumesClient().NewListReplicationsPager("myRG", "account1", "pool1", "volume1", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ListReplications = armnetapp.ListReplications{
	// 	Value: []*armnetapp.Replication{
	// 		{
	// 			RemoteVolumeRegion: to.Ptr("westus"),
	// 			RemoteVolumeResourceID: to.Ptr("/subscriptions/36e85c76-e720-473e-881f-e2fe72f462d0/resourceGroups/myRG/providers/Microsoft.NetApp/netAppAccounts/account-5999/capacityPools/pool-0977/volumes/volume-4508"),
	// 			ReplicationSchedule: to.Ptr(armnetapp.ReplicationScheduleDaily),
	// 	}},
	// }
}

Output:

func (*VolumesClient) ReplicationStatus 

func (client *VolumesClient) ReplicationStatus(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesClientReplicationStatusOptions) (VolumesClientReplicationStatusResponse, error)

ReplicationStatus - Get the status of the replication If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - The name of the NetApp account
  • poolName - The name of the capacity pool
  • volumeName - The name of the volume
  • options - VolumesClientReplicationStatusOptions contains the optional parameters for the VolumesClient.ReplicationStatus method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/netapp/resource-manager/Microsoft.NetApp/stable/2023-07-01/examples/Volumes_ReplicationStatus.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armnetapp.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVolumesClient().ReplicationStatus(ctx, "myRG", "account1", "pool1", "volume1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ReplicationStatus = armnetapp.ReplicationStatus{
// 	ErrorMessage: to.Ptr(""),
// 	Healthy: to.Ptr(true),
// 	MirrorState: to.Ptr(armnetapp.MirrorStateMirrored),
// 	RelationshipStatus: to.Ptr(armnetapp.RelationshipStatusIdle),
// 	TotalProgress: to.Ptr("1048576"),
// }

Output:

type VolumesClientAuthorizeReplicationResponse 

type VolumesClientAuthorizeReplicationResponse struct {
}

VolumesClientAuthorizeReplicationResponse contains the response from method VolumesClient.BeginAuthorizeReplication.

type VolumesClientBeginAuthorizeReplicationOptions 

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

VolumesClientBeginAuthorizeReplicationOptions contains the optional parameters for the VolumesClient.BeginAuthorizeReplication method.

type VolumesClientBeginBreakFileLocksOptions 

type VolumesClientBeginBreakFileLocksOptions struct {
	// Optional body to provide the ability to clear file locks with selected options
	Body *BreakFileLocksRequest

	// Resumes the LRO from the provided token.
	ResumeToken string
}

VolumesClientBeginBreakFileLocksOptions contains the optional parameters for the VolumesClient.BeginBreakFileLocks method.

type VolumesClientBeginBreakReplicationOptions 

type VolumesClientBeginBreakReplicationOptions struct {
	// Optional body to force break the replication.
	Body *BreakReplicationRequest

	// Resumes the LRO from the provided token.
	ResumeToken string
}

VolumesClientBeginBreakReplicationOptions contains the optional parameters for the VolumesClient.BeginBreakReplication method.

type VolumesClientBeginCreateOrUpdateOptions 

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

VolumesClientBeginCreateOrUpdateOptions contains the optional parameters for the VolumesClient.BeginCreateOrUpdate method.

type VolumesClientBeginDeleteOptions 

type VolumesClientBeginDeleteOptions struct {
	// An option to force delete the volume. Will cleanup resources connected to the particular volume
	ForceDelete *bool

	// Resumes the LRO from the provided token.
	ResumeToken string
}

VolumesClientBeginDeleteOptions contains the optional parameters for the VolumesClient.BeginDelete method.

type VolumesClientBeginDeleteReplicationOptions 

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

VolumesClientBeginDeleteReplicationOptions contains the optional parameters for the VolumesClient.BeginDeleteReplication method.

type VolumesClientBeginFinalizeRelocationOptions 

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

VolumesClientBeginFinalizeRelocationOptions contains the optional parameters for the VolumesClient.BeginFinalizeRelocation method.

type VolumesClientBeginListGetGroupIDListForLdapUserOptions 

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

VolumesClientBeginListGetGroupIDListForLdapUserOptions contains the optional parameters for the VolumesClient.BeginListGetGroupIDListForLdapUser method.

type VolumesClientBeginPoolChangeOptions 

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

VolumesClientBeginPoolChangeOptions contains the optional parameters for the VolumesClient.BeginPoolChange method.

type VolumesClientBeginPopulateAvailabilityZoneOptions 

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

VolumesClientBeginPopulateAvailabilityZoneOptions contains the optional parameters for the VolumesClient.BeginPopulateAvailabilityZone method.

type VolumesClientBeginReInitializeReplicationOptions 

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

VolumesClientBeginReInitializeReplicationOptions contains the optional parameters for the VolumesClient.BeginReInitializeReplication method.

type VolumesClientBeginReestablishReplicationOptions 

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

VolumesClientBeginReestablishReplicationOptions contains the optional parameters for the VolumesClient.BeginReestablishReplication method.

type VolumesClientBeginRelocateOptions 

type VolumesClientBeginRelocateOptions struct {
	// Relocate volume request
	Body *RelocateVolumeRequest

	// Resumes the LRO from the provided token.
	ResumeToken string
}

VolumesClientBeginRelocateOptions contains the optional parameters for the VolumesClient.BeginRelocate method.

type VolumesClientBeginResetCifsPasswordOptions 

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

VolumesClientBeginResetCifsPasswordOptions contains the optional parameters for the VolumesClient.BeginResetCifsPassword method.

type VolumesClientBeginResyncReplicationOptions 

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

VolumesClientBeginResyncReplicationOptions contains the optional parameters for the VolumesClient.BeginResyncReplication method.

type VolumesClientBeginRevertOptions 

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

VolumesClientBeginRevertOptions contains the optional parameters for the VolumesClient.BeginRevert method.

type VolumesClientBeginRevertRelocationOptions 

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

VolumesClientBeginRevertRelocationOptions contains the optional parameters for the VolumesClient.BeginRevertRelocation method.

type VolumesClientBeginUpdateOptions 

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

VolumesClientBeginUpdateOptions contains the optional parameters for the VolumesClient.BeginUpdate method.

type VolumesClientBreakFileLocksResponse 

type VolumesClientBreakFileLocksResponse struct {
}

VolumesClientBreakFileLocksResponse contains the response from method VolumesClient.BeginBreakFileLocks.

type VolumesClientBreakReplicationResponse 

type VolumesClientBreakReplicationResponse struct {
}

VolumesClientBreakReplicationResponse contains the response from method VolumesClient.BeginBreakReplication.

type VolumesClientCreateOrUpdateResponse 

type VolumesClientCreateOrUpdateResponse struct {
	// Volume resource
	Volume
}

VolumesClientCreateOrUpdateResponse contains the response from method VolumesClient.BeginCreateOrUpdate.

type VolumesClientDeleteReplicationResponse 

type VolumesClientDeleteReplicationResponse struct {
}

VolumesClientDeleteReplicationResponse contains the response from method VolumesClient.BeginDeleteReplication.

type VolumesClientDeleteResponse 

type VolumesClientDeleteResponse struct {
}

VolumesClientDeleteResponse contains the response from method VolumesClient.BeginDelete.

type VolumesClientFinalizeRelocationResponse 

type VolumesClientFinalizeRelocationResponse struct {
}

VolumesClientFinalizeRelocationResponse contains the response from method VolumesClient.BeginFinalizeRelocation.

type VolumesClientGetOptions 

type VolumesClientGetOptions struct {
}

VolumesClientGetOptions contains the optional parameters for the VolumesClient.Get method.

type VolumesClientGetResponse 

type VolumesClientGetResponse struct {
	// Volume resource
	Volume
}

VolumesClientGetResponse contains the response from method VolumesClient.Get.

type VolumesClientListGetGroupIDListForLdapUserResponse 

type VolumesClientListGetGroupIDListForLdapUserResponse struct {
	// Group Id list for Ldap user
	GetGroupIDListForLDAPUserResponse
}

VolumesClientListGetGroupIDListForLdapUserResponse contains the response from method VolumesClient.BeginListGetGroupIDListForLdapUser.

type VolumesClientListOptions 

type VolumesClientListOptions struct {
}

VolumesClientListOptions contains the optional parameters for the VolumesClient.NewListPager method.

type VolumesClientListReplicationsOptions 

type VolumesClientListReplicationsOptions struct {
}

VolumesClientListReplicationsOptions contains the optional parameters for the VolumesClient.NewListReplicationsPager method.

type VolumesClientListReplicationsResponse 

type VolumesClientListReplicationsResponse struct {
	// List Replications
	ListReplications
}

VolumesClientListReplicationsResponse contains the response from method VolumesClient.NewListReplicationsPager.

type VolumesClientListResponse 

type VolumesClientListResponse struct {
	// List of volume resources
	VolumeList
}

VolumesClientListResponse contains the response from method VolumesClient.NewListPager.

type VolumesClientPoolChangeResponse 

type VolumesClientPoolChangeResponse struct {
}

VolumesClientPoolChangeResponse contains the response from method VolumesClient.BeginPoolChange.

type VolumesClientPopulateAvailabilityZoneResponse 

type VolumesClientPopulateAvailabilityZoneResponse struct {
	// Volume resource
	Volume
}

VolumesClientPopulateAvailabilityZoneResponse contains the response from method VolumesClient.BeginPopulateAvailabilityZone.

type VolumesClientReInitializeReplicationResponse 

type VolumesClientReInitializeReplicationResponse struct {
}

VolumesClientReInitializeReplicationResponse contains the response from method VolumesClient.BeginReInitializeReplication.

type VolumesClientReestablishReplicationResponse 

type VolumesClientReestablishReplicationResponse struct {
}

VolumesClientReestablishReplicationResponse contains the response from method VolumesClient.BeginReestablishReplication.

type VolumesClientRelocateResponse 

type VolumesClientRelocateResponse struct {
}

VolumesClientRelocateResponse contains the response from method VolumesClient.BeginRelocate.

type VolumesClientReplicationStatusOptions 

type VolumesClientReplicationStatusOptions struct {
}

VolumesClientReplicationStatusOptions contains the optional parameters for the VolumesClient.ReplicationStatus method.

type VolumesClientReplicationStatusResponse 

type VolumesClientReplicationStatusResponse struct {
	// Replication status
	ReplicationStatus
}

VolumesClientReplicationStatusResponse contains the response from method VolumesClient.ReplicationStatus.

type VolumesClientResetCifsPasswordResponse 

type VolumesClientResetCifsPasswordResponse struct {
}

VolumesClientResetCifsPasswordResponse contains the response from method VolumesClient.BeginResetCifsPassword.

type VolumesClientResyncReplicationResponse 

type VolumesClientResyncReplicationResponse struct {
}

VolumesClientResyncReplicationResponse contains the response from method VolumesClient.BeginResyncReplication.

type VolumesClientRevertRelocationResponse 

type VolumesClientRevertRelocationResponse struct {
}

VolumesClientRevertRelocationResponse contains the response from method VolumesClient.BeginRevertRelocation.

type VolumesClientRevertResponse 

type VolumesClientRevertResponse struct {
}

VolumesClientRevertResponse contains the response from method VolumesClient.BeginRevert.

type VolumesClientUpdateResponse 

type VolumesClientUpdateResponse struct {
	// Volume resource
	Volume
}

VolumesClientUpdateResponse contains the response from method VolumesClient.BeginUpdate.

type WeeklySchedule 

type WeeklySchedule struct {
	// Indicates which weekdays snapshot should be taken, accepts a comma separated list of week day names in english
	Day *string

	// Indicates which hour in UTC timezone a snapshot should be taken
	Hour *int32

	// Indicates which minute snapshot should be taken
	Minute *int32

	// Weekly snapshot count to keep
	SnapshotsToKeep *int32

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64
}

WeeklySchedule - Weekly Schedule properties, make a snapshot every week at a specific day or days

func (WeeklySchedule) MarshalJSON 

func (w WeeklySchedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WeeklySchedule.

func (*WeeklySchedule) UnmarshalJSON 

func (w *WeeklySchedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WeeklySchedule.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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