armstorsimple8000series

package module
v0.0.0-...-45adee8 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2024 License: MIT Imports: 12 Imported by: 0

README

Azure Storsimple8000series Module for Go

The armstorsimple8000series module provides operations for working with Azure Storsimple8000series.

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 Storsimple8000series module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Storsimple8000series. 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 Storsimple8000series 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 := armstorsimple8000series.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 := armstorsimple8000series.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.NewBackupsClient()

Fakes

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

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

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Storsimple8000series 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 AccessControlRecord 

type AccessControlRecord struct {
	// REQUIRED; The properties of access control record.
	Properties *AccessControlRecordProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

AccessControlRecord - The access control record.

func (AccessControlRecord) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlRecord.

func (*AccessControlRecord) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlRecord.

type AccessControlRecordList 

type AccessControlRecordList struct {
	// REQUIRED; The value.
	Value []*AccessControlRecord
}

AccessControlRecordList - The collection of access control records.

func (AccessControlRecordList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlRecordList.

func (*AccessControlRecordList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlRecordList.

type AccessControlRecordProperties 

type AccessControlRecordProperties struct {
	// REQUIRED; The iSCSI initiator name (IQN).
	InitiatorName *string

	// READ-ONLY; The number of volumes using the access control record.
	VolumeCount *int32
}

AccessControlRecordProperties - The properties of access control record.

func (AccessControlRecordProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccessControlRecordProperties.

func (*AccessControlRecordProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessControlRecordProperties.

type AccessControlRecordsClient 

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

AccessControlRecordsClient contains the methods for the AccessControlRecords group. Don't use this type directly, use NewAccessControlRecordsClient() instead.

func NewAccessControlRecordsClient 

func NewAccessControlRecordsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AccessControlRecordsClient, error)

NewAccessControlRecordsClient creates a new instance of AccessControlRecordsClient with the specified values.

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

func (*AccessControlRecordsClient) BeginCreateOrUpdate 

func (client *AccessControlRecordsClient) BeginCreateOrUpdate(ctx context.Context, accessControlRecordName string, resourceGroupName string, managerName string, parameters AccessControlRecord, options *AccessControlRecordsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AccessControlRecordsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or Updates an access control record. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • accessControlRecordName - The name of the access control record.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The access control record to be added or updated.
  • options - AccessControlRecordsClientBeginCreateOrUpdateOptions contains the optional parameters for the AccessControlRecordsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AccessControlRecordsCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlRecordsClient().BeginCreateOrUpdate(ctx, "ACRForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.AccessControlRecord{
		Properties: &armstorsimple8000series.AccessControlRecordProperties{
			InitiatorName: to.Ptr("iqn.2017-06.com.contoso:ForTest"),
		},
	}, 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.AccessControlRecord = armstorsimple8000series.AccessControlRecord{
	// 	Name: to.Ptr("ACRForTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACRForTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.AccessControlRecordProperties{
	// 		InitiatorName: to.Ptr("iqn.2017-06.com.contoso:ForTest"),
	// 		VolumeCount: to.Ptr[int32](0),
	// 	},
	// }
}

Output:

func (*AccessControlRecordsClient) BeginDelete 

func (client *AccessControlRecordsClient) BeginDelete(ctx context.Context, accessControlRecordName string, resourceGroupName string, managerName string, options *AccessControlRecordsClientBeginDeleteOptions) (*runtime.Poller[AccessControlRecordsClientDeleteResponse], error)

BeginDelete - Deletes the access control record. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • accessControlRecordName - The name of the access control record to delete.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - AccessControlRecordsClientBeginDeleteOptions contains the optional parameters for the AccessControlRecordsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AccessControlRecordsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccessControlRecordsClient().BeginDelete(ctx, "ACRForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*AccessControlRecordsClient) Get 

func (client *AccessControlRecordsClient) Get(ctx context.Context, accessControlRecordName string, resourceGroupName string, managerName string, options *AccessControlRecordsClientGetOptions) (AccessControlRecordsClientGetResponse, error)

Get - Returns the properties of the specified access control record name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • accessControlRecordName - Name of access control record to be fetched.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - AccessControlRecordsClientGetOptions contains the optional parameters for the AccessControlRecordsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AccessControlRecordsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessControlRecordsClient().Get(ctx, "ACRForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.AccessControlRecord = armstorsimple8000series.AccessControlRecord{
	// 	Name: to.Ptr("ACRForTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACRForTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.AccessControlRecordProperties{
	// 		InitiatorName: to.Ptr("iqn.2017-06.com.contoso:ForTest"),
	// 		VolumeCount: to.Ptr[int32](0),
	// 	},
	// }
}

Output:

func (*AccessControlRecordsClient) NewListByManagerPager 

func (client *AccessControlRecordsClient) NewListByManagerPager(resourceGroupName string, managerName string, options *AccessControlRecordsClientListByManagerOptions) *runtime.Pager[AccessControlRecordsClientListByManagerResponse]

NewListByManagerPager - Retrieves all the access control records in a manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - AccessControlRecordsClientListByManagerOptions contains the optional parameters for the AccessControlRecordsClient.NewListByManagerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AccessControlRecordsListByManager.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccessControlRecordsClient().NewListByManagerPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.AccessControlRecordList = armstorsimple8000series.AccessControlRecordList{
		// 	Value: []*armstorsimple8000series.AccessControlRecord{
		// 		{
		// 			Name: to.Ptr("ACR2"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.AccessControlRecordProperties{
		// 				InitiatorName: to.Ptr("iqn.1991-05.com.microsoft:test1"),
		// 				VolumeCount: to.Ptr[int32](1),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ACR1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR1"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.AccessControlRecordProperties{
		// 				InitiatorName: to.Ptr("iqn.1991-05.com.microsoft:test2"),
		// 				VolumeCount: to.Ptr[int32](1),
		// 			},
		// 	}},
		// }
	}
}

Output:

type AccessControlRecordsClientBeginCreateOrUpdateOptions 

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

AccessControlRecordsClientBeginCreateOrUpdateOptions contains the optional parameters for the AccessControlRecordsClient.BeginCreateOrUpdate method.

type AccessControlRecordsClientBeginDeleteOptions 

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

AccessControlRecordsClientBeginDeleteOptions contains the optional parameters for the AccessControlRecordsClient.BeginDelete method.

type AccessControlRecordsClientCreateOrUpdateResponse 

type AccessControlRecordsClientCreateOrUpdateResponse struct {
	// The access control record.
	AccessControlRecord
}

AccessControlRecordsClientCreateOrUpdateResponse contains the response from method AccessControlRecordsClient.BeginCreateOrUpdate.

type AccessControlRecordsClientDeleteResponse 

type AccessControlRecordsClientDeleteResponse struct {
}

AccessControlRecordsClientDeleteResponse contains the response from method AccessControlRecordsClient.BeginDelete.

type AccessControlRecordsClientGetOptions 

type AccessControlRecordsClientGetOptions struct {
}

AccessControlRecordsClientGetOptions contains the optional parameters for the AccessControlRecordsClient.Get method.

type AccessControlRecordsClientGetResponse 

type AccessControlRecordsClientGetResponse struct {
	// The access control record.
	AccessControlRecord
}

AccessControlRecordsClientGetResponse contains the response from method AccessControlRecordsClient.Get.

type AccessControlRecordsClientListByManagerOptions 

type AccessControlRecordsClientListByManagerOptions struct {
}

AccessControlRecordsClientListByManagerOptions contains the optional parameters for the AccessControlRecordsClient.NewListByManagerPager method.

type AccessControlRecordsClientListByManagerResponse 

type AccessControlRecordsClientListByManagerResponse struct {
	// The collection of access control records.
	AccessControlRecordList
}

AccessControlRecordsClientListByManagerResponse contains the response from method AccessControlRecordsClient.NewListByManagerPager.

type AcsConfiguration 

type AcsConfiguration struct {
	// REQUIRED; The namespace.
	Namespace *string

	// REQUIRED; The realm.
	Realm *string

	// REQUIRED; The service URL.
	ServiceURL *string
}

AcsConfiguration - The ACS configuration.

func (AcsConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AcsConfiguration.

func (*AcsConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AcsConfiguration.

type Alert 

type Alert struct {
	// REQUIRED; The properties of the alert.
	Properties *AlertProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

Alert - The alert.

func (Alert) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Alert.

func (*Alert) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Alert.

type AlertEmailNotificationStatus 

type AlertEmailNotificationStatus string

AlertEmailNotificationStatus - Indicates whether email notification enabled or not. 

const (
	AlertEmailNotificationStatusDisabled AlertEmailNotificationStatus = "Disabled"
	AlertEmailNotificationStatusEnabled  AlertEmailNotificationStatus = "Enabled"
)

func PossibleAlertEmailNotificationStatusValues 

func PossibleAlertEmailNotificationStatusValues() []AlertEmailNotificationStatus

PossibleAlertEmailNotificationStatusValues returns the possible values for the AlertEmailNotificationStatus const type.

type AlertErrorDetails 

type AlertErrorDetails struct {
	// The error code
	ErrorCode *string

	// The error message
	ErrorMessage *string

	// The number of occurrences
	Occurences *int32
}

AlertErrorDetails - The details of the error for which the alert was raised

func (AlertErrorDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertErrorDetails.

func (*AlertErrorDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertErrorDetails.

type AlertFilter 

type AlertFilter struct {
	// Specifies the appeared time (in UTC) of the alerts to be filtered. Only 'Greater-Than' and 'Lesser-Than' operators are
	// supported for this property.
	AppearedOnTime *time.Time

	// Specifies the severity of the alerts to be filtered. Only 'Equality' operator is supported for this property.
	Severity *AlertSeverity

	// Specifies the source name of the alerts to be filtered. Only 'Equality' operator is supported for this property.
	SourceName *string

	// Specifies the source type of the alerts to be filtered. Only 'Equality' operator is supported for this property.
	SourceType *AlertSourceType

	// Specifies the status of the alerts to be filtered. Only 'Equality' operator is supported for this property.
	Status *AlertStatus
}

AlertFilter - The OData filters to be used for Alert

func (AlertFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertFilter.

func (*AlertFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertFilter.

type AlertList 

type AlertList struct {
	// REQUIRED; The value.
	Value []*Alert

	// The URI of the next page of alerts.
	NextLink *string
}

AlertList - The collection of alerts.

func (AlertList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertList.

func (*AlertList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertList.

type AlertNotificationProperties 

type AlertNotificationProperties struct {
	// REQUIRED; Indicates whether email notification enabled or not.
	EmailNotification *AlertEmailNotificationStatus

	// The alert notification email list.
	AdditionalRecipientEmailList []*string

	// The alert notification culture.
	AlertNotificationCulture *string

	// The value indicating whether alert notification enabled for admin or not.
	NotificationToServiceOwners *AlertEmailNotificationStatus
}

AlertNotificationProperties - The properties of the alert notification settings.

func (AlertNotificationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertNotificationProperties.

func (*AlertNotificationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertNotificationProperties.

type AlertProperties 

type AlertProperties struct {
	// REQUIRED; The type of the alert
	AlertType *string

	// REQUIRED; The source time at which the alert was raised
	AppearedAtSourceTime *time.Time

	// REQUIRED; The UTC time at which the alert was raised
	AppearedAtTime *time.Time

	// REQUIRED; The scope of the alert
	Scope *AlertScope

	// REQUIRED; The severity of the alert
	Severity *AlertSeverity

	// REQUIRED; The source at which the alert was raised
	Source *AlertSource

	// REQUIRED; The current status of the alert
	Status *AlertStatus

	// REQUIRED; The title of the alert
	Title *string

	// The source time at which the alert was cleared
	ClearedAtSourceTime *time.Time

	// The UTC time at which the alert was cleared
	ClearedAtTime *time.Time

	// More details about the alert
	DetailedInformation map[string]*string

	// The details of the error for which the alert was raised
	ErrorDetails *AlertErrorDetails

	// The recommended action for the issue raised in the alert
	Recommendation *string

	// The reason for resolving the alert
	ResolutionReason *string
}

AlertProperties - The properties of alert

func (AlertProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertProperties.

func (*AlertProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertProperties.

type AlertScope 

type AlertScope string

AlertScope - The scope of the alert 

const (
	AlertScopeDevice   AlertScope = "Device"
	AlertScopeResource AlertScope = "Resource"
)

func PossibleAlertScopeValues 

func PossibleAlertScopeValues() []AlertScope

PossibleAlertScopeValues returns the possible values for the AlertScope const type.

type AlertSettings 

type AlertSettings struct {
	// REQUIRED; The properties of the alert notification settings.
	Properties *AlertNotificationProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

AlertSettings - The alert settings.

func (AlertSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertSettings.

func (*AlertSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertSettings.

type AlertSeverity 

type AlertSeverity string

AlertSeverity - Specifies the severity of the alerts to be filtered. Only 'Equality' operator is supported for this property. 

const (
	AlertSeverityCritical      AlertSeverity = "Critical"
	AlertSeverityInformational AlertSeverity = "Informational"
	AlertSeverityWarning       AlertSeverity = "Warning"
)

func PossibleAlertSeverityValues 

func PossibleAlertSeverityValues() []AlertSeverity

PossibleAlertSeverityValues returns the possible values for the AlertSeverity const type.

type AlertSource 

type AlertSource struct {
	// The source type of the alert
	AlertSourceType *AlertSourceType

	// The name of the source
	Name *string

	// The time zone of the source
	TimeZone *string
}

AlertSource - The source details at which the alert was raised

func (AlertSource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlertSource.

func (*AlertSource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlertSource.

type AlertSourceType 

type AlertSourceType string

AlertSourceType - Specifies the source type of the alerts to be filtered. Only 'Equality' operator is supported for this property. 

const (
	AlertSourceTypeDevice   AlertSourceType = "Device"
	AlertSourceTypeResource AlertSourceType = "Resource"
)

func PossibleAlertSourceTypeValues 

func PossibleAlertSourceTypeValues() []AlertSourceType

PossibleAlertSourceTypeValues returns the possible values for the AlertSourceType const type.

type AlertStatus 

type AlertStatus string

AlertStatus - Specifies the status of the alerts to be filtered. Only 'Equality' operator is supported for this property. 

const (
	AlertStatusActive  AlertStatus = "Active"
	AlertStatusCleared AlertStatus = "Cleared"
)

func PossibleAlertStatusValues 

func PossibleAlertStatusValues() []AlertStatus

PossibleAlertStatusValues returns the possible values for the AlertStatus const type.

type AlertsClient 

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

AlertsClient contains the methods for the Alerts group. Don't use this type directly, use NewAlertsClient() instead.

func NewAlertsClient 

func NewAlertsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AlertsClient, error)

NewAlertsClient creates a new instance of AlertsClient with the specified values.

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

func (*AlertsClient) Clear 

func (client *AlertsClient) Clear(ctx context.Context, resourceGroupName string, managerName string, parameters ClearAlertRequest, options *AlertsClientClearOptions) (AlertsClientClearResponse, error)

Clear - Clear the alerts. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The clear alert request.
  • options - AlertsClientClearOptions contains the optional parameters for the AlertsClient.Clear method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AlertsClear.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewAlertsClient().Clear(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.ClearAlertRequest{
		Alerts: []*string{
			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/alerts/308b5bd2-824b-436f-840e-44bde075ef33")},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*AlertsClient) NewListByManagerPager 

func (client *AlertsClient) NewListByManagerPager(resourceGroupName string, managerName string, options *AlertsClientListByManagerOptions) *runtime.Pager[AlertsClientListByManagerResponse]

NewListByManagerPager - Retrieves all the alerts in a manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - AlertsClientListByManagerOptions contains the optional parameters for the AlertsClient.NewListByManagerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AlertsListByManager.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAlertsClient().NewListByManagerPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.AlertsClientListByManagerOptions{Filter: to.Ptr("status%20eq%20'Active'%20and%20appearedOnTime%20ge%20'2017-06-09T18:30:00Z'%20and%20appearedOnTime%20le%20'2017-06-19T18:30:00Z'%20and%20sourceType%20eq%20'Device'%20and%20sourceName%20eq%20'Device05ForSDKTest'")})
	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.AlertList = armstorsimple8000series.AlertList{
		// 	Value: []*armstorsimple8000series.Alert{
		// 		{
		// 			Name: to.Ptr("308b5bd2-824b-436f-840e-44bde075ef33"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/alerts"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/alerts/308b5bd2-824b-436f-840e-44bde075ef33"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.AlertProperties{
		// 				AlertType: to.Ptr("Security"),
		// 				AppearedAtSourceTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-14T11:35:41.226Z"); return t}()),
		// 				AppearedAtTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-14T11:35:41.226Z"); return t}()),
		// 				ClearedAtSourceTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				ClearedAtTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				DetailedInformation: map[string]*string{
		// 				},
		// 				ErrorDetails: &armstorsimple8000series.AlertErrorDetails{
		// 					Occurences: to.Ptr[int32](1),
		// 				},
		// 				Recommendation: to.Ptr("Your device might be under attack or an authorized user is attempting to connect with an incorrect password. Check that your SnapShot manager instances are configured with the correct password. Once you have taken appropriate action, please clear this alert from the alerts page."),
		// 				Scope: to.Ptr(armstorsimple8000series.AlertScopeDevice),
		// 				Severity: to.Ptr(armstorsimple8000series.AlertSeverityWarning),
		// 				Source: &armstorsimple8000series.AlertSource{
		// 					Name: to.Ptr("Device05ForSDKTest"),
		// 					AlertSourceType: to.Ptr(armstorsimple8000series.AlertSourceTypeDevice),
		// 					TimeZone: to.Ptr("Pacific Standard Time"),
		// 				},
		// 				Status: to.Ptr(armstorsimple8000series.AlertStatusActive),
		// 				Title: to.Ptr("4 login attempts failed for SnapShotManager"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("3c3df90a-cbbc-4cc4-bd63-b54ca05997da"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/alerts"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/alerts/3c3df90a-cbbc-4cc4-bd63-b54ca05997da"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.AlertProperties{
		// 				AlertType: to.Ptr("Cloud Connectivity"),
		// 				AppearedAtSourceTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-14T11:30:43.656Z"); return t}()),
		// 				AppearedAtTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-14T11:30:43.656Z"); return t}()),
		// 				ClearedAtSourceTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				ClearedAtTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				DetailedInformation: map[string]*string{
		// 					"httP code": to.Ptr("400"),
		// 					"rpC code": to.Ptr("109"),
		// 					"status code": to.Ptr("12"),
		// 				},
		// 				ErrorDetails: &armstorsimple8000series.AlertErrorDetails{
		// 					Occurences: to.Ptr[int32](1),
		// 				},
		// 				Recommendation: to.Ptr("Check your network settings."),
		// 				Scope: to.Ptr(armstorsimple8000series.AlertScopeDevice),
		// 				Severity: to.Ptr(armstorsimple8000series.AlertSeverityWarning),
		// 				Source: &armstorsimple8000series.AlertSource{
		// 					Name: to.Ptr("Device05ForSDKTest"),
		// 					AlertSourceType: to.Ptr(armstorsimple8000series.AlertSourceTypeDevice),
		// 					TimeZone: to.Ptr("Pacific Standard Time"),
		// 				},
		// 				Status: to.Ptr(armstorsimple8000series.AlertStatusActive),
		// 				Title: to.Ptr("Connectivity to Cloud1 cannot be established"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AlertsClient) SendTestEmail 

func (client *AlertsClient) SendTestEmail(ctx context.Context, deviceName string, resourceGroupName string, managerName string, parameters SendTestAlertEmailRequest, options *AlertsClientSendTestEmailOptions) (AlertsClientSendTestEmailResponse, error)

SendTestEmail - Sends a test alert email. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The send test alert email request.
  • options - AlertsClientSendTestEmailOptions contains the optional parameters for the AlertsClient.SendTestEmail method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/AlertsSendTestEmail.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewAlertsClient().SendTestEmail(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.SendTestAlertEmailRequest{
		EmailList: []*string{
			to.Ptr("testemailid@contoso.com")},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

type AlertsClientClearOptions 

type AlertsClientClearOptions struct {
}

AlertsClientClearOptions contains the optional parameters for the AlertsClient.Clear method.

type AlertsClientClearResponse 

type AlertsClientClearResponse struct {
}

AlertsClientClearResponse contains the response from method AlertsClient.Clear.

type AlertsClientListByManagerOptions 

type AlertsClientListByManagerOptions struct {
	// OData Filter options
	Filter *string
}

AlertsClientListByManagerOptions contains the optional parameters for the AlertsClient.NewListByManagerPager method.

type AlertsClientListByManagerResponse 

type AlertsClientListByManagerResponse struct {
	// The collection of alerts.
	AlertList
}

AlertsClientListByManagerResponse contains the response from method AlertsClient.NewListByManagerPager.

type AlertsClientSendTestEmailOptions 

type AlertsClientSendTestEmailOptions struct {
}

AlertsClientSendTestEmailOptions contains the optional parameters for the AlertsClient.SendTestEmail method.

type AlertsClientSendTestEmailResponse 

type AlertsClientSendTestEmailResponse struct {
}

AlertsClientSendTestEmailResponse contains the response from method AlertsClient.SendTestEmail.

type AsymmetricEncryptedSecret 

type AsymmetricEncryptedSecret struct {
	// REQUIRED; The algorithm used to encrypt "Value".
	EncryptionAlgorithm *EncryptionAlgorithm

	// REQUIRED; The value of the secret.
	Value *string

	// Thumbprint certificate that was used to encrypt "Value". If the value in unencrypted, it will be null.
	EncryptionCertThumbprint *string
}

AsymmetricEncryptedSecret - Represent the secrets intended for encryption with asymmetric key pair.

func (AsymmetricEncryptedSecret) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AsymmetricEncryptedSecret.

func (*AsymmetricEncryptedSecret) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AsymmetricEncryptedSecret.

type AuthenticationType 

type AuthenticationType string

AuthenticationType - The authentication type. 

const (
	AuthenticationTypeBasic   AuthenticationType = "Basic"
	AuthenticationTypeInvalid AuthenticationType = "Invalid"
	AuthenticationTypeNTLM    AuthenticationType = "NTLM"
	AuthenticationTypeNone    AuthenticationType = "None"
)

func PossibleAuthenticationTypeValues 

func PossibleAuthenticationTypeValues() []AuthenticationType

PossibleAuthenticationTypeValues returns the possible values for the AuthenticationType const type.

type AuthorizationEligibility 

type AuthorizationEligibility string

AuthorizationEligibility - The eligibility status of device for service data encryption key rollover. 

const (
	AuthorizationEligibilityEligible   AuthorizationEligibility = "Eligible"
	AuthorizationEligibilityInEligible AuthorizationEligibility = "InEligible"
)

func PossibleAuthorizationEligibilityValues 

func PossibleAuthorizationEligibilityValues() []AuthorizationEligibility

PossibleAuthorizationEligibilityValues returns the possible values for the AuthorizationEligibility const type.

type AuthorizationStatus 

type AuthorizationStatus string

AuthorizationStatus - The authorization status of the device for service data encryption key rollover. 

const (
	AuthorizationStatusDisabled AuthorizationStatus = "Disabled"
	AuthorizationStatusEnabled  AuthorizationStatus = "Enabled"
)

func PossibleAuthorizationStatusValues 

func PossibleAuthorizationStatusValues() []AuthorizationStatus

PossibleAuthorizationStatusValues returns the possible values for the AuthorizationStatus const type.

type AvailableProviderOperation 

type AvailableProviderOperation struct {
	// Contains the localized display information for this particular operation/action.
	Display *AvailableProviderOperationDisplay

	// The name of the operation being performed on a particular object. Name format: "{resourceProviderNamespace}/{resourceType}/{read|write|delete|action}".
	// Eg.
	// Microsoft.StorSimple/managers/devices/volumeContainers/read, Microsoft.StorSimple/managers/devices/alerts/clearAlerts/action
	Name *string

	// The intended executor of the operation; governs the display of the operation in the RBAC UX and the audit logs UX. Default
	// value is "user,system"
	Origin *string

	// Reserved for future use.
	Properties any
}

AvailableProviderOperation - Represents available provider operation.

func (AvailableProviderOperation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvailableProviderOperation.

func (*AvailableProviderOperation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProviderOperation.

type AvailableProviderOperationDisplay 

type AvailableProviderOperationDisplay struct {
	// The localized friendly description for the operation, as it should be shown to the user. It should be thorough, yet concise
	// - it will be used in tool tips and detailed views.
	Description *string

	// The localized friendly name for the operation, as it should be shown to the user. It should be concise (to fit in drop
	// downs) but clear (i.e. self-documenting). It should use Title Casing and include
	// the entity/resource to which it applies.
	Operation *string

	// The localized friendly form of the resource provider name - it is expected to also include the publisher/company responsible.
	// It should use Title Casing and begin with 'Microsoft' for 1st party
	// services.
	Provider *string

	// The localized friendly form of the resource type related to this action/operation - it should match the public documentation
	// for the resource provider. It should use Title Casing - for examples,
	// please refer to the 'name' section.
	Resource *string
}

AvailableProviderOperationDisplay - Contains the localized display information for this particular operation/action. These value will be used by several clients for (a) custom role definitions for RBAC, (b) complex query filters for the event service and (c) audit history/records for management operations.

func (AvailableProviderOperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvailableProviderOperationDisplay.

func (*AvailableProviderOperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProviderOperationDisplay.

type AvailableProviderOperationList 

type AvailableProviderOperationList struct {
	// REQUIRED; The value.
	Value []*AvailableProviderOperation

	// The NextLink.
	NextLink *string
}

AvailableProviderOperationList - List of available provider operations.

func (AvailableProviderOperationList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvailableProviderOperationList.

func (*AvailableProviderOperationList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableProviderOperationList.

type Backup 

type Backup struct {
	// REQUIRED; The properties of the backup.
	Properties *BackupProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

Backup - The backup.

func (Backup) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Backup.

func (*Backup) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Backup.

type BackupElement 

type BackupElement struct {
	// REQUIRED; The path ID that uniquely identifies the backup element.
	ElementID *string

	// REQUIRED; The name of the backup element.
	ElementName *string

	// REQUIRED; The hierarchical type of the backup element.
	ElementType *string

	// REQUIRED; The size in bytes.
	SizeInBytes *int64

	// REQUIRED; The path ID of the volume container.
	VolumeContainerID *string

	// REQUIRED; The name of the volume.
	VolumeName *string

	// The volume type.
	VolumeType *VolumeType
}

BackupElement - The backup element.

func (BackupElement) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupElement.

func (*BackupElement) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupElement.

type BackupFilter 

type BackupFilter struct {
	// Specifies the backupPolicyId of the backups to be filtered. Only 'Equality' operator is supported for this property.
	BackupPolicyID *string

	// Specifies the creation time of the backups to be filtered. Only 'Greater Than or Equal To' and 'Lesser Than or Equal To'
	// operators are supported for this property.
	CreatedTime *time.Time

	// Specifies the volumeId of the backups to be filtered. Only 'Equality' operator is supported for this property.
	VolumeID *string
}

BackupFilter - The OData filters to be used for backups.

func (BackupFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupFilter.

func (*BackupFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupFilter.

type BackupJobCreationType 

type BackupJobCreationType string

BackupJobCreationType - The backup job creation type. 

const (
	BackupJobCreationTypeAdhoc      BackupJobCreationType = "Adhoc"
	BackupJobCreationTypeBySSM      BackupJobCreationType = "BySSM"
	BackupJobCreationTypeBySchedule BackupJobCreationType = "BySchedule"
)

func PossibleBackupJobCreationTypeValues 

func PossibleBackupJobCreationTypeValues() []BackupJobCreationType

PossibleBackupJobCreationTypeValues returns the possible values for the BackupJobCreationType const type.

type BackupList 

type BackupList struct {
	// REQUIRED; The value.
	Value []*Backup

	// The NextLink.
	NextLink *string
}

BackupList - The collection of backups.

func (BackupList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupList.

func (*BackupList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupList.

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 subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BackupPoliciesClient) BeginBackupNow 

func (client *BackupPoliciesClient) BeginBackupNow(ctx context.Context, deviceName string, backupPolicyName string, backupType string, resourceGroupName string, managerName string, options *BackupPoliciesClientBeginBackupNowOptions) (*runtime.Poller[BackupPoliciesClientBackupNowResponse], error)

BeginBackupNow - Backup the backup policy now. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The backup policy name.
  • backupType - The backup Type. This can be cloudSnapshot or localSnapshot.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupPoliciesClientBeginBackupNowOptions contains the optional parameters for the BackupPoliciesClient.BeginBackupNow method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupPoliciesBackupNow.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupPoliciesClient().BeginBackupNow(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "CloudSnapshot", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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) BeginCreateOrUpdate 

func (client *BackupPoliciesClient) BeginCreateOrUpdate(ctx context.Context, deviceName string, backupPolicyName string, resourceGroupName string, managerName string, parameters BackupPolicy, options *BackupPoliciesClientBeginCreateOrUpdateOptions) (*runtime.Poller[BackupPoliciesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the backup policy. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The name of the backup policy to be created/updated.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The backup policy.
  • options - BackupPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the BackupPoliciesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupPoliciesCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupPoliciesClient().BeginCreateOrUpdate(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.BackupPolicy{
		Kind: to.Ptr("Series8000"),
		Properties: &armstorsimple8000series.BackupPolicyProperties{
			VolumeIDs: []*string{
				to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/Clonedvolume1"),
				to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/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.BackupPolicy = armstorsimple8000series.BackupPolicy{
	// 	Name: to.Ptr("BkUpPolicy01ForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.BackupPolicyProperties{
	// 		BackupPolicyCreationType: to.Ptr(armstorsimple8000series.BackupPolicyCreationTypeBySaaS),
	// 		ScheduledBackupStatus: to.Ptr(armstorsimple8000series.ScheduledBackupStatusDisabled),
	// 		SchedulesCount: to.Ptr[int64](0),
	// 		VolumeIDs: []*string{
	// 			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/Clonedvolume1"),
	// 			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume1")},
	// 		},
	// 	}
}

Output:

func (*BackupPoliciesClient) BeginDelete 

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

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

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The name of the backup policy.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • 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/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupPoliciesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupPoliciesClient().BeginDelete(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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) Get 

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

Get - Gets the properties of the specified backup policy name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The name of backup policy to be fetched.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • 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/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupPoliciesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBackupPoliciesClient().Get(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 = armstorsimple8000series.BackupPolicy{
	// 	Name: to.Ptr("BkUpPolicy01ForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.BackupPolicyProperties{
	// 		BackupPolicyCreationType: to.Ptr(armstorsimple8000series.BackupPolicyCreationTypeBySaaS),
	// 		ScheduledBackupStatus: to.Ptr(armstorsimple8000series.ScheduledBackupStatusDisabled),
	// 		SchedulesCount: to.Ptr[int64](0),
	// 		VolumeIDs: []*string{
	// 			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/Clonedvolume1"),
	// 			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume1")},
	// 		},
	// 	}
}

Output:

func (*BackupPoliciesClient) NewListByDevicePager 

func (client *BackupPoliciesClient) NewListByDevicePager(deviceName string, resourceGroupName string, managerName string, options *BackupPoliciesClientListByDeviceOptions) *runtime.Pager[BackupPoliciesClientListByDeviceResponse]

NewListByDevicePager - Gets all the backup policies in a device.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupPoliciesClientListByDeviceOptions contains the optional parameters for the BackupPoliciesClient.NewListByDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupPoliciesListByDevice.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBackupPoliciesClient().NewListByDevicePager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.BackupPolicyList = armstorsimple8000series.BackupPolicyList{
		// 	Value: []*armstorsimple8000series.BackupPolicy{
		// 		{
		// 			Name: to.Ptr("BkUpPolicy01ForSDKTest"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.BackupPolicyProperties{
		// 				BackupPolicyCreationType: to.Ptr(armstorsimple8000series.BackupPolicyCreationTypeBySaaS),
		// 				LastBackupTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T22:01:19.708Z"); return t}()),
		// 				NextBackupTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-24T00:00:00.000Z"); return t}()),
		// 				ScheduledBackupStatus: to.Ptr(armstorsimple8000series.ScheduledBackupStatusEnabled),
		// 				SchedulesCount: to.Ptr[int64](2),
		// 				VolumeIDs: []*string{
		// 					to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/Clonedvolume1"),
		// 					to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume1")},
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("BkUpPolicyForSDKTest1032280949"),
		// 				Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
		// 				ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest1032280949"),
		// 				Kind: to.Ptr("Series8000"),
		// 				Properties: &armstorsimple8000series.BackupPolicyProperties{
		// 					BackupPolicyCreationType: to.Ptr(armstorsimple8000series.BackupPolicyCreationTypeBySaaS),
		// 					LastBackupTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T21:22:01.372Z"); return t}()),
		// 					ScheduledBackupStatus: to.Ptr(armstorsimple8000series.ScheduledBackupStatusDisabled),
		// 					SchedulesCount: to.Ptr[int64](0),
		// 					VolumeIDs: []*string{
		// 						to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume2"),
		// 						to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume1")},
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type BackupPoliciesClientBackupNowResponse 

type BackupPoliciesClientBackupNowResponse struct {
}

BackupPoliciesClientBackupNowResponse contains the response from method BackupPoliciesClient.BeginBackupNow.

type BackupPoliciesClientBeginBackupNowOptions 

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

BackupPoliciesClientBeginBackupNowOptions contains the optional parameters for the BackupPoliciesClient.BeginBackupNow method.

type BackupPoliciesClientBeginCreateOrUpdateOptions 

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

BackupPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the BackupPoliciesClient.BeginCreateOrUpdate 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 BackupPoliciesClientCreateOrUpdateResponse 

type BackupPoliciesClientCreateOrUpdateResponse struct {
	// The backup policy.
	BackupPolicy
}

BackupPoliciesClientCreateOrUpdateResponse contains the response from method BackupPoliciesClient.BeginCreateOrUpdate.

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 {
	// The backup policy.
	BackupPolicy
}

BackupPoliciesClientGetResponse contains the response from method BackupPoliciesClient.Get.

type BackupPoliciesClientListByDeviceOptions 

type BackupPoliciesClientListByDeviceOptions struct {
}

BackupPoliciesClientListByDeviceOptions contains the optional parameters for the BackupPoliciesClient.NewListByDevicePager method.

type BackupPoliciesClientListByDeviceResponse 

type BackupPoliciesClientListByDeviceResponse struct {
	// The collection of backup policies.
	BackupPolicyList
}

BackupPoliciesClientListByDeviceResponse contains the response from method BackupPoliciesClient.NewListByDevicePager.

type BackupPolicy 

type BackupPolicy struct {
	// REQUIRED; The properties of the backup policy.
	Properties *BackupPolicyProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

BackupPolicy - The backup policy.

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 BackupPolicyCreationType 

type BackupPolicyCreationType string

BackupPolicyCreationType - The backup policy creation type. Indicates whether this was created through SaaS or through StorSimple Snapshot Manager. 

const (
	BackupPolicyCreationTypeBySSM  BackupPolicyCreationType = "BySSM"
	BackupPolicyCreationTypeBySaaS BackupPolicyCreationType = "BySaaS"
)

func PossibleBackupPolicyCreationTypeValues 

func PossibleBackupPolicyCreationTypeValues() []BackupPolicyCreationType

PossibleBackupPolicyCreationTypeValues returns the possible values for the BackupPolicyCreationType const type.

type BackupPolicyList 

type BackupPolicyList struct {
	// REQUIRED; The value.
	Value []*BackupPolicy
}

BackupPolicyList - The collection of backup policies.

func (BackupPolicyList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicyList.

func (*BackupPolicyList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupPolicyList.

type BackupPolicyProperties 

type BackupPolicyProperties struct {
	// REQUIRED; The path IDs of the volumes which are part of the backup policy.
	VolumeIDs []*string

	// READ-ONLY; The backup policy creation type. Indicates whether this was created through SaaS or through StorSimple Snapshot
	// Manager.
	BackupPolicyCreationType *BackupPolicyCreationType

	// READ-ONLY; The time of the last backup for the backup policy.
	LastBackupTime *time.Time

	// READ-ONLY; The time of the next backup for the backup policy.
	NextBackupTime *time.Time

	// READ-ONLY; Indicates whether at least one of the schedules in the backup policy is active or not.
	ScheduledBackupStatus *ScheduledBackupStatus

	// READ-ONLY; The count of schedules the backup policy contains.
	SchedulesCount *int64

	// READ-ONLY; If the backup policy was created by StorSimple Snapshot Manager, then this field indicates the hostname of the
	// StorSimple Snapshot Manager.
	SsmHostName *string
}

BackupPolicyProperties - The properties of the backup policy.

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 BackupProperties 

type BackupProperties struct {
	// REQUIRED; The time when the backup was created.
	CreatedOn *time.Time

	// REQUIRED; The backup elements.
	Elements []*BackupElement

	// REQUIRED; The backup size in bytes.
	SizeInBytes *int64

	// The backup job creation type.
	BackupJobCreationType *BackupJobCreationType

	// The path ID of the backup policy.
	BackupPolicyID *string

	// The type of the backup.
	BackupType *BackupType

	// The StorSimple Snapshot Manager host name.
	SsmHostName *string
}

BackupProperties - The properties of the backup.

func (BackupProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupProperties.

func (*BackupProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupProperties.

type BackupSchedule 

type BackupSchedule struct {
	// REQUIRED; The properties of the backup schedule.
	Properties *BackupScheduleProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

BackupSchedule - The backup schedule.

func (BackupSchedule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupSchedule.

func (*BackupSchedule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupSchedule.

type BackupScheduleList 

type BackupScheduleList struct {
	// REQUIRED; The value.
	Value []*BackupSchedule
}

BackupScheduleList - The backup schedule list.

func (BackupScheduleList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupScheduleList.

func (*BackupScheduleList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupScheduleList.

type BackupScheduleProperties 

type BackupScheduleProperties struct {
	// REQUIRED; The type of backup which needs to be taken.
	BackupType *BackupType

	// REQUIRED; The number of backups to be retained.
	RetentionCount *int64

	// REQUIRED; The schedule recurrence.
	ScheduleRecurrence *ScheduleRecurrence

	// REQUIRED; The schedule status.
	ScheduleStatus *ScheduleStatus

	// REQUIRED; The start time of the schedule.
	StartTime *time.Time

	// READ-ONLY; The last successful backup run which was triggered for the schedule.
	LastSuccessfulRun *time.Time
}

BackupScheduleProperties - The properties of the backup schedule.

func (BackupScheduleProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupScheduleProperties.

func (*BackupScheduleProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupScheduleProperties.

type BackupSchedulesClient 

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

BackupSchedulesClient contains the methods for the BackupSchedules group. Don't use this type directly, use NewBackupSchedulesClient() instead.

func NewBackupSchedulesClient 

func NewBackupSchedulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BackupSchedulesClient, error)

NewBackupSchedulesClient creates a new instance of BackupSchedulesClient with the specified values.

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

func (*BackupSchedulesClient) BeginCreateOrUpdate 

func (client *BackupSchedulesClient) BeginCreateOrUpdate(ctx context.Context, deviceName string, backupPolicyName string, backupScheduleName string, resourceGroupName string, managerName string, parameters BackupSchedule, options *BackupSchedulesClientBeginCreateOrUpdateOptions) (*runtime.Poller[BackupSchedulesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the backup schedule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The backup policy name.
  • backupScheduleName - The backup schedule name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The backup schedule.
  • options - BackupSchedulesClientBeginCreateOrUpdateOptions contains the optional parameters for the BackupSchedulesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupSchedulesCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupSchedulesClient().BeginCreateOrUpdate(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "schedule2", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.BackupSchedule{
		Kind: to.Ptr("Series8000"),
		Properties: &armstorsimple8000series.BackupScheduleProperties{
			BackupType:     to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
			RetentionCount: to.Ptr[int64](1),
			ScheduleRecurrence: &armstorsimple8000series.ScheduleRecurrence{
				RecurrenceType:  to.Ptr(armstorsimple8000series.RecurrenceTypeWeekly),
				RecurrenceValue: to.Ptr[int32](1),
				WeeklyDaysList: []*armstorsimple8000series.DayOfWeek{
					to.Ptr(armstorsimple8000series.DayOfWeekFriday),
					to.Ptr(armstorsimple8000series.DayOfWeekThursday),
					to.Ptr(armstorsimple8000series.DayOfWeekMonday)},
			},
			ScheduleStatus: to.Ptr(armstorsimple8000series.ScheduleStatusEnabled),
			StartTime:      to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-24T01:00:00.000Z"); return t }()),
		},
	}, 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.BackupSchedule = armstorsimple8000series.BackupSchedule{
	// 	Name: to.Ptr("schedule2"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest/schedules/schedule2"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.BackupScheduleProperties{
	// 		BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
	// 		RetentionCount: to.Ptr[int64](1),
	// 		ScheduleRecurrence: &armstorsimple8000series.ScheduleRecurrence{
	// 			RecurrenceType: to.Ptr(armstorsimple8000series.RecurrenceTypeWeekly),
	// 			RecurrenceValue: to.Ptr[int32](1),
	// 			WeeklyDaysList: []*armstorsimple8000series.DayOfWeek{
	// 				to.Ptr(armstorsimple8000series.DayOfWeekMonday),
	// 				to.Ptr(armstorsimple8000series.DayOfWeekThursday),
	// 				to.Ptr(armstorsimple8000series.DayOfWeekFriday)},
	// 			},
	// 			ScheduleStatus: to.Ptr(armstorsimple8000series.ScheduleStatusEnabled),
	// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-24T01:00:00.000Z"); return t}()),
	// 		},
	// 	}
}

Output:

func (*BackupSchedulesClient) BeginDelete 

func (client *BackupSchedulesClient) BeginDelete(ctx context.Context, deviceName string, backupPolicyName string, backupScheduleName string, resourceGroupName string, managerName string, options *BackupSchedulesClientBeginDeleteOptions) (*runtime.Poller[BackupSchedulesClientDeleteResponse], error)

BeginDelete - Deletes the backup schedule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The backup policy name.
  • backupScheduleName - The name the backup schedule.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupSchedulesClientBeginDeleteOptions contains the optional parameters for the BackupSchedulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupSchedulesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupSchedulesClient().BeginDelete(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "schedule1", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*BackupSchedulesClient) Get 

func (client *BackupSchedulesClient) Get(ctx context.Context, deviceName string, backupPolicyName string, backupScheduleName string, resourceGroupName string, managerName string, options *BackupSchedulesClientGetOptions) (BackupSchedulesClientGetResponse, error)

Get - Gets the properties of the specified backup schedule name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The backup policy name.
  • backupScheduleName - The name of the backup schedule to be fetched
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupSchedulesClientGetOptions contains the optional parameters for the BackupSchedulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupSchedulesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBackupSchedulesClient().Get(ctx, "Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "schedule2", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.BackupSchedule = armstorsimple8000series.BackupSchedule{
	// 	Name: to.Ptr("schedule2"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest/schedules/schedule2"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.BackupScheduleProperties{
	// 		BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
	// 		RetentionCount: to.Ptr[int64](1),
	// 		ScheduleRecurrence: &armstorsimple8000series.ScheduleRecurrence{
	// 			RecurrenceType: to.Ptr(armstorsimple8000series.RecurrenceTypeWeekly),
	// 			RecurrenceValue: to.Ptr[int32](1),
	// 			WeeklyDaysList: []*armstorsimple8000series.DayOfWeek{
	// 				to.Ptr(armstorsimple8000series.DayOfWeekMonday),
	// 				to.Ptr(armstorsimple8000series.DayOfWeekThursday),
	// 				to.Ptr(armstorsimple8000series.DayOfWeekFriday)},
	// 			},
	// 			ScheduleStatus: to.Ptr(armstorsimple8000series.ScheduleStatusEnabled),
	// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-24T01:00:00.000Z"); return t}()),
	// 		},
	// 	}
}

Output:

func (*BackupSchedulesClient) NewListByBackupPolicyPager 

func (client *BackupSchedulesClient) NewListByBackupPolicyPager(deviceName string, backupPolicyName string, resourceGroupName string, managerName string, options *BackupSchedulesClientListByBackupPolicyOptions) *runtime.Pager[BackupSchedulesClientListByBackupPolicyResponse]

NewListByBackupPolicyPager - Gets all the backup schedules in a backup policy.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupPolicyName - The backup policy name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupSchedulesClientListByBackupPolicyOptions contains the optional parameters for the BackupSchedulesClient.NewListByBackupPolicyPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupSchedulesListByBackupPolicy.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBackupSchedulesClient().NewListByBackupPolicyPager("Device05ForSDKTest", "BkUpPolicy01ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.BackupScheduleList = armstorsimple8000series.BackupScheduleList{
		// 	Value: []*armstorsimple8000series.BackupSchedule{
		// 		{
		// 			Name: to.Ptr("schedule1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest/schedules/schedule1"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.BackupScheduleProperties{
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				RetentionCount: to.Ptr[int64](1),
		// 				ScheduleRecurrence: &armstorsimple8000series.ScheduleRecurrence{
		// 					RecurrenceType: to.Ptr(armstorsimple8000series.RecurrenceTypeDaily),
		// 					RecurrenceValue: to.Ptr[int32](1),
		// 				},
		// 				ScheduleStatus: to.Ptr(armstorsimple8000series.ScheduleStatusEnabled),
		// 				StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-24T00:00:00.000Z"); return t}()),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("schedule2"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest/schedules/schedule2"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.BackupScheduleProperties{
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				RetentionCount: to.Ptr[int64](1),
		// 				ScheduleRecurrence: &armstorsimple8000series.ScheduleRecurrence{
		// 					RecurrenceType: to.Ptr(armstorsimple8000series.RecurrenceTypeWeekly),
		// 					RecurrenceValue: to.Ptr[int32](1),
		// 					WeeklyDaysList: []*armstorsimple8000series.DayOfWeek{
		// 						to.Ptr(armstorsimple8000series.DayOfWeekMonday),
		// 						to.Ptr(armstorsimple8000series.DayOfWeekThursday),
		// 						to.Ptr(armstorsimple8000series.DayOfWeekFriday)},
		// 					},
		// 					ScheduleStatus: to.Ptr(armstorsimple8000series.ScheduleStatusEnabled),
		// 					StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-24T01:00:00.000Z"); return t}()),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type BackupSchedulesClientBeginCreateOrUpdateOptions 

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

BackupSchedulesClientBeginCreateOrUpdateOptions contains the optional parameters for the BackupSchedulesClient.BeginCreateOrUpdate method.

type BackupSchedulesClientBeginDeleteOptions 

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

BackupSchedulesClientBeginDeleteOptions contains the optional parameters for the BackupSchedulesClient.BeginDelete method.

type BackupSchedulesClientCreateOrUpdateResponse 

type BackupSchedulesClientCreateOrUpdateResponse struct {
	// The backup schedule.
	BackupSchedule
}

BackupSchedulesClientCreateOrUpdateResponse contains the response from method BackupSchedulesClient.BeginCreateOrUpdate.

type BackupSchedulesClientDeleteResponse 

type BackupSchedulesClientDeleteResponse struct {
}

BackupSchedulesClientDeleteResponse contains the response from method BackupSchedulesClient.BeginDelete.

type BackupSchedulesClientGetOptions 

type BackupSchedulesClientGetOptions struct {
}

BackupSchedulesClientGetOptions contains the optional parameters for the BackupSchedulesClient.Get method.

type BackupSchedulesClientGetResponse 

type BackupSchedulesClientGetResponse struct {
	// The backup schedule.
	BackupSchedule
}

BackupSchedulesClientGetResponse contains the response from method BackupSchedulesClient.Get.

type BackupSchedulesClientListByBackupPolicyOptions 

type BackupSchedulesClientListByBackupPolicyOptions struct {
}

BackupSchedulesClientListByBackupPolicyOptions contains the optional parameters for the BackupSchedulesClient.NewListByBackupPolicyPager method.

type BackupSchedulesClientListByBackupPolicyResponse 

type BackupSchedulesClientListByBackupPolicyResponse struct {
	// The backup schedule list.
	BackupScheduleList
}

BackupSchedulesClientListByBackupPolicyResponse contains the response from method BackupSchedulesClient.NewListByBackupPolicyPager.

type BackupStatus 

type BackupStatus string

BackupStatus - The backup status of the volume. 

const (
	BackupStatusDisabled BackupStatus = "Disabled"
	BackupStatusEnabled  BackupStatus = "Enabled"
)

func PossibleBackupStatusValues 

func PossibleBackupStatusValues() []BackupStatus

PossibleBackupStatusValues returns the possible values for the BackupStatus const type.

type BackupType 

type BackupType string

BackupType - The type of the backup. 

const (
	BackupTypeCloudSnapshot BackupType = "CloudSnapshot"
	BackupTypeLocalSnapshot BackupType = "LocalSnapshot"
)

func PossibleBackupTypeValues 

func PossibleBackupTypeValues() []BackupType

PossibleBackupTypeValues returns the possible values for the BackupType const type.

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 subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BackupsClient) BeginClone 

func (client *BackupsClient) BeginClone(ctx context.Context, deviceName string, backupName string, backupElementName string, resourceGroupName string, managerName string, parameters CloneRequest, options *BackupsClientBeginCloneOptions) (*runtime.Poller[BackupsClientCloneResponse], error)

BeginClone - Clones the backup element as a new volume. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupName - The backup name.
  • backupElementName - The backup element name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The clone request object.
  • options - BackupsClientBeginCloneOptions contains the optional parameters for the BackupsClient.BeginClone method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupsClone.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupsClient().BeginClone(ctx, "Device05ForSDKTest", "880e1774-94a8-4f3e-85e6-a61e6b94a8b7", "7e115577-4a3b-4921-bfd4-ee5a1b9bcbb5_0000000000000000", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.CloneRequest{
		BackupElement: &armstorsimple8000series.BackupElement{
			ElementID:         to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/880e1774-94a8-4f3e-85e6-a61e6b94a8b7/elements/7e115577-4a3b-4921-bfd4-ee5a1b9bcbb5_0000000000000000"),
			ElementName:       to.Ptr("7e115577-4a3b-4921-bfd4-ee5a1b9bcbb5_0000000000000000"),
			ElementType:       to.Ptr("managers/devices/backups/elements"),
			SizeInBytes:       to.Ptr[int64](10737418240),
			VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
			VolumeName:        to.Ptr("Clonedvolume1"),
			VolumeType:        to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		},
		TargetAccessControlRecordIDs: []*string{
			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		TargetDeviceID:   to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		TargetVolumeName: to.Ptr("ClonedClonedvolume1"),
	}, 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 (*BackupsClient) BeginDelete 

func (client *BackupsClient) BeginDelete(ctx context.Context, deviceName string, backupName string, resourceGroupName string, managerName string, options *BackupsClientBeginDeleteOptions) (*runtime.Poller[BackupsClientDeleteResponse], error)

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

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupName - The backup name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupsClientBeginDeleteOptions contains the optional parameters for the BackupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupsClient().BeginDelete(ctx, "Device05ForSDKTest", "880e1774-94a8-4f3e-85e6-a61e6b94a8b7", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*BackupsClient) BeginRestore 

func (client *BackupsClient) BeginRestore(ctx context.Context, deviceName string, backupName string, resourceGroupName string, managerName string, options *BackupsClientBeginRestoreOptions) (*runtime.Poller[BackupsClientRestoreResponse], error)

BeginRestore - Restores the backup on the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • backupName - The backupSet name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupsClientBeginRestoreOptions contains the optional parameters for the BackupsClient.BeginRestore method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupsRestore.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBackupsClient().BeginRestore(ctx, "Device05ForSDKTest", "880e1774-94a8-4f3e-85e6-a61e6b94a8b7", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*BackupsClient) NewListByDevicePager 

func (client *BackupsClient) NewListByDevicePager(deviceName string, resourceGroupName string, managerName string, options *BackupsClientListByDeviceOptions) *runtime.Pager[BackupsClientListByDeviceResponse]

NewListByDevicePager - Retrieves all the backups in a device.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BackupsClientListByDeviceOptions contains the optional parameters for the BackupsClient.NewListByDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BackupsListByDevice.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBackupsClient().NewListByDevicePager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.BackupsClientListByDeviceOptions{Filter: to.Ptr("createdTime%20ge%20'2017-06-22T18:30:00Z'%20and%20backupPolicyId%20eq%20'%2Fsubscriptions%2F4385cf00-2d3a-425a-832f-f4285b1c9dce%2FresourceGroups%2FResourceGroupForSDKTest%2Fproviders%2FMicrosoft.StorSimple%2Fmanagers%2FManagerForSDKTest1%2Fdevices%2FDevice05ForSDKTest%2FbackupPolicies%2FBkUpPolicy01ForSDKTest'")})
	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.BackupList = armstorsimple8000series.BackupList{
		// 	Value: []*armstorsimple8000series.Backup{
		// 		{
		// 			Name: to.Ptr("880e1774-94a8-4f3e-85e6-a61e6b94a8b7"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/backups"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/880e1774-94a8-4f3e-85e6-a61e6b94a8b7"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.BackupProperties{
		// 				BackupJobCreationType: to.Ptr(armstorsimple8000series.BackupJobCreationTypeAdhoc),
		// 				BackupPolicyID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest"),
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				CreatedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T22:01:19.708Z"); return t}()),
		// 				Elements: []*armstorsimple8000series.BackupElement{
		// 					{
		// 						ElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/880e1774-94a8-4f3e-85e6-a61e6b94a8b7/elements/87d398b9-63e8-4973-af85-12707c280ce8_0000000000000000"),
		// 						ElementName: to.Ptr("87d398b9-63e8-4973-af85-12707c280ce8_0000000000000000"),
		// 						ElementType: to.Ptr("managers/devices/backups/elements"),
		// 						SizeInBytes: to.Ptr[int64](10737418240),
		// 						VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 						VolumeName: to.Ptr("volume1"),
		// 						VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 					},
		// 					{
		// 						ElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/880e1774-94a8-4f3e-85e6-a61e6b94a8b7/elements/7e115577-4a3b-4921-bfd4-ee5a1b9bcbb5_0000000000000000"),
		// 						ElementName: to.Ptr("7e115577-4a3b-4921-bfd4-ee5a1b9bcbb5_0000000000000000"),
		// 						ElementType: to.Ptr("managers/devices/backups/elements"),
		// 						SizeInBytes: to.Ptr[int64](10737418240),
		// 						VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 						VolumeName: to.Ptr("Clonedvolume1"),
		// 						VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 				}},
		// 				SizeInBytes: to.Ptr[int64](21474836480),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("0826eda8-3d17-4cb9-b2af-d18ecf6ab819"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/backups"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0826eda8-3d17-4cb9-b2af-d18ecf6ab819"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.BackupProperties{
		// 				BackupJobCreationType: to.Ptr(armstorsimple8000series.BackupJobCreationTypeAdhoc),
		// 				BackupPolicyID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest1032280949"),
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				CreatedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T21:22:01.372Z"); return t}()),
		// 				Elements: []*armstorsimple8000series.BackupElement{
		// 					{
		// 						ElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0826eda8-3d17-4cb9-b2af-d18ecf6ab819/elements/89f8af90-6420-45ec-9963-6b3e55d9a44c_0000000000000000"),
		// 						ElementName: to.Ptr("89f8af90-6420-45ec-9963-6b3e55d9a44c_0000000000000000"),
		// 						ElementType: to.Ptr("managers/devices/backups/elements"),
		// 						SizeInBytes: to.Ptr[int64](16106127360),
		// 						VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 						VolumeName: to.Ptr("volume2"),
		// 						VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 					},
		// 					{
		// 						ElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0826eda8-3d17-4cb9-b2af-d18ecf6ab819/elements/95581ea2-b0aa-482a-be0c-8b7bd7658345_0000000000000000"),
		// 						ElementName: to.Ptr("95581ea2-b0aa-482a-be0c-8b7bd7658345_0000000000000000"),
		// 						ElementType: to.Ptr("managers/devices/backups/elements"),
		// 						SizeInBytes: to.Ptr[int64](10737418240),
		// 						VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 						VolumeName: to.Ptr("volume1"),
		// 						VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 				}},
		// 				SizeInBytes: to.Ptr[int64](26843545600),
		// 			},
		// 	}},
		// }
	}
}

Output:

type BackupsClientBeginCloneOptions 

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

BackupsClientBeginCloneOptions contains the optional parameters for the BackupsClient.BeginClone method.

type BackupsClientBeginDeleteOptions 

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

BackupsClientBeginDeleteOptions contains the optional parameters for the BackupsClient.BeginDelete method.

type BackupsClientBeginRestoreOptions 

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

BackupsClientBeginRestoreOptions contains the optional parameters for the BackupsClient.BeginRestore method.

type BackupsClientCloneResponse 

type BackupsClientCloneResponse struct {
}

BackupsClientCloneResponse contains the response from method BackupsClient.BeginClone.

type BackupsClientDeleteResponse 

type BackupsClientDeleteResponse struct {
}

BackupsClientDeleteResponse contains the response from method BackupsClient.BeginDelete.

type BackupsClientListByDeviceOptions 

type BackupsClientListByDeviceOptions struct {
	// OData Filter options
	Filter *string
}

BackupsClientListByDeviceOptions contains the optional parameters for the BackupsClient.NewListByDevicePager method.

type BackupsClientListByDeviceResponse 

type BackupsClientListByDeviceResponse struct {
	// The collection of backups.
	BackupList
}

BackupsClientListByDeviceResponse contains the response from method BackupsClient.NewListByDevicePager.

type BackupsClientRestoreResponse 

type BackupsClientRestoreResponse struct {
}

BackupsClientRestoreResponse contains the response from method BackupsClient.BeginRestore.

type BandwidthRateSettingProperties 

type BandwidthRateSettingProperties struct {
	// REQUIRED; The schedules.
	Schedules []*BandwidthSchedule

	// READ-ONLY; The number of volumes that uses the bandwidth setting.
	VolumeCount *int32
}

BandwidthRateSettingProperties - The properties of the bandwidth setting.

func (BandwidthRateSettingProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BandwidthRateSettingProperties.

func (*BandwidthRateSettingProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BandwidthRateSettingProperties.

type BandwidthSchedule 

type BandwidthSchedule struct {
	// REQUIRED; The days of the week when this schedule is applicable.
	Days []*DayOfWeek

	// REQUIRED; The rate in Mbps.
	RateInMbps *int32

	// REQUIRED; The start time of the schedule.
	Start *Time

	// REQUIRED; The stop time of the schedule.
	Stop *Time
}

BandwidthSchedule - The schedule for bandwidth setting.

func (BandwidthSchedule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BandwidthSchedule.

func (*BandwidthSchedule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BandwidthSchedule.

type BandwidthSetting 

type BandwidthSetting struct {
	// REQUIRED; The properties of the bandwidth setting.
	Properties *BandwidthRateSettingProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

BandwidthSetting - The bandwidth setting.

func (BandwidthSetting) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BandwidthSetting.

func (*BandwidthSetting) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BandwidthSetting.

type BandwidthSettingList 

type BandwidthSettingList struct {
	// REQUIRED; The value.
	Value []*BandwidthSetting
}

BandwidthSettingList - The collection of bandwidth setting entities.

func (BandwidthSettingList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BandwidthSettingList.

func (*BandwidthSettingList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BandwidthSettingList.

type BandwidthSettingsClient 

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

BandwidthSettingsClient contains the methods for the BandwidthSettings group. Don't use this type directly, use NewBandwidthSettingsClient() instead.

func NewBandwidthSettingsClient 

func NewBandwidthSettingsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BandwidthSettingsClient, error)

NewBandwidthSettingsClient creates a new instance of BandwidthSettingsClient with the specified values.

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

func (*BandwidthSettingsClient) BeginCreateOrUpdate 

func (client *BandwidthSettingsClient) BeginCreateOrUpdate(ctx context.Context, bandwidthSettingName string, resourceGroupName string, managerName string, parameters BandwidthSetting, options *BandwidthSettingsClientBeginCreateOrUpdateOptions) (*runtime.Poller[BandwidthSettingsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the bandwidth setting If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • bandwidthSettingName - The bandwidth setting name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The bandwidth setting to be added or updated.
  • options - BandwidthSettingsClientBeginCreateOrUpdateOptions contains the optional parameters for the BandwidthSettingsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BandwidthSettingsCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBandwidthSettingsClient().BeginCreateOrUpdate(ctx, "BWSForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.BandwidthSetting{
		Properties: &armstorsimple8000series.BandwidthRateSettingProperties{
			Schedules: []*armstorsimple8000series.BandwidthSchedule{
				{
					Days: []*armstorsimple8000series.DayOfWeek{
						to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
						to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
					RateInMbps: to.Ptr[int32](10),
					Start: &armstorsimple8000series.Time{
						Hours:   to.Ptr[int32](10),
						Minutes: to.Ptr[int32](0),
						Seconds: to.Ptr[int32](0),
					},
					Stop: &armstorsimple8000series.Time{
						Hours:   to.Ptr[int32](20),
						Minutes: to.Ptr[int32](0),
						Seconds: to.Ptr[int32](0),
					},
				}},
		},
	}, 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.BandwidthSetting = armstorsimple8000series.BandwidthSetting{
	// 	Name: to.Ptr("BWSForTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/BWSForTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.BandwidthRateSettingProperties{
	// 		Schedules: []*armstorsimple8000series.BandwidthSchedule{
	// 			{
	// 				Days: []*armstorsimple8000series.DayOfWeek{
	// 					to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
	// 					RateInMbps: to.Ptr[int32](10),
	// 					Start: &armstorsimple8000series.Time{
	// 						Hours: to.Ptr[int32](10),
	// 						Minutes: to.Ptr[int32](0),
	// 						Seconds: to.Ptr[int32](0),
	// 					},
	// 					Stop: &armstorsimple8000series.Time{
	// 						Hours: to.Ptr[int32](20),
	// 						Minutes: to.Ptr[int32](0),
	// 						Seconds: to.Ptr[int32](0),
	// 					},
	// 			}},
	// 			VolumeCount: to.Ptr[int32](0),
	// 		},
	// 	}
}

Output:

func (*BandwidthSettingsClient) BeginDelete 

func (client *BandwidthSettingsClient) BeginDelete(ctx context.Context, bandwidthSettingName string, resourceGroupName string, managerName string, options *BandwidthSettingsClientBeginDeleteOptions) (*runtime.Poller[BandwidthSettingsClientDeleteResponse], error)

BeginDelete - Deletes the bandwidth setting If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • bandwidthSettingName - The name of the bandwidth setting.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BandwidthSettingsClientBeginDeleteOptions contains the optional parameters for the BandwidthSettingsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BandwidthSettingsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBandwidthSettingsClient().BeginDelete(ctx, "BWSForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*BandwidthSettingsClient) Get 

func (client *BandwidthSettingsClient) Get(ctx context.Context, bandwidthSettingName string, resourceGroupName string, managerName string, options *BandwidthSettingsClientGetOptions) (BandwidthSettingsClientGetResponse, error)

Get - Returns the properties of the specified bandwidth setting name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • bandwidthSettingName - The name of bandwidth setting to be fetched.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BandwidthSettingsClientGetOptions contains the optional parameters for the BandwidthSettingsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BandwidthSettingsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBandwidthSettingsClient().Get(ctx, "bandwidthSetting1", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.BandwidthSetting = armstorsimple8000series.BandwidthSetting{
	// 	Name: to.Ptr("bandwidthSetting1"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/bandwidthSetting1"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.BandwidthRateSettingProperties{
	// 		Schedules: []*armstorsimple8000series.BandwidthSchedule{
	// 			{
	// 				Days: []*armstorsimple8000series.DayOfWeek{
	// 					to.Ptr(armstorsimple8000series.DayOfWeekMonday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekTuesday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekWednesday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekThursday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekFriday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
	// 					to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
	// 					RateInMbps: to.Ptr[int32](150),
	// 					Start: &armstorsimple8000series.Time{
	// 						Hours: to.Ptr[int32](10),
	// 						Minutes: to.Ptr[int32](0),
	// 						Seconds: to.Ptr[int32](0),
	// 					},
	// 					Stop: &armstorsimple8000series.Time{
	// 						Hours: to.Ptr[int32](22),
	// 						Minutes: to.Ptr[int32](0),
	// 						Seconds: to.Ptr[int32](0),
	// 					},
	// 				},
	// 				{
	// 					Days: []*armstorsimple8000series.DayOfWeek{
	// 						to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
	// 						to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
	// 						RateInMbps: to.Ptr[int32](100),
	// 						Start: &armstorsimple8000series.Time{
	// 							Hours: to.Ptr[int32](8),
	// 							Minutes: to.Ptr[int32](0),
	// 							Seconds: to.Ptr[int32](0),
	// 						},
	// 						Stop: &armstorsimple8000series.Time{
	// 							Hours: to.Ptr[int32](10),
	// 							Minutes: to.Ptr[int32](0),
	// 							Seconds: to.Ptr[int32](0),
	// 						},
	// 				}},
	// 				VolumeCount: to.Ptr[int32](1),
	// 			},
	// 		}
}

Output:

func (*BandwidthSettingsClient) NewListByManagerPager 

func (client *BandwidthSettingsClient) NewListByManagerPager(resourceGroupName string, managerName string, options *BandwidthSettingsClientListByManagerOptions) *runtime.Pager[BandwidthSettingsClientListByManagerResponse]

NewListByManagerPager - Retrieves all the bandwidth setting in a manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - BandwidthSettingsClientListByManagerOptions contains the optional parameters for the BandwidthSettingsClient.NewListByManagerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/BandwidthSettingsListByManager.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBandwidthSettingsClient().NewListByManagerPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.BandwidthSettingList = armstorsimple8000series.BandwidthSettingList{
		// 	Value: []*armstorsimple8000series.BandwidthSetting{
		// 		{
		// 			Name: to.Ptr("bandwidthSetting1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/bandwidthSetting1"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.BandwidthRateSettingProperties{
		// 				Schedules: []*armstorsimple8000series.BandwidthSchedule{
		// 					{
		// 						Days: []*armstorsimple8000series.DayOfWeek{
		// 							to.Ptr(armstorsimple8000series.DayOfWeekMonday),
		// 							to.Ptr(armstorsimple8000series.DayOfWeekTuesday),
		// 							to.Ptr(armstorsimple8000series.DayOfWeekWednesday),
		// 							to.Ptr(armstorsimple8000series.DayOfWeekThursday),
		// 							to.Ptr(armstorsimple8000series.DayOfWeekFriday),
		// 							to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
		// 							to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
		// 							RateInMbps: to.Ptr[int32](150),
		// 							Start: &armstorsimple8000series.Time{
		// 								Hours: to.Ptr[int32](10),
		// 								Minutes: to.Ptr[int32](0),
		// 								Seconds: to.Ptr[int32](0),
		// 							},
		// 							Stop: &armstorsimple8000series.Time{
		// 								Hours: to.Ptr[int32](22),
		// 								Minutes: to.Ptr[int32](0),
		// 								Seconds: to.Ptr[int32](0),
		// 							},
		// 						},
		// 						{
		// 							Days: []*armstorsimple8000series.DayOfWeek{
		// 								to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
		// 								to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
		// 								RateInMbps: to.Ptr[int32](100),
		// 								Start: &armstorsimple8000series.Time{
		// 									Hours: to.Ptr[int32](8),
		// 									Minutes: to.Ptr[int32](0),
		// 									Seconds: to.Ptr[int32](0),
		// 								},
		// 								Stop: &armstorsimple8000series.Time{
		// 									Hours: to.Ptr[int32](10),
		// 									Minutes: to.Ptr[int32](0),
		// 									Seconds: to.Ptr[int32](0),
		// 								},
		// 						}},
		// 						VolumeCount: to.Ptr[int32](1),
		// 					},
		// 				},
		// 				{
		// 					Name: to.Ptr("BandwidthSetting2"),
		// 					Type: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings"),
		// 					ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/BandwidthSetting2"),
		// 					Kind: to.Ptr("Series8000"),
		// 					Properties: &armstorsimple8000series.BandwidthRateSettingProperties{
		// 						Schedules: []*armstorsimple8000series.BandwidthSchedule{
		// 							{
		// 								Days: []*armstorsimple8000series.DayOfWeek{
		// 									to.Ptr(armstorsimple8000series.DayOfWeekMonday),
		// 									to.Ptr(armstorsimple8000series.DayOfWeekTuesday),
		// 									to.Ptr(armstorsimple8000series.DayOfWeekWednesday),
		// 									to.Ptr(armstorsimple8000series.DayOfWeekThursday),
		// 									to.Ptr(armstorsimple8000series.DayOfWeekFriday),
		// 									to.Ptr(armstorsimple8000series.DayOfWeekSaturday),
		// 									to.Ptr(armstorsimple8000series.DayOfWeekSunday)},
		// 									RateInMbps: to.Ptr[int32](150),
		// 									Start: &armstorsimple8000series.Time{
		// 										Hours: to.Ptr[int32](10),
		// 										Minutes: to.Ptr[int32](0),
		// 										Seconds: to.Ptr[int32](0),
		// 									},
		// 									Stop: &armstorsimple8000series.Time{
		// 										Hours: to.Ptr[int32](22),
		// 										Minutes: to.Ptr[int32](0),
		// 										Seconds: to.Ptr[int32](0),
		// 									},
		// 								},
		// 								{
		// 									Days: []*armstorsimple8000series.DayOfWeek{
		// 										to.Ptr(armstorsimple8000series.DayOfWeekThursday),
		// 										to.Ptr(armstorsimple8000series.DayOfWeekFriday)},
		// 										RateInMbps: to.Ptr[int32](80),
		// 										Start: &armstorsimple8000series.Time{
		// 											Hours: to.Ptr[int32](8),
		// 											Minutes: to.Ptr[int32](0),
		// 											Seconds: to.Ptr[int32](0),
		// 										},
		// 										Stop: &armstorsimple8000series.Time{
		// 											Hours: to.Ptr[int32](10),
		// 											Minutes: to.Ptr[int32](0),
		// 											Seconds: to.Ptr[int32](0),
		// 										},
		// 								}},
		// 								VolumeCount: to.Ptr[int32](0),
		// 							},
		// 					}},
		// 				}
	}
}

Output:

type BandwidthSettingsClientBeginCreateOrUpdateOptions 

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

BandwidthSettingsClientBeginCreateOrUpdateOptions contains the optional parameters for the BandwidthSettingsClient.BeginCreateOrUpdate method.

type BandwidthSettingsClientBeginDeleteOptions 

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

BandwidthSettingsClientBeginDeleteOptions contains the optional parameters for the BandwidthSettingsClient.BeginDelete method.

type BandwidthSettingsClientCreateOrUpdateResponse 

type BandwidthSettingsClientCreateOrUpdateResponse struct {
	// The bandwidth setting.
	BandwidthSetting
}

BandwidthSettingsClientCreateOrUpdateResponse contains the response from method BandwidthSettingsClient.BeginCreateOrUpdate.

type BandwidthSettingsClientDeleteResponse 

type BandwidthSettingsClientDeleteResponse struct {
}

BandwidthSettingsClientDeleteResponse contains the response from method BandwidthSettingsClient.BeginDelete.

type BandwidthSettingsClientGetOptions 

type BandwidthSettingsClientGetOptions struct {
}

BandwidthSettingsClientGetOptions contains the optional parameters for the BandwidthSettingsClient.Get method.

type BandwidthSettingsClientGetResponse 

type BandwidthSettingsClientGetResponse struct {
	// The bandwidth setting.
	BandwidthSetting
}

BandwidthSettingsClientGetResponse contains the response from method BandwidthSettingsClient.Get.

type BandwidthSettingsClientListByManagerOptions 

type BandwidthSettingsClientListByManagerOptions struct {
}

BandwidthSettingsClientListByManagerOptions contains the optional parameters for the BandwidthSettingsClient.NewListByManagerPager method.

type BandwidthSettingsClientListByManagerResponse 

type BandwidthSettingsClientListByManagerResponse struct {
	// The collection of bandwidth setting entities.
	BandwidthSettingList
}

BandwidthSettingsClientListByManagerResponse contains the response from method BandwidthSettingsClient.NewListByManagerPager.

type BaseModel 

type BaseModel struct {
	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

BaseModel - Represents the base class for all other ARM object models

func (BaseModel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BaseModel.

func (*BaseModel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BaseModel.

type ChapSettings 

type ChapSettings struct {
	// The CHAP initiator secret.
	InitiatorSecret *AsymmetricEncryptedSecret

	// The CHAP initiator user.
	InitiatorUser *string

	// The target secret.
	TargetSecret *AsymmetricEncryptedSecret

	// The CHAP target user.
	TargetUser *string
}

ChapSettings - The Challenge-Handshake Authentication Protocol (CHAP) settings.

func (ChapSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ChapSettings.

func (*ChapSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChapSettings.

type ClearAlertRequest 

type ClearAlertRequest struct {
	// REQUIRED; The list of alert IDs to be cleared
	Alerts []*string

	// The resolution message while clearing the alert
	ResolutionMessage *string
}

ClearAlertRequest - The request for clearing the alert

func (ClearAlertRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ClearAlertRequest.

func (*ClearAlertRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClearAlertRequest.

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 subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAccessControlRecordsClient 

func (c *ClientFactory) NewAccessControlRecordsClient() *AccessControlRecordsClient

NewAccessControlRecordsClient creates a new instance of AccessControlRecordsClient.

func (*ClientFactory) NewAlertsClient 

func (c *ClientFactory) NewAlertsClient() *AlertsClient

NewAlertsClient creates a new instance of AlertsClient.

func (*ClientFactory) NewBackupPoliciesClient 

func (c *ClientFactory) NewBackupPoliciesClient() *BackupPoliciesClient

NewBackupPoliciesClient creates a new instance of BackupPoliciesClient.

func (*ClientFactory) NewBackupSchedulesClient 

func (c *ClientFactory) NewBackupSchedulesClient() *BackupSchedulesClient

NewBackupSchedulesClient creates a new instance of BackupSchedulesClient.

func (*ClientFactory) NewBackupsClient 

func (c *ClientFactory) NewBackupsClient() *BackupsClient

NewBackupsClient creates a new instance of BackupsClient.

func (*ClientFactory) NewBandwidthSettingsClient 

func (c *ClientFactory) NewBandwidthSettingsClient() *BandwidthSettingsClient

NewBandwidthSettingsClient creates a new instance of BandwidthSettingsClient.

func (*ClientFactory) NewCloudAppliancesClient 

func (c *ClientFactory) NewCloudAppliancesClient() *CloudAppliancesClient

NewCloudAppliancesClient creates a new instance of CloudAppliancesClient.

func (*ClientFactory) NewDeviceSettingsClient 

func (c *ClientFactory) NewDeviceSettingsClient() *DeviceSettingsClient

NewDeviceSettingsClient creates a new instance of DeviceSettingsClient.

func (*ClientFactory) NewDevicesClient 

func (c *ClientFactory) NewDevicesClient() *DevicesClient

NewDevicesClient creates a new instance of DevicesClient.

func (*ClientFactory) NewHardwareComponentGroupsClient 

func (c *ClientFactory) NewHardwareComponentGroupsClient() *HardwareComponentGroupsClient

NewHardwareComponentGroupsClient creates a new instance of HardwareComponentGroupsClient.

func (*ClientFactory) NewJobsClient 

func (c *ClientFactory) NewJobsClient() *JobsClient

NewJobsClient creates a new instance of JobsClient.

func (*ClientFactory) NewManagersClient 

func (c *ClientFactory) NewManagersClient() *ManagersClient

NewManagersClient creates a new instance of ManagersClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewStorageAccountCredentialsClient 

func (c *ClientFactory) NewStorageAccountCredentialsClient() *StorageAccountCredentialsClient

NewStorageAccountCredentialsClient creates a new instance of StorageAccountCredentialsClient.

func (*ClientFactory) NewVolumeContainersClient 

func (c *ClientFactory) NewVolumeContainersClient() *VolumeContainersClient

NewVolumeContainersClient creates a new instance of VolumeContainersClient.

func (*ClientFactory) NewVolumesClient 

func (c *ClientFactory) NewVolumesClient() *VolumesClient

NewVolumesClient creates a new instance of VolumesClient.

type CloneRequest 

type CloneRequest struct {
	// REQUIRED; The backup element that is cloned.
	BackupElement *BackupElement

	// REQUIRED; The list of path IDs of the access control records to be associated to the new cloned volume.
	TargetAccessControlRecordIDs []*string

	// REQUIRED; The path ID of the device which will act as the clone target.
	TargetDeviceID *string

	// REQUIRED; The name of the new volume which will be created and the backup will be cloned into.
	TargetVolumeName *string
}

CloneRequest - The clone job request.

func (CloneRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloneRequest.

func (*CloneRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloneRequest.

type CloudAppliance 

type CloudAppliance struct {
	// REQUIRED; The name.
	Name *string

	// REQUIRED; The virtual network region.
	VnetRegion *string

	// Indicates whether virtual network used is configured with DNS or not.
	IsVnetDNSConfigured *bool

	// Indicates whether virtual network used is configured with express route or not.
	IsVnetExpressConfigured *bool

	// The model number.
	ModelNumber *string

	// The name of the storage account.
	StorageAccountName *string

	// The type of the storage account.
	StorageAccountType *string

	// The name of the subnet.
	SubnetName *string

	// The name of the virtual machine image.
	VMImageName *string

	// The type of the virtual machine.
	VMType *string

	// The name of the virtual network.
	VnetName *string
}

CloudAppliance - The cloud appliance.

func (CloudAppliance) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloudAppliance.

func (*CloudAppliance) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudAppliance.

type CloudApplianceConfiguration 

type CloudApplianceConfiguration struct {
	// REQUIRED; The properties.
	Properties *CloudApplianceConfigurationProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

CloudApplianceConfiguration - The cloud appliance configuration

func (CloudApplianceConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloudApplianceConfiguration.

func (*CloudApplianceConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudApplianceConfiguration.

type CloudApplianceConfigurationList 

type CloudApplianceConfigurationList struct {
	// REQUIRED; The value.
	Value []*CloudApplianceConfiguration
}

CloudApplianceConfigurationList - The cloud appliance configuration list

func (CloudApplianceConfigurationList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloudApplianceConfigurationList.

func (*CloudApplianceConfigurationList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudApplianceConfigurationList.

type CloudApplianceConfigurationProperties 

type CloudApplianceConfigurationProperties struct {
	// REQUIRED; The ACS configuration.
	AcsConfiguration *AcsConfiguration

	// REQUIRED; The cloud platform.
	CloudPlatform *string

	// REQUIRED; The model number.
	ModelNumber *string

	// REQUIRED; The supported regions.
	SupportedRegions []*string

	// REQUIRED; The supported storage account types.
	SupportedStorageAccountTypes []*string

	// REQUIRED; The supported virtual machine images.
	SupportedVMImages []*VMImage

	// REQUIRED; The supported virtual machine types.
	SupportedVMTypes []*string
}

CloudApplianceConfigurationProperties - The properties of cloud appliance configuration.

func (CloudApplianceConfigurationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloudApplianceConfigurationProperties.

func (*CloudApplianceConfigurationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudApplianceConfigurationProperties.

type CloudApplianceSettings 

type CloudApplianceSettings struct {
	// The channel integrity key (encrypted with DAK).
	ChannelIntegrityKey *AsymmetricEncryptedSecret

	// The service data encryption key (encrypted with DAK).
	ServiceDataEncryptionKey *AsymmetricEncryptedSecret
}

CloudApplianceSettings - The cloud appliance settings.

func (CloudApplianceSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloudApplianceSettings.

func (*CloudApplianceSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudApplianceSettings.

type CloudAppliancesClient 

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

CloudAppliancesClient contains the methods for the CloudAppliances group. Don't use this type directly, use NewCloudAppliancesClient() instead.

func NewCloudAppliancesClient 

func NewCloudAppliancesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CloudAppliancesClient, error)

NewCloudAppliancesClient creates a new instance of CloudAppliancesClient with the specified values.

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

func (*CloudAppliancesClient) BeginProvision 

func (client *CloudAppliancesClient) BeginProvision(ctx context.Context, resourceGroupName string, managerName string, parameters CloudAppliance, options *CloudAppliancesClientBeginProvisionOptions) (*runtime.Poller[CloudAppliancesClientProvisionResponse], error)

BeginProvision - Provisions cloud appliance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The cloud appliance
  • options - CloudAppliancesClientBeginProvisionOptions contains the optional parameters for the CloudAppliancesClient.BeginProvision method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/CloudAppliancesProvision.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCloudAppliancesClient().BeginProvision(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.CloudAppliance{
		Name:        to.Ptr("sca07forsdktest"),
		ModelNumber: to.Ptr("8020"),
		VnetRegion:  to.Ptr("West US"),
	}, 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 (*CloudAppliancesClient) NewListSupportedConfigurationsPager 

func (client *CloudAppliancesClient) NewListSupportedConfigurationsPager(resourceGroupName string, managerName string, options *CloudAppliancesClientListSupportedConfigurationsOptions) *runtime.Pager[CloudAppliancesClientListSupportedConfigurationsResponse]

NewListSupportedConfigurationsPager - Lists supported cloud appliance models and supported configurations.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - CloudAppliancesClientListSupportedConfigurationsOptions contains the optional parameters for the CloudAppliancesClient.NewListSupportedConfigurationsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/CloudAppliancesListSupportedConfigurations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewCloudAppliancesClient().NewListSupportedConfigurationsPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.CloudApplianceConfigurationList = armstorsimple8000series.CloudApplianceConfigurationList{
		// 	Value: []*armstorsimple8000series.CloudApplianceConfiguration{
		// 		{
		// 			Name: to.Ptr("8010"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/cloudApplianceConfigurations"),
		// 			ID: to.Ptr("/subscriptions/d3ebfe71-b7a9-4c57-92b9-68a2afde4de5/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/managers/cloudApplianceConfigurations/8010"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.CloudApplianceConfigurationProperties{
		// 				AcsConfiguration: &armstorsimple8000series.AcsConfiguration{
		// 					Namespace: to.Ptr("wuspod01rp1users"),
		// 					Realm: to.Ptr("http://windowscloudbackup/m3"),
		// 					ServiceURL: to.Ptr("accesscontrol.windows.net"),
		// 				},
		// 				CloudPlatform: to.Ptr("public"),
		// 				ModelNumber: to.Ptr("8010"),
		// 				SupportedRegions: []*string{
		// 					to.Ptr("All")},
		// 					SupportedStorageAccountTypes: []*string{
		// 						to.Ptr("Standard_LRS"),
		// 						to.Ptr("Standard_GRS"),
		// 						to.Ptr("Standard_RAGRS")},
		// 						SupportedVMImages: []*armstorsimple8000series.VMImage{
		// 							{
		// 								Name: to.Ptr("StorSimple 8000 Series Update 4"),
		// 								Offer: to.Ptr("StorSimple"),
		// 								Publisher: to.Ptr("MicrosoftHybridCloudStorage"),
		// 								SKU: to.Ptr("StorSimple-Garda-8000-Series-BBUpdate"),
		// 								Version: to.Ptr("9600.17820.170208"),
		// 						}},
		// 						SupportedVMTypes: []*string{
		// 							to.Ptr("Standard_A3")},
		// 						},
		// 					},
		// 					{
		// 						Name: to.Ptr("8020"),
		// 						Type: to.Ptr("Microsoft.StorSimple/managers/cloudApplianceConfigurations"),
		// 						ID: to.Ptr("/subscriptions/d3ebfe71-b7a9-4c57-92b9-68a2afde4de5/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/managers/cloudApplianceConfigurations/8020"),
		// 						Kind: to.Ptr("Series8000"),
		// 						Properties: &armstorsimple8000series.CloudApplianceConfigurationProperties{
		// 							AcsConfiguration: &armstorsimple8000series.AcsConfiguration{
		// 								Namespace: to.Ptr("wuspod01rp1users"),
		// 								Realm: to.Ptr("http://windowscloudbackup/m3"),
		// 								ServiceURL: to.Ptr("accesscontrol.windows.net"),
		// 							},
		// 							CloudPlatform: to.Ptr("public"),
		// 							ModelNumber: to.Ptr("8020"),
		// 							SupportedRegions: []*string{
		// 								to.Ptr("Central US"),
		// 								to.Ptr("East US"),
		// 								to.Ptr("East US 2"),
		// 								to.Ptr("South Central US"),
		// 								to.Ptr("West US"),
		// 								to.Ptr("North Europe"),
		// 								to.Ptr("West Europe"),
		// 								to.Ptr("East Asia"),
		// 								to.Ptr("Southeast Asia"),
		// 								to.Ptr("Japan East"),
		// 								to.Ptr("Japan West"),
		// 								to.Ptr("Australia East"),
		// 								to.Ptr("Australia Southeast")},
		// 								SupportedStorageAccountTypes: []*string{
		// 									to.Ptr("Premium_LRS")},
		// 									SupportedVMImages: []*armstorsimple8000series.VMImage{
		// 										{
		// 											Name: to.Ptr("StorSimple 8000 Series Update 4"),
		// 											Offer: to.Ptr("StorSimple"),
		// 											Publisher: to.Ptr("MicrosoftHybridCloudStorage"),
		// 											SKU: to.Ptr("StorSimple-Garda-8000-Series-BBUpdate"),
		// 											Version: to.Ptr("9600.17820.170208"),
		// 									}},
		// 									SupportedVMTypes: []*string{
		// 										to.Ptr("Standard_DS3")},
		// 									},
		// 							}},
		// 						}
	}
}

Output:

type CloudAppliancesClientBeginProvisionOptions 

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

CloudAppliancesClientBeginProvisionOptions contains the optional parameters for the CloudAppliancesClient.BeginProvision method.

type CloudAppliancesClientListSupportedConfigurationsOptions 

type CloudAppliancesClientListSupportedConfigurationsOptions struct {
}

CloudAppliancesClientListSupportedConfigurationsOptions contains the optional parameters for the CloudAppliancesClient.NewListSupportedConfigurationsPager method.

type CloudAppliancesClientListSupportedConfigurationsResponse 

type CloudAppliancesClientListSupportedConfigurationsResponse struct {
	// The cloud appliance configuration list
	CloudApplianceConfigurationList
}

CloudAppliancesClientListSupportedConfigurationsResponse contains the response from method CloudAppliancesClient.NewListSupportedConfigurationsPager.

type CloudAppliancesClientProvisionResponse 

type CloudAppliancesClientProvisionResponse struct {
}

CloudAppliancesClientProvisionResponse contains the response from method CloudAppliancesClient.BeginProvision.

type ConfigureDeviceRequest 

type ConfigureDeviceRequest struct {
	// REQUIRED; The properties of the configure device request.
	Properties *ConfigureDeviceRequestProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

ConfigureDeviceRequest - The mandatory device configuration request.

func (ConfigureDeviceRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigureDeviceRequest.

func (*ConfigureDeviceRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigureDeviceRequest.

type ConfigureDeviceRequestProperties 

type ConfigureDeviceRequestProperties struct {
	// REQUIRED; The current name of the device.
	CurrentDeviceName *string

	// REQUIRED; The friendly name for the device.
	FriendlyName *string

	// REQUIRED; The device time zone. For eg: "Pacific Standard Time"
	TimeZone *string

	// The secondary DNS Settings of the device.
	DNSSettings *SecondaryDNSSettings

	// The 'Data 0' network interface card settings.
	NetworkInterfaceData0Settings *NetworkInterfaceData0Settings
}

ConfigureDeviceRequestProperties - The properties of the configure device request.

func (ConfigureDeviceRequestProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConfigureDeviceRequestProperties.

func (*ConfigureDeviceRequestProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigureDeviceRequestProperties.

type ControllerID 

type ControllerID string

ControllerID - The active controller that the request is expecting on the device. 

const (
	ControllerIDController0 ControllerID = "Controller0"
	ControllerIDController1 ControllerID = "Controller1"
	ControllerIDNone        ControllerID = "None"
	ControllerIDUnknown     ControllerID = "Unknown"
)

func PossibleControllerIDValues 

func PossibleControllerIDValues() []ControllerID

PossibleControllerIDValues returns the possible values for the ControllerID const type.

type ControllerPowerStateAction 

type ControllerPowerStateAction string

ControllerPowerStateAction - The power state that the request is expecting for the controller of the device. 

const (
	ControllerPowerStateActionRestart  ControllerPowerStateAction = "Restart"
	ControllerPowerStateActionShutdown ControllerPowerStateAction = "Shutdown"
	ControllerPowerStateActionStart    ControllerPowerStateAction = "Start"
)

func PossibleControllerPowerStateActionValues 

func PossibleControllerPowerStateActionValues() []ControllerPowerStateAction

PossibleControllerPowerStateActionValues returns the possible values for the ControllerPowerStateAction const type.

type ControllerPowerStateChangeRequest 

type ControllerPowerStateChangeRequest struct {
	// REQUIRED; The properties of the controller power state change request.
	Properties *ControllerPowerStateChangeRequestProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

ControllerPowerStateChangeRequest - The controller power state change request.

func (ControllerPowerStateChangeRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ControllerPowerStateChangeRequest.

func (*ControllerPowerStateChangeRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ControllerPowerStateChangeRequest.

type ControllerPowerStateChangeRequestProperties 

type ControllerPowerStateChangeRequestProperties struct {
	// REQUIRED; The power state that the request is expecting for the controller of the device.
	Action *ControllerPowerStateAction

	// REQUIRED; The active controller that the request is expecting on the device.
	ActiveController *ControllerID

	// REQUIRED; The controller 0's status that the request is expecting on the device.
	Controller0State *ControllerStatus

	// REQUIRED; The controller 1's status that the request is expecting on the device.
	Controller1State *ControllerStatus
}

ControllerPowerStateChangeRequestProperties - The properties of the controller power state change request.

func (ControllerPowerStateChangeRequestProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ControllerPowerStateChangeRequestProperties.

func (*ControllerPowerStateChangeRequestProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ControllerPowerStateChangeRequestProperties.

type ControllerStatus 

type ControllerStatus string

ControllerStatus - The controller 0's status that the request is expecting on the device. 

const (
	ControllerStatusFailure    ControllerStatus = "Failure"
	ControllerStatusNotPresent ControllerStatus = "NotPresent"
	ControllerStatusOk         ControllerStatus = "Ok"
	ControllerStatusPoweredOff ControllerStatus = "PoweredOff"
	ControllerStatusRecovering ControllerStatus = "Recovering"
	ControllerStatusWarning    ControllerStatus = "Warning"
)

func PossibleControllerStatusValues 

func PossibleControllerStatusValues() []ControllerStatus

PossibleControllerStatusValues returns the possible values for the ControllerStatus const type.

type DNSSettings 

type DNSSettings struct {
	// The primary IPv4 DNS server for the device
	PrimaryDNSServer *string

	// The primary IPv6 DNS server for the device
	PrimaryIPv6DNSServer *string

	// The secondary IPv4 DNS server for the device
	SecondaryDNSServers []*string

	// The secondary IPv6 DNS server for the device
	SecondaryIPv6DNSServers []*string
}

DNSSettings - The DNS(Domain Name Server) settings of a device.

func (DNSSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DNSSettings.

func (*DNSSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DNSSettings.

type DataStatistics 

type DataStatistics struct {
	// The number of bytes of data written to cloud, as part of the job.
	CloudData *int64

	// The number of bytes of data processed till now, as part of the job.
	ProcessedData *int64

	// The average throughput of data processed(bytes/sec), as part of the job.
	Throughput *int64

	// The total bytes of data to be processed, as part of the job.
	TotalData *int64
}

DataStatistics - The additional details related to the data related statistics of a job. Currently applicable only for Backup, Clone and Restore jobs.

func (DataStatistics) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataStatistics.

func (*DataStatistics) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataStatistics.

type DayOfWeek 

type DayOfWeek string
const (
	DayOfWeekFriday    DayOfWeek = "Friday"
	DayOfWeekMonday    DayOfWeek = "Monday"
	DayOfWeekSaturday  DayOfWeek = "Saturday"
	DayOfWeekSunday    DayOfWeek = "Sunday"
	DayOfWeekThursday  DayOfWeek = "Thursday"
	DayOfWeekTuesday   DayOfWeek = "Tuesday"
	DayOfWeekWednesday DayOfWeek = "Wednesday"
)

func PossibleDayOfWeekValues 

func PossibleDayOfWeekValues() []DayOfWeek

PossibleDayOfWeekValues returns the possible values for the DayOfWeek const type.

type Device 

type Device struct {
	// REQUIRED; The properties of the StorSimple device.
	Properties *DeviceProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

Device - The StorSimple device.

func (Device) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Device.

func (*Device) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Device.

type DeviceConfigurationStatus 

type DeviceConfigurationStatus string

DeviceConfigurationStatus - The current configuration status of the device. 

const (
	DeviceConfigurationStatusComplete DeviceConfigurationStatus = "Complete"
	DeviceConfigurationStatusPending  DeviceConfigurationStatus = "Pending"
)

func PossibleDeviceConfigurationStatusValues 

func PossibleDeviceConfigurationStatusValues() []DeviceConfigurationStatus

PossibleDeviceConfigurationStatusValues returns the possible values for the DeviceConfigurationStatus const type.

type DeviceDetails 

type DeviceDetails struct {
	// The total number of endpoints that are currently on the device ( i.e. number of volumes).
	EndpointCount *int32

	// The total number of volume containers on the device.
	VolumeContainerCount *int32
}

DeviceDetails - The additional device details regarding the end point count and volume container count.

func (DeviceDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeviceDetails.

func (*DeviceDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeviceDetails.

type DeviceList 

type DeviceList struct {
	// REQUIRED; The value.
	Value []*Device
}

DeviceList - The collection of devices.

func (DeviceList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeviceList.

func (*DeviceList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeviceList.

type DevicePatch 

type DevicePatch struct {
	// REQUIRED; The properties of the device patch.
	Properties *DevicePatchProperties
}

DevicePatch - The device patch.

func (DevicePatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DevicePatch.

func (*DevicePatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DevicePatch.

type DevicePatchProperties 

type DevicePatchProperties struct {
	// Short description given for the device
	DeviceDescription *string
}

DevicePatchProperties - The properties of the device patch.

func (DevicePatchProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DevicePatchProperties.

func (*DevicePatchProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DevicePatchProperties.

type DeviceProperties 

type DeviceProperties struct {
	// REQUIRED; The UTC time at which the device was activated
	ActivationTime *time.Time

	// REQUIRED; The identifier of the active controller of the device.
	ActiveController *ControllerID

	// REQUIRED; The language culture setting on the device. For eg: "en-US"
	Culture *string

	// REQUIRED; The current configuration status of the device.
	DeviceConfigurationStatus *DeviceConfigurationStatus

	// REQUIRED; The device description.
	DeviceDescription *string

	// REQUIRED; The version number of the software running on the device.
	DeviceSoftwareVersion *string

	// REQUIRED; The type of the device.
	DeviceType *DeviceType

	// REQUIRED; The friendly name of the device.
	FriendlyName *string

	// REQUIRED; The device friendly software version.
	FriendlySoftwareVersion *string

	// REQUIRED; The device model.
	ModelDescription *string

	// REQUIRED; The serial number.
	SerialNumber *string

	// REQUIRED; The current status of the device.
	Status *DeviceStatus

	// REQUIRED; The target IQN.
	TargetIqn *string

	// The device agent group version.
	AgentGroupVersion *int32

	// The storage in bytes that is available locally on the device.
	AvailableLocalStorageInBytes *int64

	// The storage in bytes that is available on the device for tiered volumes.
	AvailableTieredStorageInBytes *int64

	// The additional device details regarding the end point count and volume container count.
	Details *DeviceDetails

	// The location of the virtual appliance.
	DeviceLocation *string

	// The friendly name of the software running on the device.
	FriendlySoftwareName *string

	// The number of network interface cards
	NetworkInterfaceCardCount *int32

	// The storage in bytes used for locally pinned volumes on the device (including additional local reservation).
	ProvisionedLocalStorageInBytes *int64

	// The storage in bytes that has been provisioned on the device for tiered volumes.
	ProvisionedTieredStorageInBytes *int64

	// Total capacity in bytes of tiered and locally pinned volumes on the device
	ProvisionedVolumeSizeInBytes *int64

	// The additional device details for the service data encryption key rollover.
	RolloverDetails *DeviceRolloverDetails

	// The total tiered storage available on the device in bytes.
	TotalTieredStorageInBytes *int64

	// The storage in bytes that is currently being used on the device, including both local and cloud.
	UsingStorageInBytes *int64

	// READ-ONLY; The virtual machine API type.
	VirtualMachineAPIType *VirtualMachineAPIType
}

DeviceProperties - The properties of the StorSimple device.

func (DeviceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeviceProperties.

func (*DeviceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeviceProperties.

type DeviceRolloverDetails 

type DeviceRolloverDetails struct {
	// The eligibility status of device for service data encryption key rollover.
	AuthorizationEligibility *AuthorizationEligibility

	// The authorization status of the device for service data encryption key rollover.
	AuthorizationStatus *AuthorizationStatus

	// The reason for inEligibility of device, in case it's not eligible for service data encryption key rollover.
	InEligibilityReason *InEligibilityCategory
}

DeviceRolloverDetails - The additional device details for the service data encryption key rollover.

func (DeviceRolloverDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeviceRolloverDetails.

func (*DeviceRolloverDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeviceRolloverDetails.

type DeviceSettingsClient 

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

DeviceSettingsClient contains the methods for the DeviceSettings group. Don't use this type directly, use NewDeviceSettingsClient() instead.

func NewDeviceSettingsClient 

func NewDeviceSettingsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DeviceSettingsClient, error)

NewDeviceSettingsClient creates a new instance of DeviceSettingsClient with the specified values.

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

func (*DeviceSettingsClient) BeginCreateOrUpdateAlertSettings 

func (client *DeviceSettingsClient) BeginCreateOrUpdateAlertSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, parameters AlertSettings, options *DeviceSettingsClientBeginCreateOrUpdateAlertSettingsOptions) (*runtime.Poller[DeviceSettingsClientCreateOrUpdateAlertSettingsResponse], error)

BeginCreateOrUpdateAlertSettings - Creates or updates the alert settings of the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The alert settings to be added or updated.
  • options - DeviceSettingsClientBeginCreateOrUpdateAlertSettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginCreateOrUpdateAlertSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsCreateOrUpdateAlertSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeviceSettingsClient().BeginCreateOrUpdateAlertSettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.AlertSettings{
		Properties: &armstorsimple8000series.AlertNotificationProperties{
			AdditionalRecipientEmailList: []*string{},
			AlertNotificationCulture:     to.Ptr("en-US"),
			EmailNotification:            to.Ptr(armstorsimple8000series.AlertEmailNotificationStatusEnabled),
			NotificationToServiceOwners:  to.Ptr(armstorsimple8000series.AlertEmailNotificationStatusEnabled),
		},
	}, 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.AlertSettings = armstorsimple8000series.AlertSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/alertSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/alertSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.AlertNotificationProperties{
	// 		AdditionalRecipientEmailList: []*string{
	// 		},
	// 		AlertNotificationCulture: to.Ptr("en-US"),
	// 		EmailNotification: to.Ptr(armstorsimple8000series.AlertEmailNotificationStatusEnabled),
	// 		NotificationToServiceOwners: to.Ptr(armstorsimple8000series.AlertEmailNotificationStatusEnabled),
	// 	},
	// }
}

Output:

func (*DeviceSettingsClient) BeginCreateOrUpdateTimeSettings 

func (client *DeviceSettingsClient) BeginCreateOrUpdateTimeSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, parameters TimeSettings, options *DeviceSettingsClientBeginCreateOrUpdateTimeSettingsOptions) (*runtime.Poller[DeviceSettingsClientCreateOrUpdateTimeSettingsResponse], error)

BeginCreateOrUpdateTimeSettings - Creates or updates the time settings of the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The time settings to be added or updated.
  • options - DeviceSettingsClientBeginCreateOrUpdateTimeSettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginCreateOrUpdateTimeSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsCreateOrUpdateTimeSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeviceSettingsClient().BeginCreateOrUpdateTimeSettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.TimeSettings{
		Properties: &armstorsimple8000series.TimeSettingsProperties{
			PrimaryTimeServer: to.Ptr("time.windows.com"),
			SecondaryTimeServer: []*string{
				to.Ptr("8.8.8.8")},
			TimeZone: to.Ptr("Pacific Standard Time"),
		},
	}, 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.TimeSettings = armstorsimple8000series.TimeSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/timeSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/timeSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.TimeSettingsProperties{
	// 		PrimaryTimeServer: to.Ptr("time.windows.com"),
	// 		SecondaryTimeServer: []*string{
	// 			to.Ptr("8.8.8.8")},
	// 			TimeZone: to.Ptr("Pacific Standard Time"),
	// 		},
	// 	}
}

Output:

func (*DeviceSettingsClient) BeginSyncRemotemanagementCertificate 

func (client *DeviceSettingsClient) BeginSyncRemotemanagementCertificate(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DeviceSettingsClientBeginSyncRemotemanagementCertificateOptions) (*runtime.Poller[DeviceSettingsClientSyncRemotemanagementCertificateResponse], error)

BeginSyncRemotemanagementCertificate - sync Remote management Certificate between appliance and Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DeviceSettingsClientBeginSyncRemotemanagementCertificateOptions contains the optional parameters for the DeviceSettingsClient.BeginSyncRemotemanagementCertificate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsSyncRemotemanagementCertificate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeviceSettingsClient().BeginSyncRemotemanagementCertificate(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*DeviceSettingsClient) BeginUpdateNetworkSettings 

func (client *DeviceSettingsClient) BeginUpdateNetworkSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, parameters NetworkSettingsPatch, options *DeviceSettingsClientBeginUpdateNetworkSettingsOptions) (*runtime.Poller[DeviceSettingsClientUpdateNetworkSettingsResponse], error)

BeginUpdateNetworkSettings - Updates the network settings on the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The network settings to be updated.
  • options - DeviceSettingsClientBeginUpdateNetworkSettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginUpdateNetworkSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsUpdateNetworkSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeviceSettingsClient().BeginUpdateNetworkSettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.NetworkSettingsPatch{
		Properties: &armstorsimple8000series.NetworkSettingsPatchProperties{
			DNSSettings: &armstorsimple8000series.DNSSettings{
				PrimaryDNSServer: to.Ptr("10.171.65.60"),
				SecondaryDNSServers: []*string{
					to.Ptr("8.8.8.8")},
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.NetworkSettings = armstorsimple8000series.NetworkSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/encryptionSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/encryptionSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.NetworkSettingsProperties{
	// 	},
	// }
}

Output:

func (*DeviceSettingsClient) BeginUpdateSecuritySettings 

func (client *DeviceSettingsClient) BeginUpdateSecuritySettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, parameters SecuritySettingsPatch, options *DeviceSettingsClientBeginUpdateSecuritySettingsOptions) (*runtime.Poller[DeviceSettingsClientUpdateSecuritySettingsResponse], error)

BeginUpdateSecuritySettings - Patch Security properties of the specified device name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The security settings properties to be patched.
  • options - DeviceSettingsClientBeginUpdateSecuritySettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginUpdateSecuritySettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsUpdateSecuritySettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeviceSettingsClient().BeginUpdateSecuritySettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.SecuritySettingsPatch{
		Properties: &armstorsimple8000series.SecuritySettingsPatchProperties{
			ChapSettings: &armstorsimple8000series.ChapSettings{
				InitiatorSecret: &armstorsimple8000series.AsymmetricEncryptedSecret{
					EncryptionAlgorithm:      to.Ptr(armstorsimple8000series.EncryptionAlgorithmRSAESPKCS1V15),
					EncryptionCertThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
					Value:                    to.Ptr("V/uVfWk5OcXfMC0HvUV89o9+cmF636jBnqhFM1pD/zHhmh8Z1KB5/LhVV3T53uGjIlKL3wjhwg+9NIQrIbYuKhl/r8jSftSSH+WqUnQHTRDWazjPAeMu6ozrL5RYzP1h5mgw7XtidZPaaV9ae/uF1KQPkK6TIARaOTdr8I/BLWUg7WdDrfARNYHnW6ezXek1M9Qhv1sL9fZY+JrGB58LF6D2aC2Xjed4K4Jk6v2T1ieneNV27uIdnt21TajuM7w90UlRiVZJZtq/KdEUfqI28C7VoUdcXluAwzR95Ho8hmyIJDqeW3/Wxymdjv+Rctwqtmcka9i2G85Hj8SVV3g4kA=="),
				},
				InitiatorUser: to.Ptr("test-initiator-user"),
				TargetSecret: &armstorsimple8000series.AsymmetricEncryptedSecret{
					EncryptionAlgorithm:      to.Ptr(armstorsimple8000series.EncryptionAlgorithmRSAESPKCS1V15),
					EncryptionCertThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
					Value:                    to.Ptr("OTR4uwVpy+pf0zthnCIAUXurC8NdSh8RpRG5GWL9TSv4WtkVmpeU/U2A4vjkrchfQOzI1x+uooWikWW9txwwQOM+/N3NG44+/dlHoaEe7AxjmItCKhNj8K2RM6D1mb45wicbF/M4uanuXnGXuT+JmZ+1Lcy2k1GXsk67ejplz2K08h37B+oIW85qMUHLdKuuQlAA/fFS+q6qMti3j2Q8Fr+Sh4U76/2AZVkKRtFeqPB1QhC12dFx6TFoZJkMFzdQz4WNvWVelIK2McKNnOiH0/Z5lAXC7164uzReAoTEfqoNU7qqqRrHhsdwWPu6jbeUn8BQnr7A/X6NWvgeax+HGA=="),
				},
				TargetUser: to.Ptr("test-target-user"),
			},
			DeviceAdminPassword: &armstorsimple8000series.AsymmetricEncryptedSecret{
				EncryptionAlgorithm:      to.Ptr(armstorsimple8000series.EncryptionAlgorithmRSAESPKCS1V15),
				EncryptionCertThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
				Value:                    to.Ptr("<value>"),
			},
			RemoteManagementSettings: &armstorsimple8000series.RemoteManagementSettingsPatch{
				RemoteManagementMode: to.Ptr(armstorsimple8000series.RemoteManagementModeConfigurationHTTPSAndHTTPEnabled),
			},
			SnapshotPassword: &armstorsimple8000series.AsymmetricEncryptedSecret{
				EncryptionAlgorithm:      to.Ptr(armstorsimple8000series.EncryptionAlgorithmRSAESPKCS1V15),
				EncryptionCertThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
				Value:                    to.Ptr("<value>"),
			},
		},
	}, 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.SecuritySettings = armstorsimple8000series.SecuritySettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/securitySettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/securitySettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.SecuritySettingsProperties{
	// 		ChapSettings: &armstorsimple8000series.ChapSettings{
	// 			InitiatorUser: to.Ptr("test-initiator-user"),
	// 			TargetUser: to.Ptr("test-target-user"),
	// 		},
	// 		RemoteManagementSettings: &armstorsimple8000series.RemoteManagementSettings{
	// 			RemoteManagementCertificate: to.Ptr(""),
	// 			RemoteManagementMode: to.Ptr(armstorsimple8000series.RemoteManagementModeConfigurationHTTPSAndHTTPEnabled),
	// 		},
	// 	},
	// }
}

Output:

func (*DeviceSettingsClient) GetAlertSettings 

func (client *DeviceSettingsClient) GetAlertSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DeviceSettingsClientGetAlertSettingsOptions) (DeviceSettingsClientGetAlertSettingsResponse, error)

GetAlertSettings - Gets the alert settings of the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DeviceSettingsClientGetAlertSettingsOptions contains the optional parameters for the DeviceSettingsClient.GetAlertSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsGetAlertSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDeviceSettingsClient().GetAlertSettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.AlertSettings = armstorsimple8000series.AlertSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/alertSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/alertSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.AlertNotificationProperties{
	// 		AdditionalRecipientEmailList: []*string{
	// 		},
	// 		AlertNotificationCulture: to.Ptr("en-US"),
	// 		EmailNotification: to.Ptr(armstorsimple8000series.AlertEmailNotificationStatusEnabled),
	// 		NotificationToServiceOwners: to.Ptr(armstorsimple8000series.AlertEmailNotificationStatusEnabled),
	// 	},
	// }
}

Output:

func (*DeviceSettingsClient) GetNetworkSettings 

func (client *DeviceSettingsClient) GetNetworkSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DeviceSettingsClientGetNetworkSettingsOptions) (DeviceSettingsClientGetNetworkSettingsResponse, error)

GetNetworkSettings - Gets the network settings of the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DeviceSettingsClientGetNetworkSettingsOptions contains the optional parameters for the DeviceSettingsClient.GetNetworkSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsGetNetworkSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDeviceSettingsClient().GetNetworkSettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.NetworkSettings = armstorsimple8000series.NetworkSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/networkSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/networkSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.NetworkSettingsProperties{
	// 		DNSSettings: &armstorsimple8000series.DNSSettings{
	// 			PrimaryDNSServer: to.Ptr("10.171.65.60"),
	// 			SecondaryDNSServers: []*string{
	// 				to.Ptr("8.8.8.8")},
	// 				SecondaryIPv6DNSServers: []*string{
	// 				},
	// 			},
	// 			NetworkAdapters: &armstorsimple8000series.NetworkAdapterList{
	// 				Value: []*armstorsimple8000series.NetworkAdapters{
	// 					{
	// 						InterfaceID: to.Ptr(armstorsimple8000series.NetInterfaceIDData0),
	// 						IsDefault: to.Ptr(true),
	// 						IscsiAndCloudStatus: to.Ptr(armstorsimple8000series.ISCSIAndCloudStatusIscsiAndCloudEnabled),
	// 						Mode: to.Ptr(armstorsimple8000series.NetworkModeIPV4),
	// 						NetInterfaceStatus: to.Ptr(armstorsimple8000series.NetInterfaceStatusEnabled),
	// 						NicIPv4Settings: &armstorsimple8000series.NicIPv4{
	// 							Controller0IPv4Address: to.Ptr("10.168.241.143"),
	// 							Controller1IPv4Address: to.Ptr("10.168.241.121"),
	// 							IPv4Address: to.Ptr("10.168.241.187"),
	// 							IPv4Gateway: to.Ptr("10.168.241.1"),
	// 							IPv4Netmask: to.Ptr("255.255.252.0"),
	// 						},
	// 						NicIPv6Settings: &armstorsimple8000series.NicIPv6{
	// 							Controller0IPv6Address: to.Ptr(""),
	// 							Controller1IPv6Address: to.Ptr(""),
	// 							IPv6Address: to.Ptr(""),
	// 							IPv6Gateway: to.Ptr(""),
	// 							IPv6Prefix: to.Ptr(""),
	// 						},
	// 						Speed: to.Ptr[int64](1000000000),
	// 				}},
	// 			},
	// 			WebproxySettings: &armstorsimple8000series.WebproxySettings{
	// 				Authentication: to.Ptr(armstorsimple8000series.AuthenticationTypeNone),
	// 				ConnectionURI: to.Ptr(""),
	// 				Username: to.Ptr(""),
	// 			},
	// 		},
	// 	}
}

Output:

func (*DeviceSettingsClient) GetSecuritySettings 

func (client *DeviceSettingsClient) GetSecuritySettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DeviceSettingsClientGetSecuritySettingsOptions) (DeviceSettingsClientGetSecuritySettingsResponse, error)

GetSecuritySettings - Returns the Security properties of the specified device name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DeviceSettingsClientGetSecuritySettingsOptions contains the optional parameters for the DeviceSettingsClient.GetSecuritySettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsGetSecuritySettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDeviceSettingsClient().GetSecuritySettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.SecuritySettings = armstorsimple8000series.SecuritySettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/securitySettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/securitySettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.SecuritySettingsProperties{
	// 		ChapSettings: &armstorsimple8000series.ChapSettings{
	// 			InitiatorUser: to.Ptr("test-initiator-user"),
	// 			TargetUser: to.Ptr("test-target-user"),
	// 		},
	// 		RemoteManagementSettings: &armstorsimple8000series.RemoteManagementSettings{
	// 			RemoteManagementCertificate: to.Ptr("-----BEGIN CERTIFICATE-----\r\nMIIDfjCCAmagAwIBAgIQR9UA510Lj4FPZGVXI0oyQDANBgkqhkiG9w0BAQUFADBWMSAwHgYDVQQL\r\nDBdIY3NSZW1vdGVNYW5hZ2VtZW50Q2VydDEeMBwGA1UECgwVTWljcm9zb2Z0IENvcnBvcmF0aW9u\r\nMRIwEAYDVQQDDAkxMjM0NTY3ODkwIBcNMTcwNjA3MTExMDUzWhgPMjExNjA2MDcxMTEwNTNaMFYx\r\nIDAeBgNVBAsMF0hjc1JlbW90ZU1hbmFnZW1lbnRDZXJ0MR4wHAYDVQQKDBVNaWNyb3NvZnQgQ29y\r\ncG9yYXRpb24xEjAQBgNVBAMMCTEyMzQ1Njc4OTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\r\nggEBAMp25cGMmEJdwur4y2Qgs9AKimTYGHdL5R9o2rcf+rGpgLC2wMY4qWsz3Ub4EWDwgT26rCiX\r\nv/24FK3xGB0OLxzTC3EbBJ7g7uCkapAKp/cFcmr+uBZiBhXe3hNnkeP8H2IfXNRSKa54XUMSqoFi\r\naavSBstS8FMuDMKopIVe6o4j+oDZBJGbb4a2anxuSyBM3cNhFTaOCLnfKynREC4sbbBL6enaFs0i\r\nRdIobT1FDSb2sLSUz4ONa3ZN7Os25UFvj1OcWeDjT1vJKcjx+u5owILvifRGoGbPETtCjwJ306+7\r\nihl+0GQ7teD2+O1h/Q7qdBm3gQAX9ZTsQAoiRYyJ14UCAwEAAaNGMEQwEwYDVR0lBAwwCgYIKwYB\r\nBQUHAwEwHQYDVR0OBBYEFJNK6cTqsGCcZkjP1q0LF53B2+G1MA4GA1UdDwEB/wQEAwIFIDANBgkq\r\nhkiG9w0BAQUFAAOCAQEAl+2ApGz9hpt6+sND+Q3TGczBqh2BSprgK//KwPdWthSLnxPf7f06MITN\r\ng1sTxFlbrFb46Y0UPN5YKTMb7wxRd+Nqrz6l7X4kp6IR+2sMX1ydkWyJ6HZrosc96fkFvFUt9B+J\r\n25gb9YVRotNUeborkznDFW6VeeS0kxJVps5r3fcuhz2vOPW1q/U0UWNV+LnrzRT+7MauUTYyLe0q\r\nuobmnD8NC2HhZcJ04xYhCKOJQ/NNJyaURwGJ2TZSYwS0HOnQViZp/SipjhyOOwwB6h0W62ElOovN\r\nAxVgTBEQjbG0jsMOm079hLUKuIBYmH4HJDmF3QKml0er1NcXeieATPLOWQ==\r\n-----END CERTIFICATE-----\r\n"),
	// 			RemoteManagementMode: to.Ptr(armstorsimple8000series.RemoteManagementModeConfigurationHTTPSAndHTTPEnabled),
	// 		},
	// 	},
	// }
}

Output:

func (*DeviceSettingsClient) GetTimeSettings 

func (client *DeviceSettingsClient) GetTimeSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DeviceSettingsClientGetTimeSettingsOptions) (DeviceSettingsClientGetTimeSettingsResponse, error)

GetTimeSettings - Gets the time settings of the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DeviceSettingsClientGetTimeSettingsOptions contains the optional parameters for the DeviceSettingsClient.GetTimeSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DeviceSettingsGetTimeSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDeviceSettingsClient().GetTimeSettings(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.TimeSettings = armstorsimple8000series.TimeSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/timeSettings"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/timeSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.TimeSettingsProperties{
	// 		PrimaryTimeServer: to.Ptr("time.windows.com"),
	// 		SecondaryTimeServer: []*string{
	// 			to.Ptr("8.8.8.8")},
	// 			TimeZone: to.Ptr("Pacific Standard Time"),
	// 		},
	// 	}
}

Output:

type DeviceSettingsClientBeginCreateOrUpdateAlertSettingsOptions 

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

DeviceSettingsClientBeginCreateOrUpdateAlertSettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginCreateOrUpdateAlertSettings method.

type DeviceSettingsClientBeginCreateOrUpdateTimeSettingsOptions 

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

DeviceSettingsClientBeginCreateOrUpdateTimeSettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginCreateOrUpdateTimeSettings method.

type DeviceSettingsClientBeginSyncRemotemanagementCertificateOptions 

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

DeviceSettingsClientBeginSyncRemotemanagementCertificateOptions contains the optional parameters for the DeviceSettingsClient.BeginSyncRemotemanagementCertificate method.

type DeviceSettingsClientBeginUpdateNetworkSettingsOptions 

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

DeviceSettingsClientBeginUpdateNetworkSettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginUpdateNetworkSettings method.

type DeviceSettingsClientBeginUpdateSecuritySettingsOptions 

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

DeviceSettingsClientBeginUpdateSecuritySettingsOptions contains the optional parameters for the DeviceSettingsClient.BeginUpdateSecuritySettings method.

type DeviceSettingsClientCreateOrUpdateAlertSettingsResponse 

type DeviceSettingsClientCreateOrUpdateAlertSettingsResponse struct {
	// The alert settings.
	AlertSettings
}

DeviceSettingsClientCreateOrUpdateAlertSettingsResponse contains the response from method DeviceSettingsClient.BeginCreateOrUpdateAlertSettings.

type DeviceSettingsClientCreateOrUpdateTimeSettingsResponse 

type DeviceSettingsClientCreateOrUpdateTimeSettingsResponse struct {
	// The time settings of a device.
	TimeSettings
}

DeviceSettingsClientCreateOrUpdateTimeSettingsResponse contains the response from method DeviceSettingsClient.BeginCreateOrUpdateTimeSettings.

type DeviceSettingsClientGetAlertSettingsOptions 

type DeviceSettingsClientGetAlertSettingsOptions struct {
}

DeviceSettingsClientGetAlertSettingsOptions contains the optional parameters for the DeviceSettingsClient.GetAlertSettings method.

type DeviceSettingsClientGetAlertSettingsResponse 

type DeviceSettingsClientGetAlertSettingsResponse struct {
	// The alert settings.
	AlertSettings
}

DeviceSettingsClientGetAlertSettingsResponse contains the response from method DeviceSettingsClient.GetAlertSettings.

type DeviceSettingsClientGetNetworkSettingsOptions 

type DeviceSettingsClientGetNetworkSettingsOptions struct {
}

DeviceSettingsClientGetNetworkSettingsOptions contains the optional parameters for the DeviceSettingsClient.GetNetworkSettings method.

type DeviceSettingsClientGetNetworkSettingsResponse 

type DeviceSettingsClientGetNetworkSettingsResponse struct {
	// Represents the network settings of a device.
	NetworkSettings
}

DeviceSettingsClientGetNetworkSettingsResponse contains the response from method DeviceSettingsClient.GetNetworkSettings.

type DeviceSettingsClientGetSecuritySettingsOptions 

type DeviceSettingsClientGetSecuritySettingsOptions struct {
}

DeviceSettingsClientGetSecuritySettingsOptions contains the optional parameters for the DeviceSettingsClient.GetSecuritySettings method.

type DeviceSettingsClientGetSecuritySettingsResponse 

type DeviceSettingsClientGetSecuritySettingsResponse struct {
	// The security settings of a device.
	SecuritySettings
}

DeviceSettingsClientGetSecuritySettingsResponse contains the response from method DeviceSettingsClient.GetSecuritySettings.

type DeviceSettingsClientGetTimeSettingsOptions 

type DeviceSettingsClientGetTimeSettingsOptions struct {
}

DeviceSettingsClientGetTimeSettingsOptions contains the optional parameters for the DeviceSettingsClient.GetTimeSettings method.

type DeviceSettingsClientGetTimeSettingsResponse 

type DeviceSettingsClientGetTimeSettingsResponse struct {
	// The time settings of a device.
	TimeSettings
}

DeviceSettingsClientGetTimeSettingsResponse contains the response from method DeviceSettingsClient.GetTimeSettings.

type DeviceSettingsClientSyncRemotemanagementCertificateResponse 

type DeviceSettingsClientSyncRemotemanagementCertificateResponse struct {
}

DeviceSettingsClientSyncRemotemanagementCertificateResponse contains the response from method DeviceSettingsClient.BeginSyncRemotemanagementCertificate.

type DeviceSettingsClientUpdateNetworkSettingsResponse 

type DeviceSettingsClientUpdateNetworkSettingsResponse struct {
	// Represents the network settings of a device.
	NetworkSettings
}

DeviceSettingsClientUpdateNetworkSettingsResponse contains the response from method DeviceSettingsClient.BeginUpdateNetworkSettings.

type DeviceSettingsClientUpdateSecuritySettingsResponse 

type DeviceSettingsClientUpdateSecuritySettingsResponse struct {
	// The security settings of a device.
	SecuritySettings
}

DeviceSettingsClientUpdateSecuritySettingsResponse contains the response from method DeviceSettingsClient.BeginUpdateSecuritySettings.

type DeviceStatus 

type DeviceStatus string

DeviceStatus - The current status of the device. 

const (
	DeviceStatusCreating          DeviceStatus = "Creating"
	DeviceStatusDeactivated       DeviceStatus = "Deactivated"
	DeviceStatusDeactivating      DeviceStatus = "Deactivating"
	DeviceStatusDeleted           DeviceStatus = "Deleted"
	DeviceStatusMaintenanceMode   DeviceStatus = "MaintenanceMode"
	DeviceStatusOffline           DeviceStatus = "Offline"
	DeviceStatusOnline            DeviceStatus = "Online"
	DeviceStatusProvisioning      DeviceStatus = "Provisioning"
	DeviceStatusReadyToSetup      DeviceStatus = "ReadyToSetup"
	DeviceStatusRequiresAttention DeviceStatus = "RequiresAttention"
	DeviceStatusUnknown           DeviceStatus = "Unknown"
)

func PossibleDeviceStatusValues 

func PossibleDeviceStatusValues() []DeviceStatus

PossibleDeviceStatusValues returns the possible values for the DeviceStatus const type.

type DeviceType 

type DeviceType string

DeviceType - The type of the device. 

const (
	DeviceTypeInvalid                     DeviceType = "Invalid"
	DeviceTypeSeries8000PhysicalAppliance DeviceType = "Series8000PhysicalAppliance"
	DeviceTypeSeries8000VirtualAppliance  DeviceType = "Series8000VirtualAppliance"
)

func PossibleDeviceTypeValues 

func PossibleDeviceTypeValues() []DeviceType

PossibleDeviceTypeValues returns the possible values for the DeviceType const type.

type DevicesClient 

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

DevicesClient contains the methods for the Devices group. Don't use this type directly, use NewDevicesClient() instead.

func NewDevicesClient 

func NewDevicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DevicesClient, error)

NewDevicesClient creates a new instance of DevicesClient with the specified values.

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

func (*DevicesClient) AuthorizeForServiceEncryptionKeyRollover 

func (client *DevicesClient) AuthorizeForServiceEncryptionKeyRollover(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientAuthorizeForServiceEncryptionKeyRolloverOptions) (DevicesClientAuthorizeForServiceEncryptionKeyRolloverResponse, error)

AuthorizeForServiceEncryptionKeyRollover - Authorizes the specified device for service data encryption key rollover. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientAuthorizeForServiceEncryptionKeyRolloverOptions contains the optional parameters for the DevicesClient.AuthorizeForServiceEncryptionKeyRollover method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesAuthorizeForServiceEncryptionKeyRollover.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDevicesClient().AuthorizeForServiceEncryptionKeyRollover(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DevicesClient) BeginConfigure 

func (client *DevicesClient) BeginConfigure(ctx context.Context, resourceGroupName string, managerName string, parameters ConfigureDeviceRequest, options *DevicesClientBeginConfigureOptions) (*runtime.Poller[DevicesClientConfigureResponse], error)

BeginConfigure - Complete minimal setup before using the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The minimal properties to configure a device.
  • options - DevicesClientBeginConfigureOptions contains the optional parameters for the DevicesClient.BeginConfigure method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesConfigure.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDevicesClient().BeginConfigure(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.ConfigureDeviceRequest{
		Properties: &armstorsimple8000series.ConfigureDeviceRequestProperties{
			CurrentDeviceName: to.Ptr("Device001ForSDKTest"),
			FriendlyName:      to.Ptr("Device001ForSDKTest"),
			NetworkInterfaceData0Settings: &armstorsimple8000series.NetworkInterfaceData0Settings{
				ControllerOneIP:  to.Ptr("10.168.220.228"),
				ControllerZeroIP: to.Ptr("10.168.220.227"),
			},
			TimeZone: to.Ptr("Pacific Standard Time"),
		},
	}, 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 (*DevicesClient) BeginDeactivate 

func (client *DevicesClient) BeginDeactivate(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientBeginDeactivateOptions) (*runtime.Poller[DevicesClientDeactivateResponse], error)

BeginDeactivate - Deactivates the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientBeginDeactivateOptions contains the optional parameters for the DevicesClient.BeginDeactivate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesDeactivate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDevicesClient().BeginDeactivate(ctx, "Device001ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*DevicesClient) BeginDelete 

func (client *DevicesClient) BeginDelete(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientBeginDeleteOptions) (*runtime.Poller[DevicesClientDeleteResponse], error)

BeginDelete - Deletes the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientBeginDeleteOptions contains the optional parameters for the DevicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDevicesClient().BeginDelete(ctx, "Device001ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*DevicesClient) BeginFailover 

func (client *DevicesClient) BeginFailover(ctx context.Context, sourceDeviceName string, resourceGroupName string, managerName string, parameters FailoverRequest, options *DevicesClientBeginFailoverOptions) (*runtime.Poller[DevicesClientFailoverResponse], error)

BeginFailover - Failovers a set of volume containers from a specified source device to a target device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • sourceDeviceName - The source device name on which failover is performed.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - FailoverRequest containing the source device and the list of volume containers to be failed over.
  • options - DevicesClientBeginFailoverOptions contains the optional parameters for the DevicesClient.BeginFailover method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesFailover.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDevicesClient().BeginFailover(ctx, "Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.FailoverRequest{
		TargetDeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk"),
		VolumeContainers: []*string{
			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcforsdktest")},
	}, 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 (*DevicesClient) BeginInstallUpdates 

func (client *DevicesClient) BeginInstallUpdates(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientBeginInstallUpdatesOptions) (*runtime.Poller[DevicesClientInstallUpdatesResponse], error)

BeginInstallUpdates - Downloads and installs the updates on the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientBeginInstallUpdatesOptions contains the optional parameters for the DevicesClient.BeginInstallUpdates method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesInstallUpdates.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDevicesClient().BeginInstallUpdates(ctx, "sugattdeviceforSDK", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*DevicesClient) BeginScanForUpdates 

func (client *DevicesClient) BeginScanForUpdates(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientBeginScanForUpdatesOptions) (*runtime.Poller[DevicesClientScanForUpdatesResponse], error)

BeginScanForUpdates - Scans for updates on the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientBeginScanForUpdatesOptions contains the optional parameters for the DevicesClient.BeginScanForUpdates method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesScanForUpdates.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDevicesClient().BeginScanForUpdates(ctx, "sugattdeviceforSDK", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*DevicesClient) Get 

func (client *DevicesClient) Get(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientGetOptions) (DevicesClientGetResponse, error)

Get - Returns the properties of the specified device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientGetOptions contains the optional parameters for the DevicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDevicesClient().Get(ctx, "Device001ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.DevicesClientGetOptions{Expand: to.Ptr("details")})
	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.Device = armstorsimple8000series.Device{
	// 	Name: to.Ptr("Device001ForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device001ForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.DeviceProperties{
	// 		ActivationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-22T09:36:20.963Z"); return t}()),
	// 		ActiveController: to.Ptr(armstorsimple8000series.ControllerIDController0),
	// 		AgentGroupVersion: to.Ptr[int32](7),
	// 		AvailableLocalStorageInBytes: to.Ptr[int64](43980464128),
	// 		AvailableTieredStorageInBytes: to.Ptr[int64](1099511627776),
	// 		Culture: to.Ptr("en-US"),
	// 		DeviceConfigurationStatus: to.Ptr(armstorsimple8000series.DeviceConfigurationStatusComplete),
	// 		DeviceDescription: to.Ptr("updated device description"),
	// 		DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
	// 		DeviceType: to.Ptr(armstorsimple8000series.DeviceTypeSeries8000PhysicalAppliance),
	// 		FriendlyName: to.Ptr("Device001ForSDKTest"),
	// 		FriendlySoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
	// 		ModelDescription: to.Ptr("100"),
	// 		NetworkInterfaceCardCount: to.Ptr[int32](6),
	// 		ProvisionedLocalStorageInBytes: to.Ptr[int64](0),
	// 		ProvisionedTieredStorageInBytes: to.Ptr[int64](0),
	// 		ProvisionedVolumeSizeInBytes: to.Ptr[int64](0),
	// 		SerialNumber: to.Ptr("123456789"),
	// 		Status: to.Ptr(armstorsimple8000series.DeviceStatusOnline),
	// 		TargetIqn: to.Ptr("iqn.1991-05.com.microsoft:storsimple100-123456789-target"),
	// 		TotalTieredStorageInBytes: to.Ptr[int64](1099511627776),
	// 		UsingStorageInBytes: to.Ptr[int64](0),
	// 		Details: &armstorsimple8000series.DeviceDetails{
	// 			EndpointCount: to.Ptr[int32](0),
	// 			VolumeContainerCount: to.Ptr[int32](0),
	// 		},
	// 	},
	// }
}

Output:

func (*DevicesClient) GetUpdateSummary 

func (client *DevicesClient) GetUpdateSummary(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *DevicesClientGetUpdateSummaryOptions) (DevicesClientGetUpdateSummaryResponse, error)

GetUpdateSummary - Returns the update summary of the specified device name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientGetUpdateSummaryOptions contains the optional parameters for the DevicesClient.GetUpdateSummary method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesGetUpdateSummary.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDevicesClient().GetUpdateSummary(ctx, "sugattdeviceforSDK", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.Updates = armstorsimple8000series.Updates{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/updateSummary"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/sugattdeviceforSDK/updateSummary/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.UpdatesProperties{
	// 		IsUpdateInProgress: to.Ptr(false),
	// 		LastUpdatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-14T09:07:39.184Z"); return t}()),
	// 		MaintenanceModeUpdatesAvailable: to.Ptr(false),
	// 		RegularUpdatesAvailable: to.Ptr(true),
	// 	},
	// }
}

Output:

func (*DevicesClient) NewListByManagerPager 

func (client *DevicesClient) NewListByManagerPager(resourceGroupName string, managerName string, options *DevicesClientListByManagerOptions) *runtime.Pager[DevicesClientListByManagerResponse]

NewListByManagerPager - Returns the list of devices for the specified manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientListByManagerOptions contains the optional parameters for the DevicesClient.NewListByManagerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesListByManager.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDevicesClient().NewListByManagerPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.DevicesClientListByManagerOptions{Expand: 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.DeviceList = armstorsimple8000series.DeviceList{
		// 	Value: []*armstorsimple8000series.Device{
		// 		{
		// 			Name: to.Ptr("sugattdeviceforSDK"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/sugattdeviceforSDK"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.DeviceProperties{
		// 				ActivationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-14T07:01:51.896Z"); return t}()),
		// 				ActiveController: to.Ptr(armstorsimple8000series.ControllerIDController0),
		// 				AgentGroupVersion: to.Ptr[int32](7),
		// 				AvailableLocalStorageInBytes: to.Ptr[int64](43980464128),
		// 				AvailableTieredStorageInBytes: to.Ptr[int64](1099511627776),
		// 				Culture: to.Ptr("en-US"),
		// 				DeviceConfigurationStatus: to.Ptr(armstorsimple8000series.DeviceConfigurationStatusComplete),
		// 				DeviceDescription: to.Ptr("Device for SDK testing."),
		// 				DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
		// 				DeviceType: to.Ptr(armstorsimple8000series.DeviceTypeSeries8000PhysicalAppliance),
		// 				FriendlyName: to.Ptr("sugattdeviceforSDK"),
		// 				FriendlySoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
		// 				ModelDescription: to.Ptr("100"),
		// 				NetworkInterfaceCardCount: to.Ptr[int32](6),
		// 				ProvisionedLocalStorageInBytes: to.Ptr[int64](0),
		// 				ProvisionedTieredStorageInBytes: to.Ptr[int64](0),
		// 				ProvisionedVolumeSizeInBytes: to.Ptr[int64](0),
		// 				SerialNumber: to.Ptr("123456789"),
		// 				Status: to.Ptr(armstorsimple8000series.DeviceStatusOffline),
		// 				TargetIqn: to.Ptr("iqn.1991-05.com.microsoft:storsimple100-123456789-target"),
		// 				TotalTieredStorageInBytes: to.Ptr[int64](1099511627776),
		// 				UsingStorageInBytes: to.Ptr[int64](0),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("jemdeviceforsdk"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.DeviceProperties{
		// 				ActivationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-13T05:03:25.868Z"); return t}()),
		// 				ActiveController: to.Ptr(armstorsimple8000series.ControllerIDController0),
		// 				AgentGroupVersion: to.Ptr[int32](7),
		// 				AvailableLocalStorageInBytes: to.Ptr[int64](43765715760),
		// 				AvailableTieredStorageInBytes: to.Ptr[int64](1094142918656),
		// 				Culture: to.Ptr("en-US"),
		// 				DeviceConfigurationStatus: to.Ptr(armstorsimple8000series.DeviceConfigurationStatusComplete),
		// 				DeviceDescription: to.Ptr("Device for SDK testing."),
		// 				DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
		// 				DeviceType: to.Ptr(armstorsimple8000series.DeviceTypeSeries8000PhysicalAppliance),
		// 				FriendlyName: to.Ptr("jemdeviceforsdk"),
		// 				FriendlySoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
		// 				ModelDescription: to.Ptr("100"),
		// 				NetworkInterfaceCardCount: to.Ptr[int32](6),
		// 				ProvisionedLocalStorageInBytes: to.Ptr[int64](0),
		// 				ProvisionedTieredStorageInBytes: to.Ptr[int64](5368709120),
		// 				ProvisionedVolumeSizeInBytes: to.Ptr[int64](5368709120),
		// 				SerialNumber: to.Ptr("123456789"),
		// 				Status: to.Ptr(armstorsimple8000series.DeviceStatusOnline),
		// 				TargetIqn: to.Ptr("Test-Target-IQN"),
		// 				TotalTieredStorageInBytes: to.Ptr[int64](1099511627776),
		// 				UsingStorageInBytes: to.Ptr[int64](0),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Device05ForSDKTest"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.DeviceProperties{
		// 				ActivationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-07T18:28:31.661Z"); return t}()),
		// 				ActiveController: to.Ptr(armstorsimple8000series.ControllerIDController0),
		// 				AgentGroupVersion: to.Ptr[int32](7),
		// 				AvailableLocalStorageInBytes: to.Ptr[int64](42262477184),
		// 				AvailableTieredStorageInBytes: to.Ptr[int64](1056561954816),
		// 				Culture: to.Ptr("en-US"),
		// 				DeviceConfigurationStatus: to.Ptr(armstorsimple8000series.DeviceConfigurationStatusComplete),
		// 				DeviceDescription: to.Ptr("Device for SDK testing."),
		// 				DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
		// 				DeviceType: to.Ptr(armstorsimple8000series.DeviceTypeSeries8000PhysicalAppliance),
		// 				FriendlyName: to.Ptr("Device05ForSDKTest"),
		// 				FriendlySoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
		// 				ModelDescription: to.Ptr("100"),
		// 				NetworkInterfaceCardCount: to.Ptr[int32](6),
		// 				ProvisionedLocalStorageInBytes: to.Ptr[int64](0),
		// 				ProvisionedTieredStorageInBytes: to.Ptr[int64](42949672960),
		// 				ProvisionedVolumeSizeInBytes: to.Ptr[int64](42949672960),
		// 				SerialNumber: to.Ptr("123456789"),
		// 				Status: to.Ptr(armstorsimple8000series.DeviceStatusOnline),
		// 				TargetIqn: to.Ptr("iqn.1991-05.com.microsoft:storsimple100-123456789-target"),
		// 				TotalTieredStorageInBytes: to.Ptr[int64](1099511627776),
		// 				UsingStorageInBytes: to.Ptr[int64](0),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*DevicesClient) NewListFailoverSetsPager 

func (client *DevicesClient) NewListFailoverSetsPager(deviceName string, resourceGroupName string, managerName string, options *DevicesClientListFailoverSetsOptions) *runtime.Pager[DevicesClientListFailoverSetsResponse]

NewListFailoverSetsPager - Returns all failover sets for a given device and their eligibility for participating in a failover. A failover set refers to a set of volume containers that need to be failed-over as a single unit to maintain data integrity.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientListFailoverSetsOptions contains the optional parameters for the DevicesClient.NewListFailoverSetsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesListFailoverSets.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDevicesClient().NewListFailoverSetsPager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.FailoverSetsList = armstorsimple8000series.FailoverSetsList{
		// 	Value: []*armstorsimple8000series.FailoverSet{
		// 		{
		// 			EligibilityResult: &armstorsimple8000series.FailoverSetEligibilityResult{
		// 				IsEligibleForFailover: to.Ptr(true),
		// 			},
		// 			VolumeContainers: []*armstorsimple8000series.VolumeContainerFailoverMetadata{
		// 				{
		// 					VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcforsdktest"),
		// 					Volumes: []*armstorsimple8000series.VolumeFailoverMetadata{
		// 						{
		// 							BackupCreatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-20T06:30:03.794Z"); return t}()),
		// 							BackupElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/964d5a65-5294-4707-9c71-becb8850ea12/elements/2553386f-f39e-4223-b9fa-319adc5630fe_0000000000000000"),
		// 							BackupID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/964d5a65-5294-4707-9c71-becb8850ea12"),
		// 							BackupPolicyID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/jembkpolicy"),
		// 							SizeInBytes: to.Ptr[int64](5368709120),
		// 							VolumeID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcforsdktest/volumes/jemVol1"),
		// 							VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 					}},
		// 			}},
		// 		},
		// 		{
		// 			EligibilityResult: &armstorsimple8000series.FailoverSetEligibilityResult{
		// 				IsEligibleForFailover: to.Ptr(true),
		// 			},
		// 			VolumeContainers: []*armstorsimple8000series.VolumeContainerFailoverMetadata{
		// 				{
		// 					VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 					Volumes: []*armstorsimple8000series.VolumeFailoverMetadata{
		// 						{
		// 							BackupCreatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-10T10:29:37.215Z"); return t}()),
		// 							BackupElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0874889e-f2a3-42d2-a643-f378fc199688/elements/5baae396-46f1-46a0-bc25-d8e2fcada7fa_0000000000000000"),
		// 							BackupID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0874889e-f2a3-42d2-a643-f378fc199688"),
		// 							BackupPolicyID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest429326237"),
		// 							SizeInBytes: to.Ptr[int64](10737418240),
		// 							VolumeID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/vol01"),
		// 							VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 						},
		// 						{
		// 							BackupCreatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-10T10:29:37.215Z"); return t}()),
		// 							BackupElementID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0874889e-f2a3-42d2-a643-f378fc199688/elements/5c7eb677-d688-4afb-a352-ca62454d5921_0000000000000000"),
		// 							BackupID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backups/0874889e-f2a3-42d2-a643-f378fc199688"),
		// 							BackupPolicyID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest429326237"),
		// 							SizeInBytes: to.Ptr[int64](10737418240),
		// 							VolumeID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/vol%2540123"),
		// 							VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 					}},
		// 			}},
		// 	}},
		// }
	}
}

Output:

func (*DevicesClient) NewListFailoverTargetsPager 

func (client *DevicesClient) NewListFailoverTargetsPager(sourceDeviceName string, resourceGroupName string, managerName string, parameters ListFailoverTargetsRequest, options *DevicesClientListFailoverTargetsOptions) *runtime.Pager[DevicesClientListFailoverTargetsResponse]

NewListFailoverTargetsPager - Given a list of volume containers to be failed over from a source device, this method returns the eligibility result, as a failover target, for all devices under that resource.

Generated from API version 2017-06-01

  • sourceDeviceName - The source device name on which failover is performed.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - ListFailoverTargetsRequest containing the list of volume containers to be failed over.
  • options - DevicesClientListFailoverTargetsOptions contains the optional parameters for the DevicesClient.NewListFailoverTargetsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesListFailoverTargets.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDevicesClient().NewListFailoverTargetsPager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.ListFailoverTargetsRequest{
		VolumeContainers: []*string{
			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcforsdktest")},
	}, 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.FailoverTargetsList = armstorsimple8000series.FailoverTargetsList{
		// 	Value: []*armstorsimple8000series.FailoverTarget{
		// 		{
		// 			AvailableLocalStorageInBytes: to.Ptr[int64](43980464128),
		// 			AvailableTieredStorageInBytes: to.Ptr[int64](1099511627776),
		// 			DataContainersCount: to.Ptr[int32](0),
		// 			DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/sugattdeviceforSDK"),
		// 			DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
		// 			DeviceStatus: to.Ptr(armstorsimple8000series.DeviceStatusOffline),
		// 			EligibilityResult: &armstorsimple8000series.TargetEligibilityResult{
		// 				EligibilityStatus: to.Ptr(armstorsimple8000series.TargetEligibilityStatusNotEligible),
		// 				Messages: []*armstorsimple8000series.TargetEligibilityErrorMessage{
		// 					{
		// 						Message: to.Ptr("The selected target device is in 'Offline' state. The device configuration status is 'True'. Only online devices with the configuration status as complete can be failed over."),
		// 						Resolution: to.Ptr("Ensure that the specified target device is online and the device configuration is complete before you try the device failover."),
		// 						ResultCode: to.Ptr(armstorsimple8000series.TargetEligibilityResultCodeTargetIsNotOnlineError),
		// 				}},
		// 			},
		// 			FriendlyDeviceSoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
		// 			VolumesCount: to.Ptr[int32](0),
		// 		},
		// 		{
		// 			AvailableLocalStorageInBytes: to.Ptr[int64](43980464128),
		// 			AvailableTieredStorageInBytes: to.Ptr[int64](1099511627776),
		// 			DataContainersCount: to.Ptr[int32](0),
		// 			DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk"),
		// 			DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
		// 			DeviceStatus: to.Ptr(armstorsimple8000series.DeviceStatusOnline),
		// 			EligibilityResult: &armstorsimple8000series.TargetEligibilityResult{
		// 				EligibilityStatus: to.Ptr(armstorsimple8000series.TargetEligibilityStatusEligible),
		// 			},
		// 			FriendlyDeviceSoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
		// 			VolumesCount: to.Ptr[int32](0),
		// 		},
		// 		{
		// 			AvailableLocalStorageInBytes: to.Ptr[int64](40458590976),
		// 			AvailableTieredStorageInBytes: to.Ptr[int64](1011464798208),
		// 			DataContainersCount: to.Ptr[int32](2),
		// 			DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
		// 			DeviceStatus: to.Ptr(armstorsimple8000series.DeviceStatusOnline),
		// 			EligibilityResult: &armstorsimple8000series.TargetEligibilityResult{
		// 				EligibilityStatus: to.Ptr(armstorsimple8000series.TargetEligibilityStatusNotEligible),
		// 				Messages: []*armstorsimple8000series.TargetEligibilityErrorMessage{
		// 					{
		// 						Message: to.Ptr("The specified target device is the same as the source device. This is not supported. "),
		// 						Resolution: to.Ptr("Select a different target device and then retry the failover. "),
		// 						ResultCode: to.Ptr(armstorsimple8000series.TargetEligibilityResultCodeTargetAndSourceCannotBeSameError),
		// 				}},
		// 			},
		// 			FriendlyDeviceSoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
		// 			VolumesCount: to.Ptr[int32](7),
		// 	}},
		// }
	}
}

Output:

func (*DevicesClient) NewListMetricDefinitionPager 

func (client *DevicesClient) NewListMetricDefinitionPager(deviceName string, resourceGroupName string, managerName string, options *DevicesClientListMetricDefinitionOptions) *runtime.Pager[DevicesClientListMetricDefinitionResponse]

NewListMetricDefinitionPager - Gets the metric definitions for the specified device.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - DevicesClientListMetricDefinitionOptions contains the optional parameters for the DevicesClient.NewListMetricDefinitionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesListMetricDefinition.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDevicesClient().NewListMetricDefinitionPager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.MetricDefinitionList = armstorsimple8000series.MetricDefinitionList{
		// 	Value: []*armstorsimple8000series.MetricDefinition{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Tiered Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageTieredUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Locally Pinned Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageLocallyPinnedUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Cloud Storage Used"),
		// 				Value: to.Ptr("CloudStorageUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Local Storage Used"),
		// 				Value: to.Ptr("LocalStorageUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read I/O Operations/s"),
		// 				Value: to.Ptr("InitiatorToDeviceReadOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write I/O Operations/s"),
		// 				Value: to.Ptr("InitiatorToDeviceWriteOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Bytes/s"),
		// 				Value: to.Ptr("InitiatorToDeviceReadBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Bytes/s"),
		// 				Value: to.Ptr("InitiatorToDeviceWriteBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Latency"),
		// 				Value: to.Ptr("InitiatorToDeviceReadLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Latency"),
		// 				Value: to.Ptr("InitiatorToDeviceWriteLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Outstanding I/O"),
		// 				Value: to.Ptr("InitiatorToDeviceOutStandingIO"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read I/O Operations/s"),
		// 				Value: to.Ptr("DeviceToCloudReadOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write I/O Operations/s"),
		// 				Value: to.Ptr("DeviceToCloudWriteOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Bytes/s"),
		// 				Value: to.Ptr("DeviceToCloudReadBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Bytes/s"),
		// 				Value: to.Ptr("DeviceToCloudWriteBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Latency"),
		// 				Value: to.Ptr("DeviceToCloudReadLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Latency"),
		// 				Value: to.Ptr("DeviceToCloudWriteLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Outstanding I/O"),
		// 				Value: to.Ptr("DeviceToCloudOutStandingIO"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("CPU Utilization"),
		// 				Value: to.Ptr("CPUUsage"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("DevicePerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitPercent),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Network Out"),
		// 				Value: to.Ptr("NetworkOut"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("NetworkThroughput"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("NetworkInterface"),
		// 					Value: to.Ptr("data0"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Network In"),
		// 				Value: to.Ptr("NetworkIn"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions"),
		// 			Category: to.Ptr("NetworkThroughput"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("NetworkInterface"),
		// 					Value: to.Ptr("data0"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 	}},
		// }
	}
}

Output:

func (*DevicesClient) NewListMetricsPager 

func (client *DevicesClient) NewListMetricsPager(deviceName string, resourceGroupName string, managerName string, filter string, options *DevicesClientListMetricsOptions) *runtime.Pager[DevicesClientListMetricsResponse]

NewListMetricsPager - Gets the metrics for the specified device.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • filter - OData Filter options
  • options - DevicesClientListMetricsOptions contains the optional parameters for the DevicesClient.NewListMetricsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesListMetrics.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDevicesClient().NewListMetricsPager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", "name/value%20eq%20'PrimaryStorageTieredUsed'%20and%20timeGrain%20eq%20'PT1H'%20and%20startTime%20ge%20'2017-06-17T18:30:00Z'%20and%20endTime%20le%20'2017-06-21T18:30:00Z'%20and%20category%20eq%20'CapacityUtilization'", 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.MetricList = armstorsimple8000series.MetricList{
		// 	Value: []*armstorsimple8000series.Metrics{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Tiered Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageTieredUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/metrics"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Device"),
		// 					Value: to.Ptr("Device05ForSDKTest"),
		// 			}},
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-21T18:30:00.000Z"); return t}()),
		// 			PrimaryAggregation: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-17T18:30:00.000Z"); return t}()),
		// 			TimeGrain: to.Ptr("01:00:00"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 			Values: []*armstorsimple8000series.MetricData{
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*DevicesClient) Update 

func (client *DevicesClient) Update(ctx context.Context, deviceName string, resourceGroupName string, managerName string, parameters DevicePatch, options *DevicesClientUpdateOptions) (DevicesClientUpdateResponse, error)

Update - Patches the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - Patch representation of the device.
  • options - DevicesClientUpdateOptions contains the optional parameters for the DevicesClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/DevicesUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDevicesClient().Update(ctx, "Device001ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.DevicePatch{
		Properties: &armstorsimple8000series.DevicePatchProperties{
			DeviceDescription: to.Ptr("updated device description"),
		},
	}, 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.Device = armstorsimple8000series.Device{
	// 	Name: to.Ptr("Device001ForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device001ForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.DeviceProperties{
	// 		ActivationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-22T09:36:20.963Z"); return t}()),
	// 		ActiveController: to.Ptr(armstorsimple8000series.ControllerIDController0),
	// 		AgentGroupVersion: to.Ptr[int32](7),
	// 		AvailableLocalStorageInBytes: to.Ptr[int64](43980464128),
	// 		AvailableTieredStorageInBytes: to.Ptr[int64](1099511627776),
	// 		Culture: to.Ptr("en-US"),
	// 		DeviceConfigurationStatus: to.Ptr(armstorsimple8000series.DeviceConfigurationStatusComplete),
	// 		DeviceDescription: to.Ptr("updated device description"),
	// 		DeviceSoftwareVersion: to.Ptr("6.3.9600.17802"),
	// 		DeviceType: to.Ptr(armstorsimple8000series.DeviceTypeSeries8000PhysicalAppliance),
	// 		FriendlyName: to.Ptr("Device001ForSDKTest"),
	// 		FriendlySoftwareVersion: to.Ptr("StorSimple 8000 Series Update 4.0"),
	// 		ModelDescription: to.Ptr("100"),
	// 		NetworkInterfaceCardCount: to.Ptr[int32](6),
	// 		ProvisionedLocalStorageInBytes: to.Ptr[int64](0),
	// 		ProvisionedTieredStorageInBytes: to.Ptr[int64](0),
	// 		ProvisionedVolumeSizeInBytes: to.Ptr[int64](0),
	// 		SerialNumber: to.Ptr("123456789"),
	// 		Status: to.Ptr(armstorsimple8000series.DeviceStatusOnline),
	// 		TargetIqn: to.Ptr("iqn.1991-05.com.microsoft:storsimple100-123456789-target"),
	// 		TotalTieredStorageInBytes: to.Ptr[int64](1099511627776),
	// 		UsingStorageInBytes: to.Ptr[int64](0),
	// 	},
	// }
}

Output:

type DevicesClientAuthorizeForServiceEncryptionKeyRolloverOptions 

type DevicesClientAuthorizeForServiceEncryptionKeyRolloverOptions struct {
}

DevicesClientAuthorizeForServiceEncryptionKeyRolloverOptions contains the optional parameters for the DevicesClient.AuthorizeForServiceEncryptionKeyRollover method.

type DevicesClientAuthorizeForServiceEncryptionKeyRolloverResponse 

type DevicesClientAuthorizeForServiceEncryptionKeyRolloverResponse struct {
}

DevicesClientAuthorizeForServiceEncryptionKeyRolloverResponse contains the response from method DevicesClient.AuthorizeForServiceEncryptionKeyRollover.

type DevicesClientBeginConfigureOptions 

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

DevicesClientBeginConfigureOptions contains the optional parameters for the DevicesClient.BeginConfigure method.

type DevicesClientBeginDeactivateOptions 

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

DevicesClientBeginDeactivateOptions contains the optional parameters for the DevicesClient.BeginDeactivate method.

type DevicesClientBeginDeleteOptions 

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

DevicesClientBeginDeleteOptions contains the optional parameters for the DevicesClient.BeginDelete method.

type DevicesClientBeginFailoverOptions 

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

DevicesClientBeginFailoverOptions contains the optional parameters for the DevicesClient.BeginFailover method.

type DevicesClientBeginInstallUpdatesOptions 

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

DevicesClientBeginInstallUpdatesOptions contains the optional parameters for the DevicesClient.BeginInstallUpdates method.

type DevicesClientBeginScanForUpdatesOptions 

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

DevicesClientBeginScanForUpdatesOptions contains the optional parameters for the DevicesClient.BeginScanForUpdates method.

type DevicesClientConfigureResponse 

type DevicesClientConfigureResponse struct {
}

DevicesClientConfigureResponse contains the response from method DevicesClient.BeginConfigure.

type DevicesClientDeactivateResponse 

type DevicesClientDeactivateResponse struct {
}

DevicesClientDeactivateResponse contains the response from method DevicesClient.BeginDeactivate.

type DevicesClientDeleteResponse 

type DevicesClientDeleteResponse struct {
}

DevicesClientDeleteResponse contains the response from method DevicesClient.BeginDelete.

type DevicesClientFailoverResponse 

type DevicesClientFailoverResponse struct {
}

DevicesClientFailoverResponse contains the response from method DevicesClient.BeginFailover.

type DevicesClientGetOptions 

type DevicesClientGetOptions struct {
	// Specify $expand=details to populate additional fields related to the device or $expand=rolloverdetails to populate additional
	// fields related to the service data encryption key rollover on device
	Expand *string
}

DevicesClientGetOptions contains the optional parameters for the DevicesClient.Get method.

type DevicesClientGetResponse 

type DevicesClientGetResponse struct {
	// The StorSimple device.
	Device
}

DevicesClientGetResponse contains the response from method DevicesClient.Get.

type DevicesClientGetUpdateSummaryOptions 

type DevicesClientGetUpdateSummaryOptions struct {
}

DevicesClientGetUpdateSummaryOptions contains the optional parameters for the DevicesClient.GetUpdateSummary method.

type DevicesClientGetUpdateSummaryResponse 

type DevicesClientGetUpdateSummaryResponse struct {
	// The updates profile of a device.
	Updates
}

DevicesClientGetUpdateSummaryResponse contains the response from method DevicesClient.GetUpdateSummary.

type DevicesClientInstallUpdatesResponse 

type DevicesClientInstallUpdatesResponse struct {
}

DevicesClientInstallUpdatesResponse contains the response from method DevicesClient.BeginInstallUpdates.

type DevicesClientListByManagerOptions 

type DevicesClientListByManagerOptions struct {
	// Specify $expand=details to populate additional fields related to the device or $expand=rolloverdetails to populate additional
	// fields related to the service data encryption key rollover on device
	Expand *string
}

DevicesClientListByManagerOptions contains the optional parameters for the DevicesClient.NewListByManagerPager method.

type DevicesClientListByManagerResponse 

type DevicesClientListByManagerResponse struct {
	// The collection of devices.
	DeviceList
}

DevicesClientListByManagerResponse contains the response from method DevicesClient.NewListByManagerPager.

type DevicesClientListFailoverSetsOptions 

type DevicesClientListFailoverSetsOptions struct {
}

DevicesClientListFailoverSetsOptions contains the optional parameters for the DevicesClient.NewListFailoverSetsPager method.

type DevicesClientListFailoverSetsResponse 

type DevicesClientListFailoverSetsResponse struct {
	// The list of failover sets.
	FailoverSetsList
}

DevicesClientListFailoverSetsResponse contains the response from method DevicesClient.NewListFailoverSetsPager.

type DevicesClientListFailoverTargetsOptions 

type DevicesClientListFailoverTargetsOptions struct {
}

DevicesClientListFailoverTargetsOptions contains the optional parameters for the DevicesClient.NewListFailoverTargetsPager method.

type DevicesClientListFailoverTargetsResponse 

type DevicesClientListFailoverTargetsResponse struct {
	// The list of all devices in a resource and their eligibility status as a failover target device.
	FailoverTargetsList
}

DevicesClientListFailoverTargetsResponse contains the response from method DevicesClient.NewListFailoverTargetsPager.

type DevicesClientListMetricDefinitionOptions 

type DevicesClientListMetricDefinitionOptions struct {
}

DevicesClientListMetricDefinitionOptions contains the optional parameters for the DevicesClient.NewListMetricDefinitionPager method.

type DevicesClientListMetricDefinitionResponse 

type DevicesClientListMetricDefinitionResponse struct {
	// The list of metric definitions.
	MetricDefinitionList
}

DevicesClientListMetricDefinitionResponse contains the response from method DevicesClient.NewListMetricDefinitionPager.

type DevicesClientListMetricsOptions 

type DevicesClientListMetricsOptions struct {
}

DevicesClientListMetricsOptions contains the optional parameters for the DevicesClient.NewListMetricsPager method.

type DevicesClientListMetricsResponse 

type DevicesClientListMetricsResponse struct {
	// The metric list.
	MetricList
}

DevicesClientListMetricsResponse contains the response from method DevicesClient.NewListMetricsPager.

type DevicesClientScanForUpdatesResponse 

type DevicesClientScanForUpdatesResponse struct {
}

DevicesClientScanForUpdatesResponse contains the response from method DevicesClient.BeginScanForUpdates.

type DevicesClientUpdateOptions 

type DevicesClientUpdateOptions struct {
}

DevicesClientUpdateOptions contains the optional parameters for the DevicesClient.Update method.

type DevicesClientUpdateResponse 

type DevicesClientUpdateResponse struct {
	// The StorSimple device.
	Device
}

DevicesClientUpdateResponse contains the response from method DevicesClient.Update.

type DimensionFilter 

type DimensionFilter struct {
	// Specifies the dimension name. E.g., NetworkInterface. Valid values are the ones specified in the field "dimensions" in
	// the ListMetricDefinitions call. Only 'Equality' operator is supported for this
	// property.
	Name *string

	// Specifies the dimension value. E.g., Data0. Valid values are the ones returned in the field "dimensions" in the ListMetricDefinitions
	// call. Only 'Equality' operator is supported for this property.
	Values *string
}

DimensionFilter - The dimension filter.

func (DimensionFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DimensionFilter.

func (*DimensionFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DimensionFilter.

type EncryptionAlgorithm 

type EncryptionAlgorithm string

EncryptionAlgorithm - The algorithm used to encrypt "Value". 

const (
	EncryptionAlgorithmAES256        EncryptionAlgorithm = "AES256"
	EncryptionAlgorithmNone          EncryptionAlgorithm = "None"
	EncryptionAlgorithmRSAESPKCS1V15 EncryptionAlgorithm = "RSAES_PKCS1_v_1_5"
)

func PossibleEncryptionAlgorithmValues 

func PossibleEncryptionAlgorithmValues() []EncryptionAlgorithm

PossibleEncryptionAlgorithmValues returns the possible values for the EncryptionAlgorithm const type.

type EncryptionSettings 

type EncryptionSettings struct {
	// REQUIRED; The properties of the encryption settings.
	Properties *EncryptionSettingsProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

EncryptionSettings - The encryption settings.

func (EncryptionSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionSettings.

func (*EncryptionSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionSettings.

type EncryptionSettingsProperties 

type EncryptionSettingsProperties struct {
	// REQUIRED; The encryption status to indicates if encryption is enabled or not.
	EncryptionStatus *EncryptionStatus

	// REQUIRED; The key rollover status to indicates if key rollover is required or not. If secret's encryption has been upgraded,
	// then it requires key rollover.
	KeyRolloverStatus *KeyRolloverStatus
}

EncryptionSettingsProperties - The properties of encryption settings.

func (EncryptionSettingsProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionSettingsProperties.

func (*EncryptionSettingsProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionSettingsProperties.

type EncryptionStatus 

type EncryptionStatus string

EncryptionStatus - The encryption status to indicates if encryption is enabled or not. 

const (
	EncryptionStatusDisabled EncryptionStatus = "Disabled"
	EncryptionStatusEnabled  EncryptionStatus = "Enabled"
)

func PossibleEncryptionStatusValues 

func PossibleEncryptionStatusValues() []EncryptionStatus

PossibleEncryptionStatusValues returns the possible values for the EncryptionStatus const type.

type FailoverRequest 

type FailoverRequest struct {
	// The ARM path ID of the device which will act as the failover target.
	TargetDeviceID *string

	// The list of path IDs of the volume containers which needs to be failed-over to the target device.
	VolumeContainers []*string
}

FailoverRequest - The request object for triggering a failover of volume containers, from a source device to a target device.

func (FailoverRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FailoverRequest.

func (*FailoverRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FailoverRequest.

type FailoverSet 

type FailoverSet struct {
	// The eligibility result of the failover set, for failover.
	EligibilityResult *FailoverSetEligibilityResult

	// The list of meta data of volume containers, which are part of the failover set.
	VolumeContainers []*VolumeContainerFailoverMetadata
}

FailoverSet - The failover set on a device.

func (FailoverSet) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FailoverSet.

func (*FailoverSet) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FailoverSet.

type FailoverSetEligibilityResult 

type FailoverSetEligibilityResult struct {
	// The error message, if the failover set is not eligible for failover.
	ErrorMessage *string

	// Represents if this failover set is eligible for failover or not.
	IsEligibleForFailover *bool
}

FailoverSetEligibilityResult - The eligibility result of failover set, for failover.

func (FailoverSetEligibilityResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FailoverSetEligibilityResult.

func (*FailoverSetEligibilityResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FailoverSetEligibilityResult.

type FailoverSetsList 

type FailoverSetsList struct {
	// The list of failover sets.
	Value []*FailoverSet
}

FailoverSetsList - The list of failover sets.

func (FailoverSetsList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FailoverSetsList.

func (*FailoverSetsList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FailoverSetsList.

type FailoverTarget 

type FailoverTarget struct {
	// The amount of free local storage available on the device in bytes.
	AvailableLocalStorageInBytes *int64

	// The amount of free tiered storage available for the device in bytes.
	AvailableTieredStorageInBytes *int64

	// The count of data containers on the device.
	DataContainersCount *int32

	// The path ID of the device.
	DeviceID *string

	// The geo location (applicable only for cloud appliances) of the device.
	DeviceLocation *string

	// The software version of the device.
	DeviceSoftwareVersion *string

	// The status of the device.
	DeviceStatus *DeviceStatus

	// The eligibility result of the device, as a failover target device.
	EligibilityResult *TargetEligibilityResult

	// The friendly name for the current version of software on the device.
	FriendlyDeviceSoftwareVersion *string

	// The model number of the device.
	ModelDescription *string

	// The count of volumes on the device.
	VolumesCount *int32
}

FailoverTarget - Represents the eligibility of a device as a failover target device.

func (FailoverTarget) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FailoverTarget.

func (*FailoverTarget) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FailoverTarget.

type FailoverTargetsList 

type FailoverTargetsList struct {
	// The list of all the failover targets.
	Value []*FailoverTarget
}

FailoverTargetsList - The list of all devices in a resource and their eligibility status as a failover target device.

func (FailoverTargetsList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FailoverTargetsList.

func (*FailoverTargetsList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FailoverTargetsList.

type Feature 

type Feature struct {
	// REQUIRED; The name of the feature.
	Name *string

	// REQUIRED; The feature support status.
	Status *FeatureSupportStatus
}

Feature - The feature.

func (Feature) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Feature.

func (*Feature) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Feature.

type FeatureFilter 

type FeatureFilter struct {
	// Specifies the device ID for which the features are required. Only 'Equality' operator is supported for this property.
	DeviceID *string
}

FeatureFilter - The OData filter to be used for features.

func (FeatureFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FeatureFilter.

func (*FeatureFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FeatureFilter.

type FeatureList 

type FeatureList struct {
	// REQUIRED; The value.
	Value []*Feature
}

FeatureList - The collections of features.

func (FeatureList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FeatureList.

func (*FeatureList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FeatureList.

type FeatureSupportStatus 

type FeatureSupportStatus string

FeatureSupportStatus - The feature support status. 

const (
	FeatureSupportStatusNotAvailable             FeatureSupportStatus = "NotAvailable"
	FeatureSupportStatusSupported                FeatureSupportStatus = "Supported"
	FeatureSupportStatusUnsupportedDeviceVersion FeatureSupportStatus = "UnsupportedDeviceVersion"
)

func PossibleFeatureSupportStatusValues 

func PossibleFeatureSupportStatusValues() []FeatureSupportStatus

PossibleFeatureSupportStatusValues returns the possible values for the FeatureSupportStatus const type.

type HardwareComponent 

type HardwareComponent struct {
	// REQUIRED; The component ID.
	ComponentID *string

	// REQUIRED; The display name of the hardware component.
	DisplayName *string

	// REQUIRED; The status of the hardware component.
	Status *HardwareComponentStatus

	// REQUIRED; The display name of the status of hardware component.
	StatusDisplayName *string
}

HardwareComponent - The hardware component.

func (HardwareComponent) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HardwareComponent.

func (*HardwareComponent) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HardwareComponent.

type HardwareComponentGroup 

type HardwareComponentGroup struct {
	// REQUIRED; The properties of the hardware component group.
	Properties *HardwareComponentGroupProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

HardwareComponentGroup - The hardware component group.

func (HardwareComponentGroup) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HardwareComponentGroup.

func (*HardwareComponentGroup) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HardwareComponentGroup.

type HardwareComponentGroupList 

type HardwareComponentGroupList struct {
	// REQUIRED; The value.
	Value []*HardwareComponentGroup
}

HardwareComponentGroupList - The collection of hardware component groups.

func (HardwareComponentGroupList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HardwareComponentGroupList.

func (*HardwareComponentGroupList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HardwareComponentGroupList.

type HardwareComponentGroupProperties 

type HardwareComponentGroupProperties struct {
	// REQUIRED; The list of hardware components.
	Components []*HardwareComponent

	// REQUIRED; The display name the hardware component group.
	DisplayName *string

	// REQUIRED; The last updated time.
	LastUpdatedTime *time.Time
}

HardwareComponentGroupProperties - The properties of hardware component group.

func (HardwareComponentGroupProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HardwareComponentGroupProperties.

func (*HardwareComponentGroupProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HardwareComponentGroupProperties.

type HardwareComponentGroupsClient 

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

HardwareComponentGroupsClient contains the methods for the HardwareComponentGroups group. Don't use this type directly, use NewHardwareComponentGroupsClient() instead.

func NewHardwareComponentGroupsClient 

func NewHardwareComponentGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*HardwareComponentGroupsClient, error)

NewHardwareComponentGroupsClient creates a new instance of HardwareComponentGroupsClient with the specified values.

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

func (*HardwareComponentGroupsClient) BeginChangeControllerPowerState 

func (client *HardwareComponentGroupsClient) BeginChangeControllerPowerState(ctx context.Context, deviceName string, hardwareComponentGroupName string, resourceGroupName string, managerName string, parameters ControllerPowerStateChangeRequest, options *HardwareComponentGroupsClientBeginChangeControllerPowerStateOptions) (*runtime.Poller[HardwareComponentGroupsClientChangeControllerPowerStateResponse], error)

BeginChangeControllerPowerState - Changes the power state of the controller. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • hardwareComponentGroupName - The hardware component group name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The controller power state change request.
  • options - HardwareComponentGroupsClientBeginChangeControllerPowerStateOptions contains the optional parameters for the HardwareComponentGroupsClient.BeginChangeControllerPowerState method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/HardwareComponentGroupsChangeControllerPowerState.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewHardwareComponentGroupsClient().BeginChangeControllerPowerState(ctx, "Device05ForSDKTest", "Controller0Components", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.ControllerPowerStateChangeRequest{
		Properties: &armstorsimple8000series.ControllerPowerStateChangeRequestProperties{
			Action:           to.Ptr(armstorsimple8000series.ControllerPowerStateActionStart),
			ActiveController: to.Ptr(armstorsimple8000series.ControllerIDController0),
			Controller0State: to.Ptr(armstorsimple8000series.ControllerStatusOk),
			Controller1State: to.Ptr(armstorsimple8000series.ControllerStatusNotPresent),
		},
	}, 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 (*HardwareComponentGroupsClient) NewListByDevicePager 

func (client *HardwareComponentGroupsClient) NewListByDevicePager(deviceName string, resourceGroupName string, managerName string, options *HardwareComponentGroupsClientListByDeviceOptions) *runtime.Pager[HardwareComponentGroupsClientListByDeviceResponse]

NewListByDevicePager - Lists the hardware component groups at device-level.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - HardwareComponentGroupsClientListByDeviceOptions contains the optional parameters for the HardwareComponentGroupsClient.NewListByDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/HardwareComponentGroupsListByDevice.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewHardwareComponentGroupsClient().NewListByDevicePager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.HardwareComponentGroupList = armstorsimple8000series.HardwareComponentGroupList{
		// 	Value: []*armstorsimple8000series.HardwareComponentGroup{
		// 		{
		// 			Name: to.Ptr("Controller0Components"),
		// 			Type: to.Ptr("managers/devices/hardwareComponentGroups"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/hardwareComponentGroups/Controller0Components"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.HardwareComponentGroupProperties{
		// 				Components: []*armstorsimple8000series.HardwareComponent{
		// 					{
		// 						ComponentID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/hardwareComponentGroups/Controller0Components/hardwareComponents/NetworkData0"),
		// 						DisplayName: to.Ptr("Ethernet DATA 0"),
		// 						Status: to.Ptr(armstorsimple8000series.HardwareComponentStatusOk),
		// 						StatusDisplayName: to.Ptr("Ok"),
		// 				}},
		// 				DisplayName: to.Ptr("CONTROLLER 0 COMPONENTS"),
		// 				LastUpdatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-21T21:49:05.324Z"); return t}()),
		// 			},
		// 	}},
		// }
	}
}

Output:

type HardwareComponentGroupsClientBeginChangeControllerPowerStateOptions 

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

HardwareComponentGroupsClientBeginChangeControllerPowerStateOptions contains the optional parameters for the HardwareComponentGroupsClient.BeginChangeControllerPowerState method.

type HardwareComponentGroupsClientChangeControllerPowerStateResponse 

type HardwareComponentGroupsClientChangeControllerPowerStateResponse struct {
}

HardwareComponentGroupsClientChangeControllerPowerStateResponse contains the response from method HardwareComponentGroupsClient.BeginChangeControllerPowerState.

type HardwareComponentGroupsClientListByDeviceOptions 

type HardwareComponentGroupsClientListByDeviceOptions struct {
}

HardwareComponentGroupsClientListByDeviceOptions contains the optional parameters for the HardwareComponentGroupsClient.NewListByDevicePager method.

type HardwareComponentGroupsClientListByDeviceResponse 

type HardwareComponentGroupsClientListByDeviceResponse struct {
	// The collection of hardware component groups.
	HardwareComponentGroupList
}

HardwareComponentGroupsClientListByDeviceResponse contains the response from method HardwareComponentGroupsClient.NewListByDevicePager.

type HardwareComponentStatus 

type HardwareComponentStatus string

HardwareComponentStatus - The status of the hardware component. 

const (
	HardwareComponentStatusFailure    HardwareComponentStatus = "Failure"
	HardwareComponentStatusNotPresent HardwareComponentStatus = "NotPresent"
	HardwareComponentStatusOk         HardwareComponentStatus = "Ok"
	HardwareComponentStatusPoweredOff HardwareComponentStatus = "PoweredOff"
	HardwareComponentStatusRecovering HardwareComponentStatus = "Recovering"
	HardwareComponentStatusUnknown    HardwareComponentStatus = "Unknown"
	HardwareComponentStatusWarning    HardwareComponentStatus = "Warning"
)

func PossibleHardwareComponentStatusValues 

func PossibleHardwareComponentStatusValues() []HardwareComponentStatus

PossibleHardwareComponentStatusValues returns the possible values for the HardwareComponentStatus const type.

type ISCSIAndCloudStatus 

type ISCSIAndCloudStatus string

ISCSIAndCloudStatus - Value indicating cloud and ISCSI status of network adapter. 

const (
	ISCSIAndCloudStatusCloudEnabled         ISCSIAndCloudStatus = "CloudEnabled"
	ISCSIAndCloudStatusDisabled             ISCSIAndCloudStatus = "Disabled"
	ISCSIAndCloudStatusIscsiAndCloudEnabled ISCSIAndCloudStatus = "IscsiAndCloudEnabled"
	ISCSIAndCloudStatusIscsiEnabled         ISCSIAndCloudStatus = "IscsiEnabled"
)

func PossibleISCSIAndCloudStatusValues 

func PossibleISCSIAndCloudStatusValues() []ISCSIAndCloudStatus

PossibleISCSIAndCloudStatusValues returns the possible values for the ISCSIAndCloudStatus const type.

type InEligibilityCategory 

type InEligibilityCategory string

InEligibilityCategory - The reason for inEligibility of device, in case it's not eligible for service data encryption key rollover. 

const (
	InEligibilityCategoryDeviceNotOnline       InEligibilityCategory = "DeviceNotOnline"
	InEligibilityCategoryNotSupportedAppliance InEligibilityCategory = "NotSupportedAppliance"
	InEligibilityCategoryRolloverPending       InEligibilityCategory = "RolloverPending"
)

func PossibleInEligibilityCategoryValues 

func PossibleInEligibilityCategoryValues() []InEligibilityCategory

PossibleInEligibilityCategoryValues returns the possible values for the InEligibilityCategory const type.

type Job 

type Job struct {
	// REQUIRED; The percentage of the job that is already complete.
	PercentComplete *int32

	// REQUIRED; The current status of the job.
	Status *JobStatus

	// The UTC time at which the job completed.
	EndTime *time.Time

	// The error details, if any, for the job.
	Error *JobErrorDetails

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// The properties of the job.
	Properties *JobProperties

	// The UTC time at which the job was started.
	StartTime *time.Time

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

Job - The job.

func (Job) MarshalJSON 

func (j Job) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Job.

func (*Job) UnmarshalJSON 

func (j *Job) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Job.

type JobErrorDetails 

type JobErrorDetails struct {
	// REQUIRED; The error code intended for programmatic access.
	Code *string

	// REQUIRED; The error message intended to describe the error in detail.
	Message *string

	// The error details.
	ErrorDetails []*JobErrorItem
}

JobErrorDetails - The job error details. Contains list of job error items.

func (JobErrorDetails) MarshalJSON 

func (j JobErrorDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type JobErrorDetails.

func (*JobErrorDetails) UnmarshalJSON 

func (j *JobErrorDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type JobErrorDetails.

type JobErrorItem 

type JobErrorItem struct {
	// REQUIRED; The error code intended for programmatic access.
	Code *string

	// REQUIRED; The error message intended to describe the error in detail.
	Message *string

	// The recommended actions.
	Recommendations []*string
}

JobErrorItem - The job error items.

func (JobErrorItem) MarshalJSON 

func (j JobErrorItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type JobErrorItem.

func (*JobErrorItem) UnmarshalJSON 

func (j *JobErrorItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type JobErrorItem.

type JobFilter 

type JobFilter struct {
	// Specifies the type of the jobs to be filtered. For e.g., "ScheduledBackup", "ManualBackup", "RestoreBackup", "CloneVolume",
	// "FailoverVolumeContainers", "CreateLocallyPinnedVolume", "ModifyVolume",
	// "InstallUpdates", "SupportPackageLogs", or "CreateCloudAppliance". Only 'Equality' operator can be used for this property.
	JobType *string

	// Specifies the start time of the jobs to be filtered. Only 'Greater Than or Equal To' and 'Lesser Than or Equal To' operators
	// are supported for this property.
	StartTime *time.Time

	// Specifies the status of the jobs to be filtered. For e.g., "Running", "Succeeded", "Failed" or "Canceled". Only 'Equality'
	// operator is supported for this property.
	Status *string
}

JobFilter - The OData filter to be used for jobs.

func (JobFilter) MarshalJSON 

func (j JobFilter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type JobFilter.

func (*JobFilter) UnmarshalJSON 

func (j *JobFilter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type JobFilter.

type JobList 

type JobList struct {
	// REQUIRED; The value.
	Value []*Job

	// The NextLink.
	NextLink *string
}

JobList - The collection of jobs.

func (JobList) MarshalJSON 

func (j JobList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type JobList.

func (*JobList) UnmarshalJSON 

func (j *JobList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type JobList.

type JobProperties 

type JobProperties struct {
	// REQUIRED; The type of the job.
	JobType *JobType

	// The time of the backup used for the failover.
	BackupPointInTime *time.Time

	// The backup type (CloudSnapshot | LocalSnapshot). Applicable only for backup jobs.
	BackupType *BackupType

	// The data statistics properties of the job.
	DataStats *DataStatistics

	// The device ID in which the job ran.
	DeviceID *string

	// The entity identifier for which the job ran.
	EntityLabel *string

	// The entity type for which the job ran.
	EntityType *string

	// Represents whether the job is cancellable or not.
	IsCancellable *bool

	// The job stages.
	JobStages []*JobStage

	// The source device ID of the failover job.
	SourceDeviceID *string
}

JobProperties - The properties of the job.

func (JobProperties) MarshalJSON 

func (j JobProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type JobProperties.

func (*JobProperties) UnmarshalJSON 

func (j *JobProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type JobProperties.

type JobStage 

type JobStage struct {
	// REQUIRED; The stage status.
	StageStatus *JobStatus

	// The details of the stage.
	Detail *string

	// The error code of the stage if any.
	ErrorCode *string

	// The message of the job stage.
	Message *string
}

JobStage - The details about the specific stage of a job.

func (JobStage) MarshalJSON 

func (j JobStage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type JobStage.

func (*JobStage) UnmarshalJSON 

func (j *JobStage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type JobStage.

type JobStatus 

type JobStatus string

JobStatus - The current status of the job. 

const (
	JobStatusCanceled  JobStatus = "Canceled"
	JobStatusFailed    JobStatus = "Failed"
	JobStatusRunning   JobStatus = "Running"
	JobStatusSucceeded JobStatus = "Succeeded"
)

func PossibleJobStatusValues 

func PossibleJobStatusValues() []JobStatus

PossibleJobStatusValues returns the possible values for the JobStatus const type.

type JobType 

type JobType string

JobType - The type of the job. 

const (
	JobTypeCloneVolume               JobType = "CloneVolume"
	JobTypeCreateCloudAppliance      JobType = "CreateCloudAppliance"
	JobTypeCreateLocallyPinnedVolume JobType = "CreateLocallyPinnedVolume"
	JobTypeFailoverVolumeContainers  JobType = "FailoverVolumeContainers"
	JobTypeInstallUpdates            JobType = "InstallUpdates"
	JobTypeManualBackup              JobType = "ManualBackup"
	JobTypeModifyVolume              JobType = "ModifyVolume"
	JobTypeRestoreBackup             JobType = "RestoreBackup"
	JobTypeScheduledBackup           JobType = "ScheduledBackup"
	JobTypeSupportPackageLogs        JobType = "SupportPackageLogs"
)

func PossibleJobTypeValues 

func PossibleJobTypeValues() []JobType

PossibleJobTypeValues returns the possible values for the JobType const type.

type JobsClient 

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

JobsClient contains the methods for the Jobs group. Don't use this type directly, use NewJobsClient() instead.

func NewJobsClient 

func NewJobsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*JobsClient, error)

NewJobsClient creates a new instance of JobsClient with the specified values.

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

func (*JobsClient) BeginCancel 

func (client *JobsClient) BeginCancel(ctx context.Context, deviceName string, jobName string, resourceGroupName string, managerName string, options *JobsClientBeginCancelOptions) (*runtime.Poller[JobsClientCancelResponse], error)

BeginCancel - Cancels a job on the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • jobName - The jobName.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - JobsClientBeginCancelOptions contains the optional parameters for the JobsClient.BeginCancel method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/JobsCancel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewJobsClient().BeginCancel(ctx, "Device05ForSDKTest", "993db21d-101b-41af-9e12-f593d78b99e9", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*JobsClient) Get 

func (client *JobsClient) Get(ctx context.Context, deviceName string, jobName string, resourceGroupName string, managerName string, options *JobsClientGetOptions) (JobsClientGetResponse, error)

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

Generated from API version 2017-06-01

  • deviceName - The device name
  • jobName - The job Name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - JobsClientGetOptions contains the optional parameters for the JobsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/JobsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewJobsClient().Get(ctx, "sca07forsdktest", "70a29339-de6d-48e8-b24f-e25ee6769a00", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.Job = armstorsimple8000series.Job{
	// 	Name: to.Ptr("70a29339-de6d-48e8-b24f-e25ee6769a00"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
	// 	ID: to.Ptr("/subscriptions/d3ebfe71-b7a9-4c57-92b9-68a2afde4de5/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/sca07forsdktest/jobs/70a29339-de6d-48e8-b24f-e25ee6769a00"),
	// 	Kind: to.Ptr("Series8000"),
	// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-28T13:08:19.818Z"); return t}()),
	// 	PercentComplete: to.Ptr[int32](100),
	// 	Properties: &armstorsimple8000series.JobProperties{
	// 		DeviceID: to.Ptr("/subscriptions/d3ebfe71-b7a9-4c57-92b9-68a2afde4de5/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/sca07forsdktest"),
	// 		EntityLabel: to.Ptr("sca07forsdktest"),
	// 		EntityType: to.Ptr("Microsoft.StorSimple/managers/devices"),
	// 		IsCancellable: to.Ptr(false),
	// 		JobType: to.Ptr(armstorsimple8000series.JobTypeCreateCloudAppliance),
	// 	},
	// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-28T12:58:14.364Z"); return t}()),
	// 	Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
	// }
}

Output:

func (*JobsClient) NewListByDevicePager 

func (client *JobsClient) NewListByDevicePager(deviceName string, resourceGroupName string, managerName string, options *JobsClientListByDeviceOptions) *runtime.Pager[JobsClientListByDeviceResponse]

NewListByDevicePager - Gets all the jobs for specified device. With optional OData query parameters, a filtered set of jobs is returned.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - JobsClientListByDeviceOptions contains the optional parameters for the JobsClient.NewListByDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/JobsListByDevice.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewJobsClient().NewListByDevicePager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.JobsClientListByDeviceOptions{Filter: to.Ptr("jobType%20eq%20'ManualBackup'")})
	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.JobList = armstorsimple8000series.JobList{
		// 	Value: []*armstorsimple8000series.Job{
		// 		{
		// 			Name: to.Ptr("880e1774-94a8-4f3e-85e6-a61e6b94a8b7"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/jobs/880e1774-94a8-4f3e-85e6-a61e6b94a8b7"),
		// 			Kind: to.Ptr("Series8000"),
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T22:02:39.005Z"); return t}()),
		// 			PercentComplete: to.Ptr[int32](100),
		// 			Properties: &armstorsimple8000series.JobProperties{
		// 				BackupPointInTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				DataStats: &armstorsimple8000series.DataStatistics{
		// 					CloudData: to.Ptr[int64](138),
		// 					ProcessedData: to.Ptr[int64](21474836480),
		// 					Throughput: to.Ptr[int64](76),
		// 					TotalData: to.Ptr[int64](21474836480),
		// 				},
		// 				DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 				EntityLabel: to.Ptr("BkUpPolicy01ForSDKTest"),
		// 				EntityType: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
		// 				IsCancellable: to.Ptr(true),
		// 				JobType: to.Ptr(armstorsimple8000series.JobTypeManualBackup),
		// 			},
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T22:01:19.708Z"); return t}()),
		// 			Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 		},
		// 		{
		// 			Name: to.Ptr("69829a17-ab98-40c3-a6d3-fe8d315f52af"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/jobs/69829a17-ab98-40c3-a6d3-fe8d315f52af"),
		// 			Kind: to.Ptr("Series8000"),
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T21:30:37.397Z"); return t}()),
		// 			PercentComplete: to.Ptr[int32](100),
		// 			Properties: &armstorsimple8000series.JobProperties{
		// 				BackupPointInTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				DataStats: &armstorsimple8000series.DataStatistics{
		// 					CloudData: to.Ptr[int64](152),
		// 					ProcessedData: to.Ptr[int64](26843545600),
		// 					Throughput: to.Ptr[int64](656),
		// 					TotalData: to.Ptr[int64](26843545600),
		// 				},
		// 				DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 				EntityLabel: to.Ptr("BkUpPolicy01ForSDKTest"),
		// 				EntityType: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
		// 				IsCancellable: to.Ptr(true),
		// 				JobType: to.Ptr(armstorsimple8000series.JobTypeManualBackup),
		// 			},
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T21:29:15.914Z"); return t}()),
		// 			Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 		},
		// 		{
		// 			Name: to.Ptr("0826eda8-3d17-4cb9-b2af-d18ecf6ab819"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/jobs/0826eda8-3d17-4cb9-b2af-d18ecf6ab819"),
		// 			Kind: to.Ptr("Series8000"),
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T21:23:21.028Z"); return t}()),
		// 			PercentComplete: to.Ptr[int32](100),
		// 			Properties: &armstorsimple8000series.JobProperties{
		// 				BackupPointInTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
		// 				BackupType: to.Ptr(armstorsimple8000series.BackupTypeCloudSnapshot),
		// 				DataStats: &armstorsimple8000series.DataStatistics{
		// 					CloudData: to.Ptr[int64](152),
		// 					ProcessedData: to.Ptr[int64](26843545600),
		// 					Throughput: to.Ptr[int64](85),
		// 					TotalData: to.Ptr[int64](26843545600),
		// 				},
		// 				DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 				EntityLabel: to.Ptr("BkUpPolicyForSDKTest1032280949"),
		// 				EntityType: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies"),
		// 				IsCancellable: to.Ptr(true),
		// 				JobType: to.Ptr(armstorsimple8000series.JobTypeManualBackup),
		// 			},
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-23T21:22:01.372Z"); return t}()),
		// 			Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 	}},
		// }
	}
}

Output:

func (*JobsClient) NewListByManagerPager 

func (client *JobsClient) NewListByManagerPager(resourceGroupName string, managerName string, options *JobsClientListByManagerOptions) *runtime.Pager[JobsClientListByManagerResponse]

NewListByManagerPager - Gets all the jobs for the specified manager. With optional OData query parameters, a filtered set of jobs is returned.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - JobsClientListByManagerOptions contains the optional parameters for the JobsClient.NewListByManagerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/JobsListByManager.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewJobsClient().NewListByManagerPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.JobsClientListByManagerOptions{Filter: to.Ptr("jobType%20eq%20'FailoverVolumeContainers'")})
	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.JobList = armstorsimple8000series.JobList{
		// 	Value: []*armstorsimple8000series.Job{
		// 		{
		// 			Name: to.Ptr("07103ea6-0092-4bee-853c-72a98256421e"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk/jobs/07103ea6-0092-4bee-853c-72a98256421e"),
		// 			Kind: to.Ptr("Series8000"),
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-22T09:19:06.885Z"); return t}()),
		// 			PercentComplete: to.Ptr[int32](100),
		// 			Properties: &armstorsimple8000series.JobProperties{
		// 				DataStats: &armstorsimple8000series.DataStatistics{
		// 					CloudData: to.Ptr[int64](0),
		// 					ProcessedData: to.Ptr[int64](0),
		// 					Throughput: to.Ptr[int64](0),
		// 					TotalData: to.Ptr[int64](0),
		// 				},
		// 				DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk"),
		// 				EntityLabel: to.Ptr("Device05ForSDKTest"),
		// 				EntityType: to.Ptr("Microsoft.StorSimple/managers/devices"),
		// 				IsCancellable: to.Ptr(false),
		// 				JobStages: []*armstorsimple8000series.JobStage{
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateSAC"),
		// 						Message: to.Ptr("Creation of storage account credentials"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepTakeOwnership"),
		// 						Message: to.Ptr("Transfer of volume containers and backups"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepRestoreVolumes"),
		// 						Message: to.Ptr("Restoration of volumes"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateACR"),
		// 						Message: to.Ptr("Creation of ACRs"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateSchedules"),
		// 						Message: to.Ptr("Creation of backup schedules"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 				}},
		// 				JobType: to.Ptr(armstorsimple8000series.JobTypeFailoverVolumeContainers),
		// 				SourceDeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			},
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-22T09:17:48.254Z"); return t}()),
		// 			Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 		},
		// 		{
		// 			Name: to.Ptr("55d9f42a-b130-4bbe-8f40-985174a37ce8"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/jobs/55d9f42a-b130-4bbe-8f40-985174a37ce8"),
		// 			Kind: to.Ptr("Series8000"),
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-19T09:04:37.689Z"); return t}()),
		// 			PercentComplete: to.Ptr[int32](100),
		// 			Properties: &armstorsimple8000series.JobProperties{
		// 				DataStats: &armstorsimple8000series.DataStatistics{
		// 					CloudData: to.Ptr[int64](0),
		// 					ProcessedData: to.Ptr[int64](0),
		// 					Throughput: to.Ptr[int64](0),
		// 					TotalData: to.Ptr[int64](0),
		// 				},
		// 				DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 				EntityLabel: to.Ptr("jemdeviceforsdk"),
		// 				EntityType: to.Ptr("Microsoft.StorSimple/managers/devices"),
		// 				IsCancellable: to.Ptr(false),
		// 				JobStages: []*armstorsimple8000series.JobStage{
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateSAC"),
		// 						Message: to.Ptr("Creation of storage account credentials"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepTakeOwnership"),
		// 						Message: to.Ptr("Transfer of volume containers and backups"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepRestoreVolumes"),
		// 						Message: to.Ptr("Restoration of volumes"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateACR"),
		// 						Message: to.Ptr("Creation of ACRs"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateSchedules"),
		// 						Message: to.Ptr("Creation of backup schedules"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 				}},
		// 				JobType: to.Ptr(armstorsimple8000series.JobTypeFailoverVolumeContainers),
		// 				SourceDeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk"),
		// 			},
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-19T09:02:57.435Z"); return t}()),
		// 			Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 		},
		// 		{
		// 			Name: to.Ptr("a8418e26-99e8-4b11-883f-c08ca74db2b0"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/jobs"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk/jobs/a8418e26-99e8-4b11-883f-c08ca74db2b0"),
		// 			Kind: to.Ptr("Series8000"),
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-13T10:51:59.006Z"); return t}()),
		// 			PercentComplete: to.Ptr[int32](100),
		// 			Properties: &armstorsimple8000series.JobProperties{
		// 				DataStats: &armstorsimple8000series.DataStatistics{
		// 					CloudData: to.Ptr[int64](0),
		// 					ProcessedData: to.Ptr[int64](0),
		// 					Throughput: to.Ptr[int64](0),
		// 					TotalData: to.Ptr[int64](0),
		// 				},
		// 				DeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/jemdeviceforsdk"),
		// 				EntityLabel: to.Ptr("Device05ForSDKTest"),
		// 				EntityType: to.Ptr("Microsoft.StorSimple/managers/devices"),
		// 				IsCancellable: to.Ptr(false),
		// 				JobStages: []*armstorsimple8000series.JobStage{
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateSAC"),
		// 						Message: to.Ptr("Creation of storage account credentials"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepTakeOwnership"),
		// 						Message: to.Ptr("Transfer of volume containers and backups"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepRestoreVolumes"),
		// 						Message: to.Ptr("Restoration of volumes"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateACR"),
		// 						Message: to.Ptr("Creation of ACRs"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 					},
		// 					{
		// 						Detail: to.Ptr(""),
		// 						ErrorCode: to.Ptr("CiSDRJobStepCreateSchedules"),
		// 						Message: to.Ptr("Creation of backup schedules"),
		// 						StageStatus: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 				}},
		// 				JobType: to.Ptr(armstorsimple8000series.JobTypeFailoverVolumeContainers),
		// 				SourceDeviceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest"),
		// 			},
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-13T10:50:46.764Z"); return t}()),
		// 			Status: to.Ptr(armstorsimple8000series.JobStatusSucceeded),
		// 	}},
		// }
	}
}

Output:

type JobsClientBeginCancelOptions 

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

JobsClientBeginCancelOptions contains the optional parameters for the JobsClient.BeginCancel method.

type JobsClientCancelResponse 

type JobsClientCancelResponse struct {
}

JobsClientCancelResponse contains the response from method JobsClient.BeginCancel.

type JobsClientGetOptions 

type JobsClientGetOptions struct {
}

JobsClientGetOptions contains the optional parameters for the JobsClient.Get method.

type JobsClientGetResponse 

type JobsClientGetResponse struct {
	// The job.
	Job
}

JobsClientGetResponse contains the response from method JobsClient.Get.

type JobsClientListByDeviceOptions 

type JobsClientListByDeviceOptions struct {
	// OData Filter options
	Filter *string
}

JobsClientListByDeviceOptions contains the optional parameters for the JobsClient.NewListByDevicePager method.

type JobsClientListByDeviceResponse 

type JobsClientListByDeviceResponse struct {
	// The collection of jobs.
	JobList
}

JobsClientListByDeviceResponse contains the response from method JobsClient.NewListByDevicePager.

type JobsClientListByManagerOptions 

type JobsClientListByManagerOptions struct {
	// OData Filter options
	Filter *string
}

JobsClientListByManagerOptions contains the optional parameters for the JobsClient.NewListByManagerPager method.

type JobsClientListByManagerResponse 

type JobsClientListByManagerResponse struct {
	// The collection of jobs.
	JobList
}

JobsClientListByManagerResponse contains the response from method JobsClient.NewListByManagerPager.

type Key 

type Key struct {
	// REQUIRED; The activation key for the device.
	ActivationKey *string
}

Key - The key.

func (Key) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Key.

func (*Key) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Key.

type KeyRolloverStatus 

type KeyRolloverStatus string

KeyRolloverStatus - The key rollover status to indicates if key rollover is required or not. If secret's encryption has been upgraded, then it requires key rollover. 

const (
	KeyRolloverStatusNotRequired KeyRolloverStatus = "NotRequired"
	KeyRolloverStatusRequired    KeyRolloverStatus = "Required"
)

func PossibleKeyRolloverStatusValues 

func PossibleKeyRolloverStatusValues() []KeyRolloverStatus

PossibleKeyRolloverStatusValues returns the possible values for the KeyRolloverStatus const type.

type ListFailoverTargetsRequest 

type ListFailoverTargetsRequest struct {
	// The list of path IDs of the volume containers that needs to be failed-over, for which we want to fetch the eligible targets.
	VolumeContainers []*string
}

ListFailoverTargetsRequest - The request object for fetching the list of failover targets (eligible devices for failover).

func (ListFailoverTargetsRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ListFailoverTargetsRequest.

func (*ListFailoverTargetsRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListFailoverTargetsRequest.

type Manager 

type Manager struct {
	// REQUIRED; The geo location of the resource.
	Location *string

	// The etag of the manager.
	Etag *string

	// The properties of the StorSimple Manager.
	Properties *ManagerProperties

	// The tags attached to the resource.
	Tags map[string]*string

	// READ-ONLY; The resource ID.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

Manager - The StorSimple Manager.

func (Manager) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Manager.

func (*Manager) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Manager.

type ManagerExtendedInfo 

type ManagerExtendedInfo struct {
	// The etag of the resource.
	Etag *string

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// The extended info properties.
	Properties *ManagerExtendedInfoProperties

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

ManagerExtendedInfo - The extended info of the manager.

func (ManagerExtendedInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerExtendedInfo.

func (*ManagerExtendedInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerExtendedInfo.

type ManagerExtendedInfoProperties 

type ManagerExtendedInfoProperties struct {
	// REQUIRED; Represents the encryption algorithm used to encrypt the keys. None - if Key is saved in plain text format. Algorithm
	// name - if key is encrypted
	Algorithm *string

	// REQUIRED; Represents the CIK of the resource.
	IntegrityKey *string

	// Represents the CEK of the resource.
	EncryptionKey *string

	// Represents the Cert thumbprint that was used to encrypt the CEK.
	EncryptionKeyThumbprint *string

	// Represents the portal thumbprint which can be used optionally to encrypt the entire data before storing it.
	PortalCertificateThumbprint *string

	// The version of the extended info being persisted.
	Version *string
}

ManagerExtendedInfoProperties - The properties of the manager extended info.

func (ManagerExtendedInfoProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerExtendedInfoProperties.

func (*ManagerExtendedInfoProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerExtendedInfoProperties.

type ManagerIntrinsicSettings 

type ManagerIntrinsicSettings struct {
	// REQUIRED; The type of StorSimple Manager.
	Type *ManagerType
}

ManagerIntrinsicSettings - Intrinsic settings which refers to the type of the StorSimple Manager.

func (ManagerIntrinsicSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerIntrinsicSettings.

func (*ManagerIntrinsicSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerIntrinsicSettings.

type ManagerList 

type ManagerList struct {
	// REQUIRED; The list of StorSimple managers.
	Value []*Manager
}

ManagerList - The list of StorSimple Managers.

func (ManagerList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerList.

func (*ManagerList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerList.

type ManagerPatch 

type ManagerPatch struct {
	// The tags attached to the Manager.
	Tags map[string]*string
}

ManagerPatch - The StorSimple Manager patch.

func (ManagerPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerPatch.

func (*ManagerPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerPatch.

type ManagerProperties 

type ManagerProperties struct {
	// Represents the type of StorSimple Manager.
	CisIntrinsicSettings *ManagerIntrinsicSettings

	// Specifies the state of the resource as it is getting provisioned. Value of "Succeeded" means the Manager was successfully
	// created.
	ProvisioningState *string

	// Specifies the Sku.
	SKU *ManagerSKU
}

ManagerProperties - The properties of the StorSimple Manager.

func (ManagerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerProperties.

func (*ManagerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerProperties.

type ManagerSKU 

type ManagerSKU struct {
	// CONSTANT; Refers to the sku name which should be "Standard"
	// Field has constant value "Standard", any specified value is ignored.
	Name *string
}

ManagerSKU - The Sku.

func (ManagerSKU) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagerSKU.

func (*ManagerSKU) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagerSKU.

type ManagerType 

type ManagerType string

ManagerType - The type of StorSimple Manager. 

const (
	ManagerTypeGardaV1    ManagerType = "GardaV1"
	ManagerTypeHelsinkiV1 ManagerType = "HelsinkiV1"
)

func PossibleManagerTypeValues 

func PossibleManagerTypeValues() []ManagerType

PossibleManagerTypeValues returns the possible values for the ManagerType const type.

type ManagersClient 

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

ManagersClient contains the methods for the Managers group. Don't use this type directly, use NewManagersClient() instead.

func NewManagersClient 

func NewManagersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ManagersClient, error)

NewManagersClient creates a new instance of ManagersClient with the specified values.

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

func (*ManagersClient) CreateExtendedInfo 

func (client *ManagersClient) CreateExtendedInfo(ctx context.Context, resourceGroupName string, managerName string, parameters ManagerExtendedInfo, options *ManagersClientCreateExtendedInfoOptions) (ManagersClientCreateExtendedInfoResponse, error)

CreateExtendedInfo - Creates the extended info of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The manager extended information.
  • options - ManagersClientCreateExtendedInfoOptions contains the optional parameters for the ManagersClient.CreateExtendedInfo method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersCreateExtendedInfo.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().CreateExtendedInfo(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", armstorsimple8000series.ManagerExtendedInfo{
		Properties: &armstorsimple8000series.ManagerExtendedInfoProperties{
			Algorithm:    to.Ptr("None"),
			IntegrityKey: to.Ptr("BIl+RHqO8PZ6DRvuXTTK7g=="),
		},
	}, 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.ManagerExtendedInfo = armstorsimple8000series.ManagerExtendedInfo{
	// 	Name: to.Ptr("vaultExtendedInfo"),
	// 	Type: to.Ptr("Microsoft.StorSimple/Managers/extendedInformation"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest2extendedInformation/vaultExtendedInfo"),
	// 	Etag: to.Ptr("674ab9df-af56-4c5c-a5ca-2bddcf1b781a"),
	// 	Properties: &armstorsimple8000series.ManagerExtendedInfoProperties{
	// 		Algorithm: to.Ptr("None"),
	// 		IntegrityKey: to.Ptr("BIl+RHqO8PZ6DRvuXTTK7g=="),
	// 	},
	// }
}

Output:

func (*ManagersClient) CreateOrUpdate 

func (client *ManagersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, managerName string, parameters Manager, options *ManagersClientCreateOrUpdateOptions) (ManagersClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The manager.
  • options - ManagersClientCreateOrUpdateOptions contains the optional parameters for the ManagersClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().CreateOrUpdate(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", armstorsimple8000series.Manager{
		Location: to.Ptr("westus"),
		Properties: &armstorsimple8000series.ManagerProperties{
			CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
				Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
			},
			SKU: &armstorsimple8000series.ManagerSKU{
				Name: to.Ptr("Standard"),
			},
		},
	}, 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.Manager = armstorsimple8000series.Manager{
	// 	Name: to.Ptr("ManagerForSDKTest2"),
	// 	Type: to.Ptr("Microsoft.StorSimple/Managers"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest2"),
	// 	Location: to.Ptr("westus"),
	// 	Etag: to.Ptr("W/\"datetime'2017-06-19T16%3A13%3A18.5925197Z'\""),
	// 	Properties: &armstorsimple8000series.ManagerProperties{
	// 		CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
	// 			Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SKU: &armstorsimple8000series.ManagerSKU{
	// 			Name: to.Ptr("Standard"),
	// 		},
	// 	},
	// }
}

Output:

func (*ManagersClient) Delete 

func (client *ManagersClient) Delete(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientDeleteOptions) (ManagersClientDeleteResponse, error)

Delete - Deletes the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientDeleteOptions contains the optional parameters for the ManagersClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewManagersClient().Delete(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ManagersClient) DeleteExtendedInfo 

func (client *ManagersClient) DeleteExtendedInfo(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientDeleteExtendedInfoOptions) (ManagersClientDeleteExtendedInfoResponse, error)

DeleteExtendedInfo - Deletes the extended info of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientDeleteExtendedInfoOptions contains the optional parameters for the ManagersClient.DeleteExtendedInfo method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersDeleteExtendedInfo.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewManagersClient().DeleteExtendedInfo(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ManagersClient) Get 

func (client *ManagersClient) Get(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientGetOptions) (ManagersClientGetResponse, error)

Get - Returns the properties of the specified manager name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientGetOptions contains the optional parameters for the ManagersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().Get(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", 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.Manager = armstorsimple8000series.Manager{
	// 	Name: to.Ptr("ManagerForSDKTest2"),
	// 	Type: to.Ptr("Microsoft.StorSimple/Managers"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest2"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"TagName": to.Ptr("ForSDKTest"),
	// 	},
	// 	Etag: to.Ptr("W/\"datetime'2017-06-18T16%3A15%3A11.7946224Z'\""),
	// 	Properties: &armstorsimple8000series.ManagerProperties{
	// 		CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
	// 			Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SKU: &armstorsimple8000series.ManagerSKU{
	// 			Name: to.Ptr("Standard"),
	// 		},
	// 	},
	// }
}

Output:

func (*ManagersClient) GetActivationKey 

func (client *ManagersClient) GetActivationKey(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientGetActivationKeyOptions) (ManagersClientGetActivationKeyResponse, error)

GetActivationKey - Returns the activation key of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientGetActivationKeyOptions contains the optional parameters for the ManagersClient.GetActivationKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersGetActivationKey.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().GetActivationKey(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.Key = armstorsimple8000series.Key{
	// 	ActivationKey: to.Ptr("<activationKey>"),
	// }
}

Output:

func (*ManagersClient) GetDevicePublicEncryptionKey 

func (client *ManagersClient) GetDevicePublicEncryptionKey(ctx context.Context, deviceName string, resourceGroupName string, managerName string, options *ManagersClientGetDevicePublicEncryptionKeyOptions) (ManagersClientGetDevicePublicEncryptionKeyResponse, error)

GetDevicePublicEncryptionKey - Returns the public encryption key of the device. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientGetDevicePublicEncryptionKeyOptions contains the optional parameters for the ManagersClient.GetDevicePublicEncryptionKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersGetDevicePublicEncryptionKey.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().GetDevicePublicEncryptionKey(ctx, "sca01forsdktest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.PublicKey = armstorsimple8000series.PublicKey{
	// 	Key: to.Ptr("MIIDhjCCAm6gAwIBAgIQenen3LlBm4pFTfxko4pMMjANBgkqhkiG9w0BAQUFADB/MX0wewYDVQQDHnQAQwBCAF8AZgBhAGMAOAA2ADEAOAA3AC0AZgAzADYANgAtADQAYgA5ADUALQBiADQAMgBmAC0AZgBmADEAMAA3ADEANQAzAGQAOAA1AGUAXwA2ADMANgAzADMANwAzADcAMgAyADQANQAyADYANwAxADgAMDAeFw0xNzA2MTcwMDAwMDBaFw0yMDA2MjIxNDA3MDRaMH8xfTB7BgNVBAMedABDAEIAXwBmAGEAYwA4ADYAMQA4ADcALQBmADMANgA2AC0ANABiADkANQAtAGIANAAyAGYALQBmAGYAMQAwADcAMQA1ADMAZAA4ADUAZQBfADYAMwA2ADMAMwA3ADMANwAyADIANAA1ADIANgA3ADEAOAAwMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz6r59tE8cxAf5g4cCs/JyaLKKpLf+5OEpSAsPnxHR5FBOaebsOV1raGDOmqIrc1dSOXArAyY6NcqizKkdslA0aNftKjya8Kks618Jf61mQVNHhq5fEyqTuVNSe3FZn1I2Xs2yS2NEt3YQl+GwisLgoT5ecC27NFZMEgjw2EOJwD9fjZG21CoCBCErEf+5j5HJkXk1jrn/o4wI7OnCGswPhlbGgDzl8eKcfSvMKpib50faCWdsvglC097CGtSmgu0a73IwGnac1eZCAnoVQmjaIFsdMeVNOqFot23tj1HT+Dwb9cECN8wKT7bkHCGSS84+veGiR0XEh3Op1iZ46zsIQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQAfgsz7cH8NsiR5Ub0Pgx4T0cm8saMgJIfXZdMkCPTysdxU60EgmoDC/3KypFHAhhsBaFAvFrlXEybM4n4WLiDPeNM1Dr4xq56zzBhO0gO84Vp2PXk2VdybLfiobDyMb8cgAPXXcxzzb3jdRb1/bobiUuWBJvWSRHv5fON00c+BzloUzWJHY2BezNHBCof5awoMd+hzSfxX5WRFNW29rKgWW0h8A1cYNhaWGRxSA+U7YciYRyMDew8Nae1WCxVj9v/qsEXGd+jFDOckdJd5ySgXOQCPyG8j9/QM+Lsrsx29JnGsiiddaRfCtI4K8QdjkOjh0+RXMO3DeWhkFEmoOlNK"),
	// }
}

Output:

func (*ManagersClient) GetEncryptionSettings 

func (client *ManagersClient) GetEncryptionSettings(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientGetEncryptionSettingsOptions) (ManagersClientGetEncryptionSettingsResponse, error)

GetEncryptionSettings - Returns the encryption settings of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientGetEncryptionSettingsOptions contains the optional parameters for the ManagersClient.GetEncryptionSettings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersGetEncryptionSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().GetEncryptionSettings(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.EncryptionSettings = armstorsimple8000series.EncryptionSettings{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/encryptionSettings"),
	// 	ID: to.Ptr("/subscriptions/d3ebfe71-b7a9-4c57-92b9-68a2afde4de5/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/encryptionSettings/default"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.EncryptionSettingsProperties{
	// 		EncryptionStatus: to.Ptr(armstorsimple8000series.EncryptionStatusEnabled),
	// 		KeyRolloverStatus: to.Ptr(armstorsimple8000series.KeyRolloverStatusNotRequired),
	// 	},
	// }
}

Output:

func (*ManagersClient) GetExtendedInfo 

func (client *ManagersClient) GetExtendedInfo(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientGetExtendedInfoOptions) (ManagersClientGetExtendedInfoResponse, error)

GetExtendedInfo - Returns the extended information of the specified manager name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientGetExtendedInfoOptions contains the optional parameters for the ManagersClient.GetExtendedInfo method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersGetExtendedInfo.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().GetExtendedInfo(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.ManagerExtendedInfo = armstorsimple8000series.ManagerExtendedInfo{
	// 	Name: to.Ptr("vaultExtendedInfo"),
	// 	Type: to.Ptr("Microsoft.StorSimple/Managers/extendedInformation"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest1extendedInformation/vaultExtendedInfo"),
	// 	Etag: to.Ptr("bcb55c1e-29b2-42b3-a507-f2a0cd27a963"),
	// 	Properties: &armstorsimple8000series.ManagerExtendedInfoProperties{
	// 		Algorithm: to.Ptr("None"),
	// 		EncryptionKey: to.Ptr("MIIDQjCCAiqgAwIBAgIQQmzC+SfPepJF20zGMFBbJjANBgkqhkiG9w0BAQUFADBdMVswWQYDVQQDHlIAQwBCAF8AMgA0ADMANQAyADQAMwAzADYANwAzADkAOAA0ADcAMQA5ADEANQBfADYAMwA2ADMAMgAzADQAMgA2ADEAOQAxADMANgAwADgAOAAxMB4XDTE3MDYwMTA3MDAwMFoXDTIwMDYwNjEwNDMzOVowXTFbMFkGA1UEAx5SAEMAQgBfADIANAAzADUAMgA0ADMAMwA2ADcAMwA5ADgANAA3ADEAOQAxADUAXwA2ADMANgAzADIAMwA0ADIANgAxADkAMQAzADYAMAA4ADgAMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJvO+6ytUY0Z/x2GVE2grF8L7XvuJ63mN3ebHKncQVlJiKjyfuG7iDzQUfW0HZZ/TtgxineJLHPNg67NIxjwaqhr+c0kbR6VUtyShqBxfqFAQt+Lx1bySxZ5S/G/ZSKc++evMwhYMoCkU8k1uQWOcco4N4+7HrB3XPkZee1TckhXnsjS5d9OawNCfVxt9PsCEwhX8Ezj58u1FN21OOosxKdSBTaRI1Hh+kIAP2ZPeldRvgjJ+HVRzR7hqm6OLVg/azaSziGMkP+UmvvwsyG8EI2xfhkF3K11rEFRng0fB06V01LN11hpVEL1uvNbGbfkmlIjEWmiwujiFGMdVK0eYfUCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAcztBrLgiL3fqykBXQ/3GjJXZ1PX7z9CFjoLkHdv6ZG+mkAkAkjaOxYvzCueIhX61u2zOgg9AJYW+J3BKvSGe5W5O7W8OLL0TRCmzSASH4Bap9oZmb6exs8D45aPgGRW/Mmhm2W+jGk9NIg6W8GFPksqP2XY3DlKSfAztzIU86fPRfXlNHknvpp7rt+gv7WjbSt8smSTJ7PJwUh9s/oYL+k5GPtYxHkB8A7YCgVj0rk6v9uHvhmOXm3Cm+1wOJA9ebk0U1CUUJ8maMi89JvFuxhps8kBObnp6M52AzVErMwqn9zH0gbDRlh9fIQPwvXsXm7DosxccD5KuG9/oX4eqfQ=="),
	// 		EncryptionKeyThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
	// 		IntegrityKey: to.Ptr("x3V1JcHquNW1P87Vgz10Pw=="),
	// 	},
	// }
}

Output:

func (*ManagersClient) GetPublicEncryptionKey 

func (client *ManagersClient) GetPublicEncryptionKey(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientGetPublicEncryptionKeyOptions) (ManagersClientGetPublicEncryptionKeyResponse, error)

GetPublicEncryptionKey - Returns the symmetric encrypted public encryption key of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientGetPublicEncryptionKeyOptions contains the optional parameters for the ManagersClient.GetPublicEncryptionKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersGetPublicEncryptionKey.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().GetPublicEncryptionKey(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.SymmetricEncryptedSecret = armstorsimple8000series.SymmetricEncryptedSecret{
	// 	EncryptionAlgorithm: to.Ptr(armstorsimple8000series.EncryptionAlgorithmAES256),
	// 	Value: to.Ptr("EAAAACcRUjoLMPhaI/fH4EFvdYv355vUfR6L+21trxRIl3toWpu91W804sPvAFQbCjwPAdG2epj8GYgXO44DZVHvf8x/X0f5cHhvLlcdx4yo7hdcEqoSpKwKytik8GfDTgsiqcEG4Fod05JF7E9CSAvFGOFf4hFfdQWjeiU3kTP5wCM4lJCCUWqI2uPSc5Izmg+XmumlXACavVKVtRzDEki4cbNCFc0tR1RAdMMDgziQmJFVlKNIvOOUSmurE1a5rXyUP8n3VvuCokIjlSSQSyySOSk/cWicAXjiBVHbJ6pFjJkDFLV/hTi/xdnrywVHJ7fDrdyBtMIRTZU6085lp/kWBkjVt5RNiPy9p/xHjOlGxa6DUSxYmUPZKzQytNQ49uLCVTH/JvUV0tWM6LU9bLvZxOYTJfD8hiHNaHk+XbrsX+AE4XrOj2cN/Ih1tULcX12cS21OLVYadWm9fkvU0U/csDu+r7PuwH/rBO1Bw/vmv2Kochj6h1akedro6R4+0txxu2t3HVh1a9Xc1/2xYNnSv/06/ekxEzxYwe7Sb6yAHZYZ4nCdS1FiGsBJ+2U1iSYgzDUDYcn9vwmFSJMdLlujwp5gNEWR7hZFrnmbPMtq+kBmuWA1mjJDTMZhefsJHLL3sEB1qqHTOaj8yAxM2oWYOvbc6/E/osy+qve0f1HAFWAsmgK2wOZ/yM9myAQDNFmVnxGibjNVb/svTIgfvYfSpDqWOKISDW1T4A8eHUk2Gz/8xnx+dSArjuVuLFk7u96tMbw4glEc74HNahtZbY8cvyFIStLugxrwlYmFlgN86tly9SZicd0x2cbsrIYySX4gvuSsgOwcQigoyVxFojE9u0rJa0gJYcTS4YbBjnd0+HGQJG604TKPb9hMmH7V1FbmH3bJc03PAOfPdNDgjA61uK7PgTEaamdIyoDg/FjBWpFiVJhdIu+m7Mm1gNf9GwXyv9XjQ9P42aAc/vUKzkvJESQ4uqkYFSlYTgyvMUyCpeRI9U2OD3iziNj5/Y1wr4eJ5BLePP6lVTR+UnWDjyu863d7N5grH7sWof1b+TZFb9Il6vMHA3BA9ujiFedQwqUdIdkdpKZuOBhkq+Ij9nMTQtIG1ODEpPetEXxaAoCKCS9DcBdmsN3MLvN46IIWN//vBmkABP3oUwnPoCgyx7P5V4NUpAJbm70mO1Mo6a1JEcFiqXJNZa9BO6v8e+9mRZokpDHOJCIJ0UwLpevpbKvBnLx9mcSNMN9JvcgGQOKvxt2/vBZdOv0DcO0aSYkV+bv+4ZAtLsBKOWeQTJ5CtSPs17m/y5a8+vxirvWxiGuMsNFBLHrD1aSAGBPd/5llsEde/TfIgWs+j8GW9Ep6E64LMjqALF0L5BZOSShleMbb2seTNi+d+0xOg5a2nuSRvPhcxFhRqPykmOQ/wAAMm1fE5K2l+jJfE3gZ5J3CdLXulmZHM1hV0oAGlqutqM6SCW7Czg813162G99tQb2l90MD1G01KkO7ppzn1Hy6MOazanOCzwRH6CMqZw09mEU9JozEKw=="),
	// 	ValueCertificateThumbprint: to.Ptr("D3411C80B443A01C51B8A8295A21EE82535972D0"),
	// }
}

Output:

func (*ManagersClient) NewListByResourceGroupPager 

func (client *ManagersClient) NewListByResourceGroupPager(resourceGroupName string, options *ManagersClientListByResourceGroupOptions) *runtime.Pager[ManagersClientListByResourceGroupResponse]

NewListByResourceGroupPager - Retrieves all the managers in a resource group.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • options - ManagersClientListByResourceGroupOptions contains the optional parameters for the ManagersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewManagersClient().NewListByResourceGroupPager("ResourceGroupForSDKTest", 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.ManagerList = armstorsimple8000series.ManagerList{
		// 	Value: []*armstorsimple8000series.Manager{
		// 		{
		// 			Name: to.Ptr("ManagerForSDKTest"),
		// 			Type: to.Ptr("Microsoft.StorSimple/Managers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest"),
		// 			Location: to.Ptr("westus"),
		// 			Etag: to.Ptr("W/\"datetime'2017-06-05T09%3A36%3A00.8822928Z'\""),
		// 			Properties: &armstorsimple8000series.ManagerProperties{
		// 				CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
		// 					Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				SKU: &armstorsimple8000series.ManagerSKU{
		// 					Name: to.Ptr("Standard"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ManagerForSDKTest1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/Managers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest1"),
		// 			Location: to.Ptr("westus"),
		// 			Etag: to.Ptr("W/\"datetime'2017-06-14T11%3A27%3A23.8667962Z'\""),
		// 			Properties: &armstorsimple8000series.ManagerProperties{
		// 				CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
		// 					Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				SKU: &armstorsimple8000series.ManagerSKU{
		// 					Name: to.Ptr("Standard"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ManagersClient) NewListFeatureSupportStatusPager 

func (client *ManagersClient) NewListFeatureSupportStatusPager(resourceGroupName string, managerName string, options *ManagersClientListFeatureSupportStatusOptions) *runtime.Pager[ManagersClientListFeatureSupportStatusResponse]

NewListFeatureSupportStatusPager - Lists the features and their support status

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientListFeatureSupportStatusOptions contains the optional parameters for the ManagersClient.NewListFeatureSupportStatusPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersListFeatureSupportStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewManagersClient().NewListFeatureSupportStatusPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", &armstorsimple8000series.ManagersClientListFeatureSupportStatusOptions{Filter: 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.FeatureList = armstorsimple8000series.FeatureList{
		// 	Value: []*armstorsimple8000series.Feature{
		// 		{
		// 			Name: to.Ptr("BandwidthThrottling"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("OtherCloud"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusUnsupportedDeviceVersion),
		// 		},
		// 		{
		// 			Name: to.Ptr("DeviceUpdate"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusNotAvailable),
		// 		},
		// 		{
		// 			Name: to.Ptr("ControllerRestartFeature"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("GetDRTargetDevicesApi"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("Migration"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("Update"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("GetSupportedVirtualApplianceVersionInfoApi"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("LocalOnlyVolume"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("PremiumSVA"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusSupported),
		// 		},
		// 		{
		// 			Name: to.Ptr("VersionBasedARMApiAccess"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusNotAvailable),
		// 		},
		// 		{
		// 			Name: to.Ptr("SubscriptionBasedARMApiAccess"),
		// 			Status: to.Ptr(armstorsimple8000series.FeatureSupportStatusNotAvailable),
		// 	}},
		// }
	}
}

Output:

func (*ManagersClient) NewListMetricDefinitionPager 

func (client *ManagersClient) NewListMetricDefinitionPager(resourceGroupName string, managerName string, options *ManagersClientListMetricDefinitionOptions) *runtime.Pager[ManagersClientListMetricDefinitionResponse]

NewListMetricDefinitionPager - Gets the metric definitions for the specified manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientListMetricDefinitionOptions contains the optional parameters for the ManagersClient.NewListMetricDefinitionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersListMetricDefinition.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewManagersClient().NewListMetricDefinitionPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.MetricDefinitionList = armstorsimple8000series.MetricDefinitionList{
		// 	Value: []*armstorsimple8000series.MetricDefinition{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Tiered Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageTieredUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Manager"),
		// 					Value: to.Ptr("ManagerForSDKTest1"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Locally Pinned Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageLocallyPinnedUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Manager"),
		// 					Value: to.Ptr("ManagerForSDKTest1"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Cloud Storage Used"),
		// 				Value: to.Ptr("CloudStorageUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Manager"),
		// 					Value: to.Ptr("ManagerForSDKTest1"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 	}},
		// }
	}
}

Output:

func (*ManagersClient) NewListMetricsPager 

func (client *ManagersClient) NewListMetricsPager(resourceGroupName string, managerName string, filter string, options *ManagersClientListMetricsOptions) *runtime.Pager[ManagersClientListMetricsResponse]

NewListMetricsPager - Gets the metrics for the specified manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • filter - OData Filter options
  • options - ManagersClientListMetricsOptions contains the optional parameters for the ManagersClient.NewListMetricsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersListMetrics.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewManagersClient().NewListMetricsPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", "name/value%20eq%20'PrimaryStorageTieredUsed'%20and%20timeGrain%20eq%20'PT1H'%20and%20startTime%20ge%20'2017-06-17T18:30:00Z'%20and%20endTime%20le%20'2017-06-21T18:30:00Z'%20and%20category%20eq%20'CapacityUtilization'", 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.MetricList = armstorsimple8000series.MetricList{
		// 	Value: []*armstorsimple8000series.Metrics{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Tiered Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageTieredUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/metrics"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Manager"),
		// 					Value: to.Ptr("ManagerForSDKTest1"),
		// 			}},
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-21T18:30:00.000Z"); return t}()),
		// 			PrimaryAggregation: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1"),
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-17T18:30:00.000Z"); return t}()),
		// 			TimeGrain: to.Ptr("01:00:00"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 			Values: []*armstorsimple8000series.MetricData{
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ManagersClient) NewListPager 

func (client *ManagersClient) NewListPager(options *ManagersClientListOptions) *runtime.Pager[ManagersClientListResponse]

NewListPager - Retrieves all the managers in a subscription.

Generated from API version 2017-06-01

  • options - ManagersClientListOptions contains the optional parameters for the ManagersClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewManagersClient().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.ManagerList = armstorsimple8000series.ManagerList{
		// 	Value: []*armstorsimple8000series.Manager{
		// 		{
		// 			Name: to.Ptr("Manager1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/Managers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroup1/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest"),
		// 			Location: to.Ptr("westus"),
		// 			Etag: to.Ptr("W/\"datetime'2017-06-05T09%3A36%3A00.8822928Z'\""),
		// 			Properties: &armstorsimple8000series.ManagerProperties{
		// 				CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
		// 					Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				SKU: &armstorsimple8000series.ManagerSKU{
		// 					Name: to.Ptr("Standard"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ManagerForSDKTest"),
		// 			Type: to.Ptr("Microsoft.StorSimple/Managers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest"),
		// 			Location: to.Ptr("westus"),
		// 			Etag: to.Ptr("W/\"datetime'2017-06-05T09%3A36%3A00.8822928Z'\""),
		// 			Properties: &armstorsimple8000series.ManagerProperties{
		// 				CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
		// 					Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				SKU: &armstorsimple8000series.ManagerSKU{
		// 					Name: to.Ptr("Standard"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ManagerForSDKTest1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/Managers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest1"),
		// 			Location: to.Ptr("westus"),
		// 			Etag: to.Ptr("W/\"datetime'2017-06-14T11%3A27%3A23.8667962Z'\""),
		// 			Properties: &armstorsimple8000series.ManagerProperties{
		// 				CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
		// 					Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				SKU: &armstorsimple8000series.ManagerSKU{
		// 					Name: to.Ptr("Standard"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ManagerForSDKTest2"),
		// 			Type: to.Ptr("Microsoft.StorSimple/Managers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest2"),
		// 			Location: to.Ptr("westus"),
		// 			Tags: map[string]*string{
		// 				"TagName": to.Ptr("ForSDKTest"),
		// 			},
		// 			Etag: to.Ptr("W/\"datetime'2017-06-18T16%3A13%3A43.8476579Z'\""),
		// 			Properties: &armstorsimple8000series.ManagerProperties{
		// 				CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
		// 					Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
		// 				},
		// 				ProvisioningState: to.Ptr("Succeeded"),
		// 				SKU: &armstorsimple8000series.ManagerSKU{
		// 					Name: to.Ptr("Standard"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ManagersClient) RegenerateActivationKey 

func (client *ManagersClient) RegenerateActivationKey(ctx context.Context, resourceGroupName string, managerName string, options *ManagersClientRegenerateActivationKeyOptions) (ManagersClientRegenerateActivationKeyResponse, error)

RegenerateActivationKey - Re-generates and returns the activation key of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - ManagersClientRegenerateActivationKeyOptions contains the optional parameters for the ManagersClient.RegenerateActivationKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersRegenerateActivationKey.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().RegenerateActivationKey(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", 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.Key = armstorsimple8000series.Key{
	// 	ActivationKey: to.Ptr("<activationKey>"),
	// }
}

Output:

func (*ManagersClient) Update 

func (client *ManagersClient) Update(ctx context.Context, resourceGroupName string, managerName string, parameters ManagerPatch, options *ManagersClientUpdateOptions) (ManagersClientUpdateResponse, error)

Update - Updates the StorSimple Manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The manager update parameters.
  • options - ManagersClientUpdateOptions contains the optional parameters for the ManagersClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().Update(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", armstorsimple8000series.ManagerPatch{
		Tags: map[string]*string{
			"TagName": to.Ptr("ForSDKTest"),
		},
	}, 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.Manager = armstorsimple8000series.Manager{
	// 	Name: to.Ptr("ManagerForSDKTest2"),
	// 	Type: to.Ptr("Microsoft.StorSimple/Managers"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest2"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"TagName": to.Ptr("ForSDKTest"),
	// 	},
	// 	Etag: to.Ptr("W/\"datetime'2017-06-18T16%3A13%3A43.8476579Z'\""),
	// 	Properties: &armstorsimple8000series.ManagerProperties{
	// 		CisIntrinsicSettings: &armstorsimple8000series.ManagerIntrinsicSettings{
	// 			Type: to.Ptr(armstorsimple8000series.ManagerTypeGardaV1),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SKU: &armstorsimple8000series.ManagerSKU{
	// 			Name: to.Ptr("Standard"),
	// 		},
	// 	},
	// }
}

Output:

func (*ManagersClient) UpdateExtendedInfo 

func (client *ManagersClient) UpdateExtendedInfo(ctx context.Context, resourceGroupName string, managerName string, ifMatch string, parameters ManagerExtendedInfo, options *ManagersClientUpdateExtendedInfoOptions) (ManagersClientUpdateExtendedInfoResponse, error)

UpdateExtendedInfo - Updates the extended info of the manager. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • ifMatch - Pass the ETag of ExtendedInfo fetched from GET call
  • parameters - The manager extended information.
  • options - ManagersClientUpdateExtendedInfoOptions contains the optional parameters for the ManagersClient.UpdateExtendedInfo method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/ManagersUpdateExtendedInfo.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewManagersClient().UpdateExtendedInfo(ctx, "ResourceGroupForSDKTest", "ManagerForSDKTest2", "674ab9df-af56-4c5c-a5ca-2bddcf1b781a", armstorsimple8000series.ManagerExtendedInfo{
		Etag: to.Ptr("674ab9df-af56-4c5c-a5ca-2bddcf1b781a"),
		Properties: &armstorsimple8000series.ManagerExtendedInfoProperties{
			Algorithm:    to.Ptr("SHA256"),
			IntegrityKey: to.Ptr("BIl+RHqO8PZ6DRvuXTTK7g=="),
		},
	}, 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.ManagerExtendedInfo = armstorsimple8000series.ManagerExtendedInfo{
	// 	Name: to.Ptr("vaultExtendedInfo"),
	// 	Type: to.Ptr("Microsoft.StorSimple/Managers/extendedInformation"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/Managers/ManagerForSDKTest2extendedInformation/vaultExtendedInfo"),
	// 	Etag: to.Ptr("7d062cd9-c325-422b-8bff-0e702b8659ed"),
	// 	Properties: &armstorsimple8000series.ManagerExtendedInfoProperties{
	// 		Algorithm: to.Ptr("SHA256"),
	// 		IntegrityKey: to.Ptr("BIl+RHqO8PZ6DRvuXTTK7g=="),
	// 	},
	// }
}

Output:

type ManagersClientCreateExtendedInfoOptions 

type ManagersClientCreateExtendedInfoOptions struct {
}

ManagersClientCreateExtendedInfoOptions contains the optional parameters for the ManagersClient.CreateExtendedInfo method.

type ManagersClientCreateExtendedInfoResponse 

type ManagersClientCreateExtendedInfoResponse struct {
	// The extended info of the manager.
	ManagerExtendedInfo
}

ManagersClientCreateExtendedInfoResponse contains the response from method ManagersClient.CreateExtendedInfo.

type ManagersClientCreateOrUpdateOptions 

type ManagersClientCreateOrUpdateOptions struct {
}

ManagersClientCreateOrUpdateOptions contains the optional parameters for the ManagersClient.CreateOrUpdate method.

type ManagersClientCreateOrUpdateResponse 

type ManagersClientCreateOrUpdateResponse struct {
	// The StorSimple Manager.
	Manager
}

ManagersClientCreateOrUpdateResponse contains the response from method ManagersClient.CreateOrUpdate.

type ManagersClientDeleteExtendedInfoOptions 

type ManagersClientDeleteExtendedInfoOptions struct {
}

ManagersClientDeleteExtendedInfoOptions contains the optional parameters for the ManagersClient.DeleteExtendedInfo method.

type ManagersClientDeleteExtendedInfoResponse 

type ManagersClientDeleteExtendedInfoResponse struct {
}

ManagersClientDeleteExtendedInfoResponse contains the response from method ManagersClient.DeleteExtendedInfo.

type ManagersClientDeleteOptions 

type ManagersClientDeleteOptions struct {
}

ManagersClientDeleteOptions contains the optional parameters for the ManagersClient.Delete method.

type ManagersClientDeleteResponse 

type ManagersClientDeleteResponse struct {
}

ManagersClientDeleteResponse contains the response from method ManagersClient.Delete.

type ManagersClientGetActivationKeyOptions 

type ManagersClientGetActivationKeyOptions struct {
}

ManagersClientGetActivationKeyOptions contains the optional parameters for the ManagersClient.GetActivationKey method.

type ManagersClientGetActivationKeyResponse 

type ManagersClientGetActivationKeyResponse struct {
	// The key.
	Key
}

ManagersClientGetActivationKeyResponse contains the response from method ManagersClient.GetActivationKey.

type ManagersClientGetDevicePublicEncryptionKeyOptions 

type ManagersClientGetDevicePublicEncryptionKeyOptions struct {
}

ManagersClientGetDevicePublicEncryptionKeyOptions contains the optional parameters for the ManagersClient.GetDevicePublicEncryptionKey method.

type ManagersClientGetDevicePublicEncryptionKeyResponse 

type ManagersClientGetDevicePublicEncryptionKeyResponse struct {
	// The public key.
	PublicKey
}

ManagersClientGetDevicePublicEncryptionKeyResponse contains the response from method ManagersClient.GetDevicePublicEncryptionKey.

type ManagersClientGetEncryptionSettingsOptions 

type ManagersClientGetEncryptionSettingsOptions struct {
}

ManagersClientGetEncryptionSettingsOptions contains the optional parameters for the ManagersClient.GetEncryptionSettings method.

type ManagersClientGetEncryptionSettingsResponse 

type ManagersClientGetEncryptionSettingsResponse struct {
	// The encryption settings.
	EncryptionSettings
}

ManagersClientGetEncryptionSettingsResponse contains the response from method ManagersClient.GetEncryptionSettings.

type ManagersClientGetExtendedInfoOptions 

type ManagersClientGetExtendedInfoOptions struct {
}

ManagersClientGetExtendedInfoOptions contains the optional parameters for the ManagersClient.GetExtendedInfo method.

type ManagersClientGetExtendedInfoResponse 

type ManagersClientGetExtendedInfoResponse struct {
	// The extended info of the manager.
	ManagerExtendedInfo
}

ManagersClientGetExtendedInfoResponse contains the response from method ManagersClient.GetExtendedInfo.

type ManagersClientGetOptions 

type ManagersClientGetOptions struct {
}

ManagersClientGetOptions contains the optional parameters for the ManagersClient.Get method.

type ManagersClientGetPublicEncryptionKeyOptions 

type ManagersClientGetPublicEncryptionKeyOptions struct {
}

ManagersClientGetPublicEncryptionKeyOptions contains the optional parameters for the ManagersClient.GetPublicEncryptionKey method.

type ManagersClientGetPublicEncryptionKeyResponse 

type ManagersClientGetPublicEncryptionKeyResponse struct {
	// Represents the secrets encrypted using Symmetric Encryption Key.
	SymmetricEncryptedSecret
}

ManagersClientGetPublicEncryptionKeyResponse contains the response from method ManagersClient.GetPublicEncryptionKey.

type ManagersClientGetResponse 

type ManagersClientGetResponse struct {
	// The StorSimple Manager.
	Manager
}

ManagersClientGetResponse contains the response from method ManagersClient.Get.

type ManagersClientListByResourceGroupOptions 

type ManagersClientListByResourceGroupOptions struct {
}

ManagersClientListByResourceGroupOptions contains the optional parameters for the ManagersClient.NewListByResourceGroupPager method.

type ManagersClientListByResourceGroupResponse 

type ManagersClientListByResourceGroupResponse struct {
	// The list of StorSimple Managers.
	ManagerList
}

ManagersClientListByResourceGroupResponse contains the response from method ManagersClient.NewListByResourceGroupPager.

type ManagersClientListFeatureSupportStatusOptions 

type ManagersClientListFeatureSupportStatusOptions struct {
	// OData Filter options
	Filter *string
}

ManagersClientListFeatureSupportStatusOptions contains the optional parameters for the ManagersClient.NewListFeatureSupportStatusPager method.

type ManagersClientListFeatureSupportStatusResponse 

type ManagersClientListFeatureSupportStatusResponse struct {
	// The collections of features.
	FeatureList
}

ManagersClientListFeatureSupportStatusResponse contains the response from method ManagersClient.NewListFeatureSupportStatusPager.

type ManagersClientListMetricDefinitionOptions 

type ManagersClientListMetricDefinitionOptions struct {
}

ManagersClientListMetricDefinitionOptions contains the optional parameters for the ManagersClient.NewListMetricDefinitionPager method.

type ManagersClientListMetricDefinitionResponse 

type ManagersClientListMetricDefinitionResponse struct {
	// The list of metric definitions.
	MetricDefinitionList
}

ManagersClientListMetricDefinitionResponse contains the response from method ManagersClient.NewListMetricDefinitionPager.

type ManagersClientListMetricsOptions 

type ManagersClientListMetricsOptions struct {
}

ManagersClientListMetricsOptions contains the optional parameters for the ManagersClient.NewListMetricsPager method.

type ManagersClientListMetricsResponse 

type ManagersClientListMetricsResponse struct {
	// The metric list.
	MetricList
}

ManagersClientListMetricsResponse contains the response from method ManagersClient.NewListMetricsPager.

type ManagersClientListOptions 

type ManagersClientListOptions struct {
}

ManagersClientListOptions contains the optional parameters for the ManagersClient.NewListPager method.

type ManagersClientListResponse 

type ManagersClientListResponse struct {
	// The list of StorSimple Managers.
	ManagerList
}

ManagersClientListResponse contains the response from method ManagersClient.NewListPager.

type ManagersClientRegenerateActivationKeyOptions 

type ManagersClientRegenerateActivationKeyOptions struct {
}

ManagersClientRegenerateActivationKeyOptions contains the optional parameters for the ManagersClient.RegenerateActivationKey method.

type ManagersClientRegenerateActivationKeyResponse 

type ManagersClientRegenerateActivationKeyResponse struct {
	// The key.
	Key
}

ManagersClientRegenerateActivationKeyResponse contains the response from method ManagersClient.RegenerateActivationKey.

type ManagersClientUpdateExtendedInfoOptions 

type ManagersClientUpdateExtendedInfoOptions struct {
}

ManagersClientUpdateExtendedInfoOptions contains the optional parameters for the ManagersClient.UpdateExtendedInfo method.

type ManagersClientUpdateExtendedInfoResponse 

type ManagersClientUpdateExtendedInfoResponse struct {
	// The extended info of the manager.
	ManagerExtendedInfo
}

ManagersClientUpdateExtendedInfoResponse contains the response from method ManagersClient.UpdateExtendedInfo.

type ManagersClientUpdateOptions 

type ManagersClientUpdateOptions struct {
}

ManagersClientUpdateOptions contains the optional parameters for the ManagersClient.Update method.

type ManagersClientUpdateResponse 

type ManagersClientUpdateResponse struct {
	// The StorSimple Manager.
	Manager
}

ManagersClientUpdateResponse contains the response from method ManagersClient.Update.

type MetricAggregationType 

type MetricAggregationType string

MetricAggregationType - The metric aggregation type. 

const (
	MetricAggregationTypeAverage MetricAggregationType = "Average"
	MetricAggregationTypeLast    MetricAggregationType = "Last"
	MetricAggregationTypeMaximum MetricAggregationType = "Maximum"
	MetricAggregationTypeMinimum MetricAggregationType = "Minimum"
	MetricAggregationTypeNone    MetricAggregationType = "None"
	MetricAggregationTypeTotal   MetricAggregationType = "Total"
)

func PossibleMetricAggregationTypeValues 

func PossibleMetricAggregationTypeValues() []MetricAggregationType

PossibleMetricAggregationTypeValues returns the possible values for the MetricAggregationType const type.

type MetricAvailablity 

type MetricAvailablity struct {
	// The retention period for the metric at the specified timegrain.
	Retention *string

	// The aggregation interval for the metric.
	TimeGrain *string
}

MetricAvailablity - The metric availability.

func (MetricAvailablity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricAvailablity.

func (*MetricAvailablity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricAvailablity.

type MetricData 

type MetricData struct {
	// The average of all samples at the time stamp.
	Average *float64

	// The count of all samples at the time stamp.
	Count *int32

	// The maximum of all samples at the time stamp.
	Maximum *float64

	// The minimum of all samples at the time stamp.
	Minimum *float64

	// The sum of all samples at the time stamp.
	Sum *float64

	// The time stamp of the metric data.
	TimeStamp *time.Time
}

MetricData - The metric data.

func (MetricData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricData.

func (*MetricData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricData.

type MetricDefinition 

type MetricDefinition struct {
	// The category of the metric.
	Category *string

	// The available metric dimensions.
	Dimensions []*MetricDimension

	// The available metric granularities.
	MetricAvailabilities []*MetricAvailablity

	// The metric name.
	Name *MetricName

	// The metric aggregation type.
	PrimaryAggregationType *MetricAggregationType

	// The metric source ID.
	ResourceID *string

	// The metric definition type.
	Type *string

	// The metric unit.
	Unit *MetricUnit
}

MetricDefinition - The monitoring metric definition.

func (MetricDefinition) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricDefinition.

func (*MetricDefinition) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricDefinition.

type MetricDefinitionList 

type MetricDefinitionList struct {
	// The list of metric definitions.
	Value []*MetricDefinition
}

MetricDefinitionList - The list of metric definitions.

func (MetricDefinitionList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricDefinitionList.

func (*MetricDefinitionList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricDefinitionList.

type MetricDimension 

type MetricDimension struct {
	// The metric dimension name.
	Name *string

	// The metric dimension values.
	Value *string
}

MetricDimension - The metric dimension. It indicates the source of the metric.

func (MetricDimension) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricDimension.

func (*MetricDimension) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricDimension.

type MetricFilter 

type MetricFilter struct {
	// REQUIRED; Specifies the category of the metrics to be filtered. E.g., "CapacityUtilization". Valid values are the ones
	// returned as the field "category" in the ListMetricDefinitions call. Only 'Equality'
	// operator is supported for this property.
	Category *string

	// Specifies the source(the dimension) of the metrics to be filtered. Only 'Equality' operator is supported for this property.
	Dimensions *DimensionFilter

	// Specifies the end time of the time range to be queried. Only 'Less Than Or Equal To' operator is supported for this property.
	EndTime *time.Time

	// Specifies the metric name filter specifying the name of the metric to be filtered on. Only 'Equality' operator is supported
	// for this property.
	Name *MetricNameFilter

	// Specifies the start time of the time range to be queried. Only 'Greater Than Or Equal To' operator is supported for this
	// property.
	StartTime *time.Time

	// Specifies the time granularity of the metrics to be returned. E.g., "P1D". Valid values are the ones returned as the field
	// "timeGrain" in the ListMetricDefinitions call. Only 'Equality' operator is
	// supported for this property.
	TimeGrain *string
}

MetricFilter - The OData filters to be used for metrics.

func (MetricFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricFilter.

func (*MetricFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricFilter.

type MetricList 

type MetricList struct {
	// The value.
	Value []*Metrics
}

MetricList - The metric list.

func (MetricList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricList.

func (*MetricList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricList.

type MetricName 

type MetricName struct {
	// The localized metric name.
	LocalizedValue *string

	// The metric name.
	Value *string
}

MetricName - The metric name.

func (MetricName) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricName.

func (*MetricName) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricName.

type MetricNameFilter 

type MetricNameFilter struct {
	// Specifies the metric name to be filtered on. E.g., CloudStorageUsed. Valid values are the ones returned in the field "name"
	// in the ListMetricDefinitions call. Only 'Equality' operator is supported for
	// this property.
	Value *string
}

MetricNameFilter - The metric name filter, specifying the name of the metric to be filtered on.

func (MetricNameFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricNameFilter.

func (*MetricNameFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricNameFilter.

type MetricUnit 

type MetricUnit string

MetricUnit - The metric unit. 

const (
	MetricUnitBytes          MetricUnit = "Bytes"
	MetricUnitBytesPerSecond MetricUnit = "BytesPerSecond"
	MetricUnitCount          MetricUnit = "Count"
	MetricUnitCountPerSecond MetricUnit = "CountPerSecond"
	MetricUnitPercent        MetricUnit = "Percent"
	MetricUnitSeconds        MetricUnit = "Seconds"
)

func PossibleMetricUnitValues 

func PossibleMetricUnitValues() []MetricUnit

PossibleMetricUnitValues returns the possible values for the MetricUnit const type.

type Metrics 

type Metrics struct {
	// The metric dimensions.
	Dimensions []*MetricDimension

	// The end time of the metric data.
	EndTime *time.Time

	// The name of the metric.
	Name *MetricName

	// The metric aggregation type.
	PrimaryAggregation *MetricAggregationType

	// The ID of metric source.
	ResourceID *string

	// The start time of the metric data.
	StartTime *time.Time

	// The time granularity of the metric data.
	TimeGrain *string

	// The type of the metric data.
	Type *string

	// The unit of the metric data.
	Unit *MetricUnit

	// The list of the metric data.
	Values []*MetricData
}

Metrics - The monitoring metric.

func (Metrics) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Metrics.

func (*Metrics) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Metrics.

type MonitoringStatus 

type MonitoringStatus string

MonitoringStatus - The monitoring status of the volume. 

const (
	MonitoringStatusDisabled MonitoringStatus = "Disabled"
	MonitoringStatusEnabled  MonitoringStatus = "Enabled"
)

func PossibleMonitoringStatusValues 

func PossibleMonitoringStatusValues() []MonitoringStatus

PossibleMonitoringStatusValues returns the possible values for the MonitoringStatus const type.

type NetInterfaceID 

type NetInterfaceID string

NetInterfaceID - The ID of the network adapter. 

const (
	NetInterfaceIDData0   NetInterfaceID = "Data0"
	NetInterfaceIDData1   NetInterfaceID = "Data1"
	NetInterfaceIDData2   NetInterfaceID = "Data2"
	NetInterfaceIDData3   NetInterfaceID = "Data3"
	NetInterfaceIDData4   NetInterfaceID = "Data4"
	NetInterfaceIDData5   NetInterfaceID = "Data5"
	NetInterfaceIDInvalid NetInterfaceID = "Invalid"
)

func PossibleNetInterfaceIDValues 

func PossibleNetInterfaceIDValues() []NetInterfaceID

PossibleNetInterfaceIDValues returns the possible values for the NetInterfaceID const type.

type NetInterfaceStatus 

type NetInterfaceStatus string

NetInterfaceStatus - Value indicating status of network adapter. 

const (
	NetInterfaceStatusDisabled NetInterfaceStatus = "Disabled"
	NetInterfaceStatusEnabled  NetInterfaceStatus = "Enabled"
)

func PossibleNetInterfaceStatusValues 

func PossibleNetInterfaceStatusValues() []NetInterfaceStatus

PossibleNetInterfaceStatusValues returns the possible values for the NetInterfaceStatus const type.

type NetworkAdapterList 

type NetworkAdapterList struct {
	// REQUIRED; The value.
	Value []*NetworkAdapters
}

NetworkAdapterList - The collection of network adapters on the device.

func (NetworkAdapterList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkAdapterList.

func (*NetworkAdapterList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkAdapterList.

type NetworkAdapters 

type NetworkAdapters struct {
	// REQUIRED; The ID of the network adapter.
	InterfaceID *NetInterfaceID

	// REQUIRED; Value indicating cloud and ISCSI status of network adapter.
	IscsiAndCloudStatus *ISCSIAndCloudStatus

	// REQUIRED; The mode of network adapter, either IPv4, IPv6 or both.
	Mode *NetworkMode

	// REQUIRED; Value indicating status of network adapter.
	NetInterfaceStatus *NetInterfaceStatus

	// Value indicating whether this instance is default.
	IsDefault *bool

	// The IPv4 configuration of the network adapter.
	NicIPv4Settings *NicIPv4

	// The IPv6 configuration of the network adapter.
	NicIPv6Settings *NicIPv6

	// The speed of the network adapter.
	Speed *int64
}

NetworkAdapters - Represents the network adapter on device.

func (NetworkAdapters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkAdapters.

func (*NetworkAdapters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkAdapters.

type NetworkInterfaceData0Settings 

type NetworkInterfaceData0Settings struct {
	// The controller 1's IPv4 address.
	ControllerOneIP *string

	// The controller 0's IPv4 address.
	ControllerZeroIP *string
}

NetworkInterfaceData0Settings - The 'Data 0' network interface card settings.

func (NetworkInterfaceData0Settings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkInterfaceData0Settings.

func (*NetworkInterfaceData0Settings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkInterfaceData0Settings.

type NetworkMode 

type NetworkMode string

NetworkMode - The mode of network adapter, either IPv4, IPv6 or both. 

const (
	NetworkModeBOTH    NetworkMode = "BOTH"
	NetworkModeIPV4    NetworkMode = "IPV4"
	NetworkModeIPV6    NetworkMode = "IPV6"
	NetworkModeInvalid NetworkMode = "Invalid"
)

func PossibleNetworkModeValues 

func PossibleNetworkModeValues() []NetworkMode

PossibleNetworkModeValues returns the possible values for the NetworkMode const type.

type NetworkSettings 

type NetworkSettings struct {
	// REQUIRED; The properties of network settings of a device.
	Properties *NetworkSettingsProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

NetworkSettings - Represents the network settings of a device.

func (NetworkSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkSettings.

func (*NetworkSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkSettings.

type NetworkSettingsPatch 

type NetworkSettingsPatch struct {
	// REQUIRED; The properties of the network settings patch.
	Properties *NetworkSettingsPatchProperties
}

NetworkSettingsPatch - Represents the patch request for the network settings of a device.

func (NetworkSettingsPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkSettingsPatch.

func (*NetworkSettingsPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkSettingsPatch.

type NetworkSettingsPatchProperties 

type NetworkSettingsPatchProperties struct {
	// The DNS (Domain Name System) settings of device.
	DNSSettings *DNSSettings

	// The network adapter list of device.
	NetworkAdapters *NetworkAdapterList
}

NetworkSettingsPatchProperties - The properties of the network settings patch.

func (NetworkSettingsPatchProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkSettingsPatchProperties.

func (*NetworkSettingsPatchProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkSettingsPatchProperties.

type NetworkSettingsProperties 

type NetworkSettingsProperties struct {
	// REQUIRED; The DNS (Domain Name System) settings of device.
	DNSSettings *DNSSettings

	// REQUIRED; The network adapter list of device.
	NetworkAdapters *NetworkAdapterList

	// REQUIRED; The webproxy settings of device.
	WebproxySettings *WebproxySettings
}

NetworkSettingsProperties - The properties of the network settings of device.

func (NetworkSettingsProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkSettingsProperties.

func (*NetworkSettingsProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkSettingsProperties.

type NicIPv4 

type NicIPv4 struct {
	// The IPv4 address of Controller0.
	Controller0IPv4Address *string

	// The IPv4 address of Controller1.
	Controller1IPv4Address *string

	// The IPv4 address of the network adapter.
	IPv4Address *string

	// The IPv4 gateway of the network adapter.
	IPv4Gateway *string

	// The IPv4 netmask of the network adapter.
	IPv4Netmask *string
}

NicIPv4 - Details related to the IPv4 address configuration.

func (NicIPv4) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NicIPv4.

func (*NicIPv4) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NicIPv4.

type NicIPv6 

type NicIPv6 struct {
	// The IPv6 address of Controller0.
	Controller0IPv6Address *string

	// The IPv6 address of Controller1.
	Controller1IPv6Address *string

	// The IPv6 address of the network adapter.
	IPv6Address *string

	// The IPv6 gateway of the network adapter.
	IPv6Gateway *string

	// The IPv6 prefix of the network adapter.
	IPv6Prefix *string
}

NicIPv6 - Details related to the IPv6 address configuration.

func (NicIPv6) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NicIPv6.

func (*NicIPv6) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NicIPv6.

type OperationStatus 

type OperationStatus string

OperationStatus - The operation status on the volume. 

const (
	OperationStatusDeleting  OperationStatus = "Deleting"
	OperationStatusNone      OperationStatus = "None"
	OperationStatusRestoring OperationStatus = "Restoring"
	OperationStatusUpdating  OperationStatus = "Updating"
)

func PossibleOperationStatusValues 

func PossibleOperationStatusValues() []OperationStatus

PossibleOperationStatusValues returns the possible values for the OperationStatus const type.

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 REST API operations of the Microsoft.StorSimple provider

Generated from API version 2017-06-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/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/OperationsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.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.AvailableProviderOperationList = armstorsimple8000series.AvailableProviderOperationList{
		// 	Value: []*armstorsimple8000series.AvailableProviderOperation{
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/certificates/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("The Update Resource Certificate operation updates the resource/vault credential certificate."),
		// 				Operation: to.Ptr("Update Resource Certificate"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/updateSummary/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Update Summary"),
		// 				Operation: to.Ptr("List Update Summary"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Update Summary"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/scanForUpdates/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Scan for updates in a device."),
		// 				Operation: to.Ptr("Scan Updates"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/download/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Dowload updates for a device."),
		// 				Operation: to.Ptr("Download Device Updates"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/install/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Install updates on a device."),
		// 				Operation: to.Ptr("Install Updates (1200 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/timeSettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Time Settings"),
		// 				Operation: to.Ptr("List Time Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Time Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/alertSettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Alert Settings"),
		// 				Operation: to.Ptr("List Alert Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Alert Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/networkSettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Network Settings"),
		// 				Operation: to.Ptr("List Network Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Network Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/alertSettings/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Alert Settings"),
		// 				Operation: to.Ptr("Create or Update Alert Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Alert Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/securitySettings/update/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Update the security settings."),
		// 				Operation: to.Ptr("Update (1200 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Security Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Devices"),
		// 				Operation: to.Ptr("List Devices"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Devices"),
		// 				Operation: to.Ptr("Create or Update Devices"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Devices"),
		// 				Operation: to.Ptr("Delete Devices"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/deactivate/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deactivates a device."),
		// 				Operation: to.Ptr("Deactivate Device"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/publishSupportPackage/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Publish support package of a device for Microsoft Support troubleshooting."),
		// 				Operation: to.Ptr("Publish Support Package"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/failover/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Failover of the device."),
		// 				Operation: to.Ptr("Failover Device"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/shares/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Shares"),
		// 				Operation: to.Ptr("Create or Update Shares"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Shares (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/shares/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Shares"),
		// 				Operation: to.Ptr("List Shares"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Shares (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/shares/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Shares"),
		// 				Operation: to.Ptr("Delete Shares"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Shares (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/shares/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/shares/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/disks/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Disks"),
		// 				Operation: to.Ptr("List Disks"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Disks (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/disks/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Disks"),
		// 				Operation: to.Ptr("Create or Update Disks"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Disks (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/disks/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Disks"),
		// 				Operation: to.Ptr("Delete Disks"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Disks (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/disks/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/disks/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the iSCSI Servers"),
		// 				Operation: to.Ptr("List iSCSI Servers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("iSCSI Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the iSCSI Servers"),
		// 				Operation: to.Ptr("Create or Update iSCSI Servers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("iSCSI Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the iSCSI Servers"),
		// 				Operation: to.Ptr("Delete iSCSI Servers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("iSCSI Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/backup/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Take backup of an iSCSI server."),
		// 				Operation: to.Ptr("Take Backup"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("iSCSI Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/iscsiservers/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupScheduleGroups/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Backup Schedule Groups"),
		// 				Operation: to.Ptr("List Backup Schedule Groups"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Schedule Groups (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupScheduleGroups/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Backup Schedule Groups"),
		// 				Operation: to.Ptr("Create or Update Backup Schedule Groups"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Schedule Groups (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupScheduleGroups/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Backup Schedule Groups"),
		// 				Operation: to.Ptr("Delete Backup Schedule Groups"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Schedule Groups (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/alerts/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Alerts"),
		// 				Operation: to.Ptr("List Alerts"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Alerts"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/clearAlerts/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Clear all the alerts associated with the device manager."),
		// 				Operation: to.Ptr("Clears All Alerts"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/sendTestAlertEmail/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Send test alert email to configured email recipients."),
		// 				Operation: to.Ptr("Send Test Alert Email"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Storage Account Credentials"),
		// 				Operation: to.Ptr("Create or Update Storage Account Credentials"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Account Credentials"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Storage Account Credentials"),
		// 				Operation: to.Ptr("List Storage Account Credentials"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Account Credentials"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Storage Account Credentials"),
		// 				Operation: to.Ptr("Delete Storage Account Credentials"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Account Credentials"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/getActivationKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Get activation key for the device manager."),
		// 				Operation: to.Ptr("Get Activation Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/regenerateActivationKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Regenerate activation key for the device manager."),
		// 				Operation: to.Ptr("Regenerate Activation Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/regenarateRegistationCertificate/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Regenerate registration certificate for the device managers."),
		// 				Operation: to.Ptr("Regenerate Registration Certificate"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/encryptionSettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Encryption Settings"),
		// 				Operation: to.Ptr("List Encryption Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Encryption Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/getEncryptionKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Get encryption key for the device manager."),
		// 				Operation: to.Ptr("Get Encryption Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Device Managers"),
		// 				Operation: to.Ptr("List Device Managers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Device Managers"),
		// 				Operation: to.Ptr("Delete Device Managers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Device Managers"),
		// 				Operation: to.Ptr("Create or Update Device Managers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/chapSettings/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Chap Settings"),
		// 				Operation: to.Ptr("Create or Update Chap Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Chap Settings (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/chapSettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Chap Settings"),
		// 				Operation: to.Ptr("List Chap Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Chap Settings (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/chapSettings/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Chap Settings"),
		// 				Operation: to.Ptr("Delete Chap Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Chap Settings (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backups/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Backup Set"),
		// 				Operation: to.Ptr("List Backup Set"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Set"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backups/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Backup Set"),
		// 				Operation: to.Ptr("Delete Backup Set"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Set"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backups/elements/clone/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Clone a share or volume using a backup element."),
		// 				Operation: to.Ptr("Clone"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Elements (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageDomains/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Storage Domains"),
		// 				Operation: to.Ptr("List Storage Domains"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Domains (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageDomains/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Storage Domains"),
		// 				Operation: to.Ptr("Create or Update Storage Domains"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Domains (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageDomains/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Storage Domains"),
		// 				Operation: to.Ptr("Delete Storage Domains"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Domains (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/jobs/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Jobs"),
		// 				Operation: to.Ptr("List Jobs"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Jobs"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Access Control Records"),
		// 				Operation: to.Ptr("List Access Control Records"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Access Control Records"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the Access Control Records"),
		// 				Operation: to.Ptr("Create or Update Access Control Records"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Access Control Records"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/accessControlRecords/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the Access Control Records"),
		// 				Operation: to.Ptr("Delete Access Control Records"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Access Control Records"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the File Servers"),
		// 				Operation: to.Ptr("List File Servers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("File Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create or update the File Servers"),
		// 				Operation: to.Ptr("Create or Update File Servers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("File Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes the File Servers"),
		// 				Operation: to.Ptr("Delete File Servers"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("File Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/backup/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Take backup of an File Server."),
		// 				Operation: to.Ptr("Take Backup"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("File Servers (1200 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/fileservers/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Lists or gets the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/timeSettings/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Time Settings"),
		// 				Operation: to.Ptr("Creates or Updates Time Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Time Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/networkSettings/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Network Settings"),
		// 				Operation: to.Ptr("Creates or Updates Network Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Network Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/securitySettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Security Settings"),
		// 				Operation: to.Ptr("List Security Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Security Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/securitySettings/syncRemoteManagementCertificate/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Synchronize the remote management certificate for a device."),
		// 				Operation: to.Ptr("Synchronize Remote Management Certificate (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Security Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/securitySettings/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Security Settings"),
		// 				Operation: to.Ptr("Creates or Updates Security Settings"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Security Settings"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/configureDevice/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Configures a device"),
		// 				Operation: to.Ptr("Configure Device"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/installUpdates/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Installs updates on the devices"),
		// 				Operation: to.Ptr("Install Updates (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/listFailoverSets/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the failover sets for an existing device."),
		// 				Operation: to.Ptr("List Failover Sets"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/listFailoverTargets/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List failover targets of the devices"),
		// 				Operation: to.Ptr("List Failover Targets"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/listActivationKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Gets the activation key of the StorSimple Device Manager."),
		// 				Operation: to.Ptr("Gets Activation Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/listPublicEncryptionKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List public encryption keys of a StorSimple Device Manager."),
		// 				Operation: to.Ptr("List Public Encryption Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/publicEncryptionKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List public encryption key of the device manager"),
		// 				Operation: to.Ptr("List Public Encryption Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Devices"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/listPrivateEncryptionKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Gets private encryption key for a StorSimple Device Manager."),
		// 				Operation: to.Ptr("List Private Encryption Key"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials/listAccessKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List access keys of Storage Account Credentials"),
		// 				Operation: to.Ptr("List Access Keys"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Storage Account Credentials"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/jobs/cancel/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Cancel a running job"),
		// 				Operation: to.Ptr("Cancel Job"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Jobs"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Volume Containers (8000 Series Only)"),
		// 				Operation: to.Ptr("Creates or Updates Volume Containers (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volume Containers (8000 Series Only) (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Volume Containers (8000 Series Only)"),
		// 				Operation: to.Ptr("List Volume Containers (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volume Containers (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes an existing Volume Containers (8000 Series Only)"),
		// 				Operation: to.Ptr("Deletes Volume Containers (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volume Containers (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/listEncryptionKeys/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List encryption keys of Volume Containers"),
		// 				Operation: to.Ptr("List Encryption Keys"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volume Containers (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/rolloverEncryptionKey/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Rollover encryption keys of Volume Containers"),
		// 				Operation: to.Ptr("Rollover Encryption Keys"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volume Containers (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Volumes"),
		// 				Operation: to.Ptr("List Volumes"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volumes (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Volumes"),
		// 				Operation: to.Ptr("Creates or Updates Volumes"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volumes"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes an existing Volumes"),
		// 				Operation: to.Ptr("Deletes Volumes"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Volumes"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Metrics Definitions"),
		// 				Operation: to.Ptr("List Metrics Definitions"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics Definitions"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metrics/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Metrics"),
		// 				Operation: to.Ptr("List Metrics"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Metrics"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/hardwareComponentGroups/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Hardware Component Groups"),
		// 				Operation: to.Ptr("List Hardware Component Groups"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Hardware Component Groups (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/hardwareComponentGroups/changeControllerPowerState/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Change controller power state of hardware component groups"),
		// 				Operation: to.Ptr("Change controller power state of hardware component groups"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Hardware Component Groups"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Bandwidth Settings (8000 Series Only)"),
		// 				Operation: to.Ptr("List Bandwidth Settings (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Bandwidth Settings (8000 Series Only) (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Bandwidth Settings (8000 Series Only)"),
		// 				Operation: to.Ptr("Creates or Updates Bandwidth Settings (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Bandwidth Settings (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/bandwidthSettings/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes an existing Bandwidth Settings (8000 Series Only)"),
		// 				Operation: to.Ptr("Deletes Bandwidth Settings (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Bandwidth Settings (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backups/restore/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Restore all the volumes from a backup set."),
		// 				Operation: to.Ptr("Restore from Backup Set"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Set"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Schedules"),
		// 				Operation: to.Ptr("Creates or Updates Schedules"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Schedules (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Schedules"),
		// 				Operation: to.Ptr("List Schedules"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Schedules"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/schedules/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes an existing Schedules"),
		// 				Operation: to.Ptr("Deletes Schedules"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Schedules"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Creates a new or updates Backup Polices (8000 Series Only)"),
		// 				Operation: to.Ptr("Creates or Updates Backup Polices (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Polices (8000 Series Only) (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Backup Polices (8000 Series Only)"),
		// 				Operation: to.Ptr("List Backup Polices (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Polices (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Deletes an existing Backup Polices (8000 Series Only)"),
		// 				Operation: to.Ptr("Deletes Backup Polices (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Polices (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/backupPolicies/backup/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Take a manual backup to create an on-demand backup of all the volumes protected by the policy."),
		// 				Operation: to.Ptr("Take Backup"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Backup Polices (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/import/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Import source configurations for migration"),
		// 				Operation: to.Ptr("Import Source Configurations"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only) (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/startMigrationEstimate/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Start a job to estimate the duration of the migration process."),
		// 				Operation: to.Ptr("Start Migration Estimate"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/startMigration/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Start migration using source configurations"),
		// 				Operation: to.Ptr("Start Migration"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/confirmMigration/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Confirms a successful migration and commit it."),
		// 				Operation: to.Ptr("Confirm Migration"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/fetchMigrationEstimate/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Fetch the status for the migration estimation job."),
		// 				Operation: to.Ptr("Fetch Migration Estimate"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/fetchMigrationStatus/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Fetch the status for the migration."),
		// 				Operation: to.Ptr("Fetch Migration Status"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/devices/migrationSourceConfigurations/fetchConfirmMigrationStatus/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Fetch the confirm status of migration."),
		// 				Operation: to.Ptr("Fetch Migration Confirm Status"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Migration Source Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/provisionCloudAppliance/action"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create a new cloud appliance."),
		// 				Operation: to.Ptr("Create Cloud Appliance (8000 Series Only)"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Device Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/managers/cloudApplianceConfigurations/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("List the Cloud Appliance Supported Configurations"),
		// 				Operation: to.Ptr("List Cloud Appliance Supported Configurations"),
		// 				Provider: to.Ptr("Microsoft StorSimple Device Manager"),
		// 				Resource: to.Ptr("Cloud Appliance Supported Configurations (8000 Series Only)"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("Create Vault operation creates an Azure resource of type 'vault'"),
		// 				Operation: to.Ptr("Create Vault"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("The Get Vault operation gets an object representing the Azure resource of type 'vault'"),
		// 				Operation: to.Ptr("Get Vault"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("The Delete Vault operation deletes the specified Azure resource of type 'vault'"),
		// 				Operation: to.Ptr("Delete Vault"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/extendedInformation/read"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("The Get Extended Info operation gets an object's Extended Info representing the Azure resource of type ?vault?"),
		// 				Operation: to.Ptr("Get Extended Info"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/extendedInformation/write"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("The Get Extended Info operation gets an object's Extended Info representing the Azure resource of type ?vault?"),
		// 				Operation: to.Ptr("Get Extended Info"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StorSimple/Managers/extendedInformation/delete"),
		// 			Display: &armstorsimple8000series.AvailableProviderOperationDisplay{
		// 				Description: to.Ptr("The Get Extended Info operation gets an object's Extended Info representing the Azure resource of type ?vault?"),
		// 				Operation: to.Ptr("Get Extended Info"),
		// 				Provider: to.Ptr("Microsoft.StorSimple"),
		// 				Resource: to.Ptr("Managers"),
		// 			},
		// 			Origin: to.Ptr("user"),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// List of available provider operations.
	AvailableProviderOperationList
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OwnerShipStatus 

type OwnerShipStatus string

OwnerShipStatus - The owner ship status of the volume container. Only when the status is "NotOwned", the delete operation on the volume container is permitted. 

const (
	OwnerShipStatusNotOwned OwnerShipStatus = "NotOwned"
	OwnerShipStatusOwned    OwnerShipStatus = "Owned"
)

func PossibleOwnerShipStatusValues 

func PossibleOwnerShipStatusValues() []OwnerShipStatus

PossibleOwnerShipStatusValues returns the possible values for the OwnerShipStatus const type.

type PublicKey 

type PublicKey struct {
	// REQUIRED; The key.
	Key *string
}

PublicKey - The public key.

func (PublicKey) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PublicKey.

func (*PublicKey) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PublicKey.

type RecurrenceType 

type RecurrenceType string

RecurrenceType - The recurrence type. 

const (
	RecurrenceTypeDaily   RecurrenceType = "Daily"
	RecurrenceTypeHourly  RecurrenceType = "Hourly"
	RecurrenceTypeMinutes RecurrenceType = "Minutes"
	RecurrenceTypeWeekly  RecurrenceType = "Weekly"
)

func PossibleRecurrenceTypeValues 

func PossibleRecurrenceTypeValues() []RecurrenceType

PossibleRecurrenceTypeValues returns the possible values for the RecurrenceType const type.

type RemoteManagementModeConfiguration 

type RemoteManagementModeConfiguration string

RemoteManagementModeConfiguration - The remote management mode. 

const (
	RemoteManagementModeConfigurationDisabled            RemoteManagementModeConfiguration = "Disabled"
	RemoteManagementModeConfigurationHTTPSAndHTTPEnabled RemoteManagementModeConfiguration = "HttpsAndHttpEnabled"
	RemoteManagementModeConfigurationHTTPSEnabled        RemoteManagementModeConfiguration = "HttpsEnabled"
	RemoteManagementModeConfigurationUnknown             RemoteManagementModeConfiguration = "Unknown"
)

func PossibleRemoteManagementModeConfigurationValues 

func PossibleRemoteManagementModeConfigurationValues() []RemoteManagementModeConfiguration

PossibleRemoteManagementModeConfigurationValues returns the possible values for the RemoteManagementModeConfiguration const type.

type RemoteManagementSettings 

type RemoteManagementSettings struct {
	// REQUIRED; The remote management mode.
	RemoteManagementMode *RemoteManagementModeConfiguration

	// The remote management certificates.
	RemoteManagementCertificate *string
}

RemoteManagementSettings - The settings for remote management of a device.

func (RemoteManagementSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RemoteManagementSettings.

func (*RemoteManagementSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RemoteManagementSettings.

type RemoteManagementSettingsPatch 

type RemoteManagementSettingsPatch struct {
	// REQUIRED; The remote management mode.
	RemoteManagementMode *RemoteManagementModeConfiguration
}

RemoteManagementSettingsPatch - The settings for updating remote management mode of the device.

func (RemoteManagementSettingsPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RemoteManagementSettingsPatch.

func (*RemoteManagementSettingsPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RemoteManagementSettingsPatch.

type Resource 

type Resource struct {
	// REQUIRED; The geo location of the resource.
	Location *string

	// The tags attached to the resource.
	Tags map[string]*string

	// READ-ONLY; The resource ID.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

Resource - The Azure Resource.

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SSLStatus 

type SSLStatus string

SSLStatus - Signifies whether SSL needs to be enabled or not. 

const (
	SSLStatusDisabled SSLStatus = "Disabled"
	SSLStatusEnabled  SSLStatus = "Enabled"
)

func PossibleSSLStatusValues 

func PossibleSSLStatusValues() []SSLStatus

PossibleSSLStatusValues returns the possible values for the SSLStatus const type.

type ScheduleRecurrence 

type ScheduleRecurrence struct {
	// REQUIRED; The recurrence type.
	RecurrenceType *RecurrenceType

	// REQUIRED; The recurrence value.
	RecurrenceValue *int32

	// The week days list. Applicable only for schedules of recurrence type 'weekly'.
	WeeklyDaysList []*DayOfWeek
}

ScheduleRecurrence - The schedule recurrence.

func (ScheduleRecurrence) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ScheduleRecurrence.

func (*ScheduleRecurrence) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ScheduleRecurrence.

type ScheduleStatus 

type ScheduleStatus string

ScheduleStatus - The schedule status. 

const (
	ScheduleStatusDisabled ScheduleStatus = "Disabled"
	ScheduleStatusEnabled  ScheduleStatus = "Enabled"
)

func PossibleScheduleStatusValues 

func PossibleScheduleStatusValues() []ScheduleStatus

PossibleScheduleStatusValues returns the possible values for the ScheduleStatus const type.

type ScheduledBackupStatus 

type ScheduledBackupStatus string

ScheduledBackupStatus - Indicates whether at least one of the schedules in the backup policy is active or not. 

const (
	ScheduledBackupStatusDisabled ScheduledBackupStatus = "Disabled"
	ScheduledBackupStatusEnabled  ScheduledBackupStatus = "Enabled"
)

func PossibleScheduledBackupStatusValues 

func PossibleScheduledBackupStatusValues() []ScheduledBackupStatus

PossibleScheduledBackupStatusValues returns the possible values for the ScheduledBackupStatus const type.

type SecondaryDNSSettings 

type SecondaryDNSSettings struct {
	// The list of secondary DNS Server IP addresses.
	SecondaryDNSServers []*string
}

SecondaryDNSSettings - The secondary DNS settings.

func (SecondaryDNSSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecondaryDNSSettings.

func (*SecondaryDNSSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecondaryDNSSettings.

type SecuritySettings 

type SecuritySettings struct {
	// REQUIRED; The properties of the security settings of a device.
	Properties *SecuritySettingsProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

SecuritySettings - The security settings of a device.

func (SecuritySettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecuritySettings.

func (*SecuritySettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecuritySettings.

type SecuritySettingsPatch 

type SecuritySettingsPatch struct {
	// REQUIRED; The properties of the security settings patch.
	Properties *SecuritySettingsPatchProperties
}

SecuritySettingsPatch - Represents the patch request for the security settings of a device.

func (SecuritySettingsPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecuritySettingsPatch.

func (*SecuritySettingsPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecuritySettingsPatch.

type SecuritySettingsPatchProperties 

type SecuritySettingsPatchProperties struct {
	// The device CHAP and reverse-CHAP settings.
	ChapSettings *ChapSettings

	// The cloud appliance settings.
	CloudApplianceSettings *CloudApplianceSettings

	// The device administrator password.
	DeviceAdminPassword *AsymmetricEncryptedSecret

	// The remote management settings.
	RemoteManagementSettings *RemoteManagementSettingsPatch

	// The snapshot manager password.
	SnapshotPassword *AsymmetricEncryptedSecret
}

SecuritySettingsPatchProperties - The properties of the security settings patch.

func (SecuritySettingsPatchProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecuritySettingsPatchProperties.

func (*SecuritySettingsPatchProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecuritySettingsPatchProperties.

type SecuritySettingsProperties 

type SecuritySettingsProperties struct {
	// REQUIRED; The Challenge-Handshake Authentication Protocol (CHAP) settings.
	ChapSettings *ChapSettings

	// REQUIRED; The settings for remote management of a device.
	RemoteManagementSettings *RemoteManagementSettings
}

SecuritySettingsProperties - The properties of security settings of a device.

func (SecuritySettingsProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecuritySettingsProperties.

func (*SecuritySettingsProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecuritySettingsProperties.

type SendTestAlertEmailRequest 

type SendTestAlertEmailRequest struct {
	// REQUIRED; The list of email IDs to send the test alert email
	EmailList []*string
}

SendTestAlertEmailRequest - The request for sending test alert email

func (SendTestAlertEmailRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SendTestAlertEmailRequest.

func (*SendTestAlertEmailRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SendTestAlertEmailRequest.

type StorageAccountCredential 

type StorageAccountCredential struct {
	// REQUIRED; The storage account credential properties.
	Properties *StorageAccountCredentialProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

StorageAccountCredential - The storage account credential.

func (StorageAccountCredential) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageAccountCredential.

func (*StorageAccountCredential) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccountCredential.

type StorageAccountCredentialList 

type StorageAccountCredentialList struct {
	// REQUIRED; The value.
	Value []*StorageAccountCredential
}

StorageAccountCredentialList - The collection of storage account credential entities.

func (StorageAccountCredentialList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageAccountCredentialList.

func (*StorageAccountCredentialList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccountCredentialList.

type StorageAccountCredentialProperties 

type StorageAccountCredentialProperties struct {
	// REQUIRED; The storage endpoint
	EndPoint *string

	// REQUIRED; Signifies whether SSL needs to be enabled or not.
	SSLStatus *SSLStatus

	// The details of the storage account password.
	AccessKey *AsymmetricEncryptedSecret

	// READ-ONLY; The count of volumes using this storage account credential.
	VolumesCount *int32
}

StorageAccountCredentialProperties - The storage account credential properties.

func (StorageAccountCredentialProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageAccountCredentialProperties.

func (*StorageAccountCredentialProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccountCredentialProperties.

type StorageAccountCredentialsClient 

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

StorageAccountCredentialsClient contains the methods for the StorageAccountCredentials group. Don't use this type directly, use NewStorageAccountCredentialsClient() instead.

func NewStorageAccountCredentialsClient 

func NewStorageAccountCredentialsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*StorageAccountCredentialsClient, error)

NewStorageAccountCredentialsClient creates a new instance of StorageAccountCredentialsClient with the specified values.

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

func (*StorageAccountCredentialsClient) BeginCreateOrUpdate 

func (client *StorageAccountCredentialsClient) BeginCreateOrUpdate(ctx context.Context, storageAccountCredentialName string, resourceGroupName string, managerName string, parameters StorageAccountCredential, options *StorageAccountCredentialsClientBeginCreateOrUpdateOptions) (*runtime.Poller[StorageAccountCredentialsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the storage account credential. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • storageAccountCredentialName - The storage account credential name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The storage account credential to be added or updated.
  • options - StorageAccountCredentialsClientBeginCreateOrUpdateOptions contains the optional parameters for the StorageAccountCredentialsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/StorageAccountCredentialsCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStorageAccountCredentialsClient().BeginCreateOrUpdate(ctx, "SACForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.StorageAccountCredential{
		Properties: &armstorsimple8000series.StorageAccountCredentialProperties{
			AccessKey: &armstorsimple8000series.AsymmetricEncryptedSecret{
				EncryptionAlgorithm:      to.Ptr(armstorsimple8000series.EncryptionAlgorithmRSAESPKCS1V15),
				EncryptionCertThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
				Value:                    to.Ptr("ATuJSkmrFk4h8r1jrZ4nd3nthLSddcguEO5QLO/NECUtTuB9kL4dNv3/jC4WOvFkeVr3x1UvfhlIeMmJBF1SMr6hR1JzD0xNU/TtQqUeXN7V3jk7I+2l67P9StuHWR6OMd3XOLwvznxOEQtEWpweDiobZU1ZiY03WafcGZFpV5j6tEoHeopoZ1J/GhPtkYmx+TqxzUN6qnir5rP3NSYiZciImP/qu8U9yUV/xpVRv39KvFc2Yr5SpKpMMRUj55XW10UnPer63M6KovF8X9Wi/fNnrZAs1Esl5XddZETGrW/e5B++VMJ6w0Q/uvPR+UBwrOU0804l0SzwdIe3qVVd0Q=="),
			},
			EndPoint:  to.Ptr("blob.core.windows.net"),
			SSLStatus: to.Ptr(armstorsimple8000series.SSLStatusEnabled),
		},
	}, 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.StorageAccountCredential = armstorsimple8000series.StorageAccountCredential{
	// 	Name: to.Ptr("SACForTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/SACForTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.StorageAccountCredentialProperties{
	// 		EndPoint: to.Ptr("blob.core.windows.net"),
	// 		SSLStatus: to.Ptr(armstorsimple8000series.SSLStatusEnabled),
	// 		VolumesCount: to.Ptr[int32](0),
	// 	},
	// }
}

Output:

func (*StorageAccountCredentialsClient) BeginDelete 

func (client *StorageAccountCredentialsClient) BeginDelete(ctx context.Context, storageAccountCredentialName string, resourceGroupName string, managerName string, options *StorageAccountCredentialsClientBeginDeleteOptions) (*runtime.Poller[StorageAccountCredentialsClientDeleteResponse], error)

BeginDelete - Deletes the storage account credential. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • storageAccountCredentialName - The name of the storage account credential.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - StorageAccountCredentialsClientBeginDeleteOptions contains the optional parameters for the StorageAccountCredentialsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/StorageAccountCredentialsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStorageAccountCredentialsClient().BeginDelete(ctx, "SACForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*StorageAccountCredentialsClient) Get 

func (client *StorageAccountCredentialsClient) Get(ctx context.Context, storageAccountCredentialName string, resourceGroupName string, managerName string, options *StorageAccountCredentialsClientGetOptions) (StorageAccountCredentialsClientGetResponse, error)

Get - Gets the properties of the specified storage account credential name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • storageAccountCredentialName - The name of storage account credential to be fetched.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - StorageAccountCredentialsClientGetOptions contains the optional parameters for the StorageAccountCredentialsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/StorageAccountCredentialsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStorageAccountCredentialsClient().Get(ctx, "SACForTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.StorageAccountCredential = armstorsimple8000series.StorageAccountCredential{
	// 	Name: to.Ptr("SACForTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/SACForTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.StorageAccountCredentialProperties{
	// 		EndPoint: to.Ptr("blob.core.windows.net"),
	// 		SSLStatus: to.Ptr(armstorsimple8000series.SSLStatusEnabled),
	// 		VolumesCount: to.Ptr[int32](1),
	// 	},
	// }
}

Output:

func (*StorageAccountCredentialsClient) NewListByManagerPager 

func (client *StorageAccountCredentialsClient) NewListByManagerPager(resourceGroupName string, managerName string, options *StorageAccountCredentialsClientListByManagerOptions) *runtime.Pager[StorageAccountCredentialsClientListByManagerResponse]

NewListByManagerPager - Gets all the storage account credentials in a manager.

Generated from API version 2017-06-01

  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - StorageAccountCredentialsClientListByManagerOptions contains the optional parameters for the StorageAccountCredentialsClient.NewListByManagerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/StorageAccountCredentialsListByManager.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStorageAccountCredentialsClient().NewListByManagerPager("ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.StorageAccountCredentialList = armstorsimple8000series.StorageAccountCredentialList{
		// 	Value: []*armstorsimple8000series.StorageAccountCredential{
		// 		{
		// 			Name: to.Ptr("SACForTest2"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/SACForTest2"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.StorageAccountCredentialProperties{
		// 				EndPoint: to.Ptr("blob.core.windows.net"),
		// 				SSLStatus: to.Ptr(armstorsimple8000series.SSLStatusEnabled),
		// 				VolumesCount: to.Ptr[int32](0),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("safortestrecording"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/storageAccountCredentials"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/safortestrecording"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.StorageAccountCredentialProperties{
		// 				EndPoint: to.Ptr("blob.core.windows.net"),
		// 				SSLStatus: to.Ptr(armstorsimple8000series.SSLStatusEnabled),
		// 				VolumesCount: to.Ptr[int32](5),
		// 			},
		// 	}},
		// }
	}
}

Output:

type StorageAccountCredentialsClientBeginCreateOrUpdateOptions 

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

StorageAccountCredentialsClientBeginCreateOrUpdateOptions contains the optional parameters for the StorageAccountCredentialsClient.BeginCreateOrUpdate method.

type StorageAccountCredentialsClientBeginDeleteOptions 

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

StorageAccountCredentialsClientBeginDeleteOptions contains the optional parameters for the StorageAccountCredentialsClient.BeginDelete method.

type StorageAccountCredentialsClientCreateOrUpdateResponse 

type StorageAccountCredentialsClientCreateOrUpdateResponse struct {
	// The storage account credential.
	StorageAccountCredential
}

StorageAccountCredentialsClientCreateOrUpdateResponse contains the response from method StorageAccountCredentialsClient.BeginCreateOrUpdate.

type StorageAccountCredentialsClientDeleteResponse 

type StorageAccountCredentialsClientDeleteResponse struct {
}

StorageAccountCredentialsClientDeleteResponse contains the response from method StorageAccountCredentialsClient.BeginDelete.

type StorageAccountCredentialsClientGetOptions 

type StorageAccountCredentialsClientGetOptions struct {
}

StorageAccountCredentialsClientGetOptions contains the optional parameters for the StorageAccountCredentialsClient.Get method.

type StorageAccountCredentialsClientGetResponse 

type StorageAccountCredentialsClientGetResponse struct {
	// The storage account credential.
	StorageAccountCredential
}

StorageAccountCredentialsClientGetResponse contains the response from method StorageAccountCredentialsClient.Get.

type StorageAccountCredentialsClientListByManagerOptions 

type StorageAccountCredentialsClientListByManagerOptions struct {
}

StorageAccountCredentialsClientListByManagerOptions contains the optional parameters for the StorageAccountCredentialsClient.NewListByManagerPager method.

type StorageAccountCredentialsClientListByManagerResponse 

type StorageAccountCredentialsClientListByManagerResponse struct {
	// The collection of storage account credential entities.
	StorageAccountCredentialList
}

StorageAccountCredentialsClientListByManagerResponse contains the response from method StorageAccountCredentialsClient.NewListByManagerPager.

type SymmetricEncryptedSecret 

type SymmetricEncryptedSecret struct {
	// REQUIRED; The algorithm used to encrypt the "Value".
	EncryptionAlgorithm *EncryptionAlgorithm

	// REQUIRED; The value of the secret itself. If the secret is in plaintext or null then EncryptionAlgorithm will be none.
	Value *string

	// The thumbprint of the cert that was used to encrypt "Value".
	ValueCertificateThumbprint *string
}

SymmetricEncryptedSecret - Represents the secrets encrypted using Symmetric Encryption Key.

func (SymmetricEncryptedSecret) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SymmetricEncryptedSecret.

func (*SymmetricEncryptedSecret) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SymmetricEncryptedSecret.

type TargetEligibilityErrorMessage 

type TargetEligibilityErrorMessage struct {
	// The localized error message stating the reason why the device is not eligible as a target device.
	Message *string

	// The localized resolution message for the error.
	Resolution *string

	// The result code for the error, due to which the device does not qualify as a failover target device.
	ResultCode *TargetEligibilityResultCode
}

TargetEligibilityErrorMessage - The error/warning message due to which the device is ineligible as a failover target device.

func (TargetEligibilityErrorMessage) MarshalJSON 

func (t TargetEligibilityErrorMessage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TargetEligibilityErrorMessage.

func (*TargetEligibilityErrorMessage) UnmarshalJSON 

func (t *TargetEligibilityErrorMessage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TargetEligibilityErrorMessage.

type TargetEligibilityResult 

type TargetEligibilityResult struct {
	// The eligibility status of device, as a failover target device.
	EligibilityStatus *TargetEligibilityStatus

	// The list of error messages, if a device does not qualify as a failover target device.
	Messages []*TargetEligibilityErrorMessage
}

TargetEligibilityResult - The eligibility result of device, as a failover target device.

func (TargetEligibilityResult) MarshalJSON 

func (t TargetEligibilityResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TargetEligibilityResult.

func (*TargetEligibilityResult) UnmarshalJSON 

func (t *TargetEligibilityResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TargetEligibilityResult.

type TargetEligibilityResultCode 

type TargetEligibilityResultCode string

TargetEligibilityResultCode - The result code for the error, due to which the device does not qualify as a failover target device. 

const (
	TargetEligibilityResultCodeLocalToTieredVolumesConversionWarning     TargetEligibilityResultCode = "LocalToTieredVolumesConversionWarning"
	TargetEligibilityResultCodeTargetAndSourceCannotBeSameError          TargetEligibilityResultCode = "TargetAndSourceCannotBeSameError"
	TargetEligibilityResultCodeTargetInsufficientCapacityError           TargetEligibilityResultCode = "TargetInsufficientCapacityError"
	TargetEligibilityResultCodeTargetInsufficientLocalVolumeMemoryError  TargetEligibilityResultCode = "TargetInsufficientLocalVolumeMemoryError"
	TargetEligibilityResultCodeTargetInsufficientTieredVolumeMemoryError TargetEligibilityResultCode = "TargetInsufficientTieredVolumeMemoryError"
	TargetEligibilityResultCodeTargetIsNotOnlineError                    TargetEligibilityResultCode = "TargetIsNotOnlineError"
	TargetEligibilityResultCodeTargetSourceIncompatibleVersionError      TargetEligibilityResultCode = "TargetSourceIncompatibleVersionError"
)

func PossibleTargetEligibilityResultCodeValues 

func PossibleTargetEligibilityResultCodeValues() []TargetEligibilityResultCode

PossibleTargetEligibilityResultCodeValues returns the possible values for the TargetEligibilityResultCode const type.

type TargetEligibilityStatus 

type TargetEligibilityStatus string

TargetEligibilityStatus - The eligibility status of device, as a failover target device. 

const (
	TargetEligibilityStatusEligible    TargetEligibilityStatus = "Eligible"
	TargetEligibilityStatusNotEligible TargetEligibilityStatus = "NotEligible"
)

func PossibleTargetEligibilityStatusValues 

func PossibleTargetEligibilityStatusValues() []TargetEligibilityStatus

PossibleTargetEligibilityStatusValues returns the possible values for the TargetEligibilityStatus const type.

type Time 

type Time struct {
	// REQUIRED; The hour.
	Hours *int32

	// REQUIRED; The minute.
	Minutes *int32

	// REQUIRED; The second.
	Seconds *int32
}

Time - The time.

func (Time) MarshalJSON 

func (t Time) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Time.

func (*Time) UnmarshalJSON 

func (t *Time) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Time.

type TimeSettings 

type TimeSettings struct {
	// REQUIRED; The properties of the time settings of a device.
	Properties *TimeSettingsProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

TimeSettings - The time settings of a device.

func (TimeSettings) MarshalJSON 

func (t TimeSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TimeSettings.

func (*TimeSettings) UnmarshalJSON 

func (t *TimeSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TimeSettings.

type TimeSettingsProperties 

type TimeSettingsProperties struct {
	// REQUIRED; The timezone of device, like '(UTC -06:00) Central America'
	TimeZone *string

	// The primary Network Time Protocol (NTP) server name, like 'time.windows.com'.
	PrimaryTimeServer *string

	// The secondary Network Time Protocol (NTP) server name, like 'time.contoso.com'. It's optional.
	SecondaryTimeServer []*string
}

TimeSettingsProperties - The properties of time settings of a device.

func (TimeSettingsProperties) MarshalJSON 

func (t TimeSettingsProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TimeSettingsProperties.

func (*TimeSettingsProperties) UnmarshalJSON 

func (t *TimeSettingsProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TimeSettingsProperties.

type Updates 

type Updates struct {
	// REQUIRED; The properties of the updates profile.
	Properties *UpdatesProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

Updates - The updates profile of a device.

func (Updates) MarshalJSON 

func (u Updates) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Updates.

func (*Updates) UnmarshalJSON 

func (u *Updates) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Updates.

type UpdatesProperties 

type UpdatesProperties struct {
	// Indicates whether an update is in progress or not.
	IsUpdateInProgress *bool

	// The time when the last update was completed.
	LastUpdatedTime *time.Time

	// Set to 'true' if maintenance mode update available.
	MaintenanceModeUpdatesAvailable *bool

	// Set to 'true' if regular updates are available for the device.
	RegularUpdatesAvailable *bool
}

UpdatesProperties - The properties of the updates profile.

func (UpdatesProperties) MarshalJSON 

func (u UpdatesProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdatesProperties.

func (*UpdatesProperties) UnmarshalJSON 

func (u *UpdatesProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpdatesProperties.

type VMImage 

type VMImage struct {
	// REQUIRED; The name.
	Name *string

	// REQUIRED; The offer.
	Offer *string

	// REQUIRED; The publisher.
	Publisher *string

	// REQUIRED; The SKU.
	SKU *string

	// REQUIRED; The version.
	Version *string
}

VMImage - The virtual machine image.

func (VMImage) MarshalJSON 

func (v VMImage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMImage.

func (*VMImage) UnmarshalJSON 

func (v *VMImage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMImage.

type VirtualMachineAPIType 

type VirtualMachineAPIType string

VirtualMachineAPIType - The virtual machine API type. 

const (
	VirtualMachineAPITypeArm     VirtualMachineAPIType = "Arm"
	VirtualMachineAPITypeClassic VirtualMachineAPIType = "Classic"
)

func PossibleVirtualMachineAPITypeValues 

func PossibleVirtualMachineAPITypeValues() []VirtualMachineAPIType

PossibleVirtualMachineAPITypeValues returns the possible values for the VirtualMachineAPIType const type.

type Volume 

type Volume struct {
	// REQUIRED; The properties of the volume.
	Properties *VolumeProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

Volume - The volume.

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 VolumeContainer 

type VolumeContainer struct {
	// REQUIRED; The volume container properties.
	Properties *VolumeContainerProperties

	// The Kind of the object. Currently only Series8000 is supported
	Kind *string

	// READ-ONLY; The path ID that uniquely identifies the object.
	ID *string

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

	// READ-ONLY; The hierarchical type of the object.
	Type *string
}

VolumeContainer - The volume container.

func (VolumeContainer) MarshalJSON 

func (v VolumeContainer) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeContainer.

func (*VolumeContainer) UnmarshalJSON 

func (v *VolumeContainer) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeContainer.

type VolumeContainerFailoverMetadata 

type VolumeContainerFailoverMetadata struct {
	// The path ID of the volume container.
	VolumeContainerID *string

	// The list of metadata of volumes inside the volume container, which contains valid cloud snapshots.
	Volumes []*VolumeFailoverMetadata
}

VolumeContainerFailoverMetadata - The metadata of the volume container, that is being considered as part of a failover set.

func (VolumeContainerFailoverMetadata) MarshalJSON 

func (v VolumeContainerFailoverMetadata) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeContainerFailoverMetadata.

func (*VolumeContainerFailoverMetadata) UnmarshalJSON 

func (v *VolumeContainerFailoverMetadata) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeContainerFailoverMetadata.

type VolumeContainerList 

type VolumeContainerList struct {
	// REQUIRED; The value.
	Value []*VolumeContainer
}

VolumeContainerList - The collection of volume container entities.

func (VolumeContainerList) MarshalJSON 

func (v VolumeContainerList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeContainerList.

func (*VolumeContainerList) UnmarshalJSON 

func (v *VolumeContainerList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeContainerList.

type VolumeContainerProperties 

type VolumeContainerProperties struct {
	// REQUIRED; The path ID of storage account associated with the volume container.
	StorageAccountCredentialID *string

	// The bandwidth-rate set on the volume container.
	BandWidthRateInMbps *int32

	// The ID of the bandwidth setting associated with the volume container.
	BandwidthSettingID *string

	// The key used to encrypt data in the volume container. It is required when property 'EncryptionStatus' is "Enabled".
	EncryptionKey *AsymmetricEncryptedSecret

	// READ-ONLY; The flag to denote whether encryption is enabled or not.
	EncryptionStatus *EncryptionStatus

	// READ-ONLY; The owner ship status of the volume container. Only when the status is "NotOwned", the delete operation on the
	// volume container is permitted.
	OwnerShipStatus *OwnerShipStatus

	// READ-ONLY; The total cloud storage for the volume container.
	TotalCloudStorageUsageInBytes *int64

	// READ-ONLY; The number of volumes in the volume Container.
	VolumeCount *int32
}

VolumeContainerProperties - The properties of volume container.

func (VolumeContainerProperties) MarshalJSON 

func (v VolumeContainerProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeContainerProperties.

func (*VolumeContainerProperties) UnmarshalJSON 

func (v *VolumeContainerProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeContainerProperties.

type VolumeContainersClient 

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

VolumeContainersClient contains the methods for the VolumeContainers group. Don't use this type directly, use NewVolumeContainersClient() instead.

func NewVolumeContainersClient 

func NewVolumeContainersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VolumeContainersClient, error)

NewVolumeContainersClient creates a new instance of VolumeContainersClient with the specified values.

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

func (*VolumeContainersClient) BeginCreateOrUpdate 

func (client *VolumeContainersClient) BeginCreateOrUpdate(ctx context.Context, deviceName string, volumeContainerName string, resourceGroupName string, managerName string, parameters VolumeContainer, options *VolumeContainersClientBeginCreateOrUpdateOptions) (*runtime.Poller[VolumeContainersClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the volume container. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The name of the volume container.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - The volume container to be added or updated.
  • options - VolumeContainersClientBeginCreateOrUpdateOptions contains the optional parameters for the VolumeContainersClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumeContainersCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVolumeContainersClient().BeginCreateOrUpdate(ctx, "Device05ForSDKTest", "VolumeContainerForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.VolumeContainer{
		Properties: &armstorsimple8000series.VolumeContainerProperties{
			BandwidthSettingID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/bandwidthSetting1"),
			EncryptionKey: &armstorsimple8000series.AsymmetricEncryptedSecret{
				EncryptionAlgorithm:      to.Ptr(armstorsimple8000series.EncryptionAlgorithmRSAESPKCS1V15),
				EncryptionCertThumbprint: to.Ptr("A872A2DF196AC7682EE24791E7DE2E2A360F5926"),
				Value:                    to.Ptr("R//pyVLx/fn58ia098JiLgZB5RY7fVT+6o8a4fmsvjy+ls2UgJphMf25XVqEQCZnsp/5uxteN1M/9ArPIICdhM7M1+b/Ur7kJ0FH0ktxfk7CrPWWJLI4q20LZoduJGI56lREav1VpuLdqw5F9fRcq7zbfgPQ3B/SD0mfumNRiV+AnwbC6msfavIuWrhVDl9iSzEPE+zU06/kpsexnrS81yYT2QlVVUbvpY4F3zfH8TQPpAROTbv2pld6JO4eGOrZ5O1iOr6XCg2TY2W/jf+Ev4z5tqC9VWXE5kh65gjBfpWN0bDWXKekqEhor2crHAxZi4dybdY8Ok1MDWd1CSU8kw=="),
			},
			StorageAccountCredentialID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/safortestrecording"),
		},
	}, 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.VolumeContainer = armstorsimple8000series.VolumeContainer{
	// 	Name: to.Ptr("VolumeContainerForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/VolumeContainerForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.VolumeContainerProperties{
	// 		BandwidthSettingID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/bandwidthSetting1"),
	// 		EncryptionStatus: to.Ptr(armstorsimple8000series.EncryptionStatusEnabled),
	// 		OwnerShipStatus: to.Ptr(armstorsimple8000series.OwnerShipStatusOwned),
	// 		StorageAccountCredentialID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/safortestrecording"),
	// 		TotalCloudStorageUsageInBytes: to.Ptr[int64](0),
	// 		VolumeCount: to.Ptr[int32](1),
	// 	},
	// }
}

Output:

func (*VolumeContainersClient) BeginDelete 

func (client *VolumeContainersClient) BeginDelete(ctx context.Context, deviceName string, volumeContainerName string, resourceGroupName string, managerName string, options *VolumeContainersClientBeginDeleteOptions) (*runtime.Poller[VolumeContainersClientDeleteResponse], error)

BeginDelete - Deletes the volume container. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The name of the volume container.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumeContainersClientBeginDeleteOptions contains the optional parameters for the VolumeContainersClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumeContainersDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVolumeContainersClient().BeginDelete(ctx, "Device05ForSDKTest", "VolumeContainerForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 (*VolumeContainersClient) Get 

func (client *VolumeContainersClient) Get(ctx context.Context, deviceName string, volumeContainerName string, resourceGroupName string, managerName string, options *VolumeContainersClientGetOptions) (VolumeContainersClientGetResponse, error)

Get - Gets the properties of the specified volume container name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The name of the volume container.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumeContainersClientGetOptions contains the optional parameters for the VolumeContainersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumeContainersGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVolumeContainersClient().Get(ctx, "Device05ForSDKTest", "VolumeContainerForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.VolumeContainer = armstorsimple8000series.VolumeContainer{
	// 	Name: to.Ptr("VolumeContainerForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/VolumeContainerForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.VolumeContainerProperties{
	// 		BandwidthSettingID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/bandwidthSettings/bandwidthSetting1"),
	// 		EncryptionStatus: to.Ptr(armstorsimple8000series.EncryptionStatusEnabled),
	// 		OwnerShipStatus: to.Ptr(armstorsimple8000series.OwnerShipStatusOwned),
	// 		StorageAccountCredentialID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/safortestrecording"),
	// 		TotalCloudStorageUsageInBytes: to.Ptr[int64](0),
	// 		VolumeCount: to.Ptr[int32](1),
	// 	},
	// }
}

Output:

func (*VolumeContainersClient) NewListByDevicePager 

func (client *VolumeContainersClient) NewListByDevicePager(deviceName string, resourceGroupName string, managerName string, options *VolumeContainersClientListByDeviceOptions) *runtime.Pager[VolumeContainersClientListByDeviceResponse]

NewListByDevicePager - Gets all the volume containers in a device.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumeContainersClientListByDeviceOptions contains the optional parameters for the VolumeContainersClient.NewListByDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumeContainersListByDevice.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumeContainersClient().NewListByDevicePager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.VolumeContainerList = armstorsimple8000series.VolumeContainerList{
		// 	Value: []*armstorsimple8000series.VolumeContainer{
		// 		{
		// 			Name: to.Ptr("vcforsdktest"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcforsdktest"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.VolumeContainerProperties{
		// 				BandWidthRateInMbps: to.Ptr[int32](0),
		// 				EncryptionStatus: to.Ptr(armstorsimple8000series.EncryptionStatusDisabled),
		// 				OwnerShipStatus: to.Ptr(armstorsimple8000series.OwnerShipStatusOwned),
		// 				StorageAccountCredentialID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/safortestrecording"),
		// 				TotalCloudStorageUsageInBytes: to.Ptr[int64](33839216),
		// 				VolumeCount: to.Ptr[int32](1),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("vcForOdataFilterTest"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.VolumeContainerProperties{
		// 				BandWidthRateInMbps: to.Ptr[int32](0),
		// 				EncryptionStatus: to.Ptr(armstorsimple8000series.EncryptionStatusDisabled),
		// 				OwnerShipStatus: to.Ptr(armstorsimple8000series.OwnerShipStatusOwned),
		// 				StorageAccountCredentialID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/storageAccountCredentials/safortestrecording"),
		// 				TotalCloudStorageUsageInBytes: to.Ptr[int64](200277),
		// 				VolumeCount: to.Ptr[int32](4),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*VolumeContainersClient) NewListMetricDefinitionPager 

func (client *VolumeContainersClient) NewListMetricDefinitionPager(deviceName string, volumeContainerName string, resourceGroupName string, managerName string, options *VolumeContainersClientListMetricDefinitionOptions) *runtime.Pager[VolumeContainersClientListMetricDefinitionResponse]

NewListMetricDefinitionPager - Gets the metric definitions for the specified volume container.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumeContainersClientListMetricDefinitionOptions contains the optional parameters for the VolumeContainersClient.NewListMetricDefinitionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumeContainersListMetricDefinition.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumeContainersClient().NewListMetricDefinitionPager("Device05ForSDKTest", "vcForOdataFilterTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.MetricDefinitionList = armstorsimple8000series.MetricDefinitionList{
		// 	Value: []*armstorsimple8000series.MetricDefinition{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Cloud Storage Used"),
		// 				Value: to.Ptr("CloudConsumedStorage"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read I/O Operations/s"),
		// 				Value: to.Ptr("DeviceToCloudReadOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write I/O Operations/s"),
		// 				Value: to.Ptr("DeviceToCloudWriteOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Bytes/s"),
		// 				Value: to.Ptr("DeviceToCloudReadBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Bytes/s"),
		// 				Value: to.Ptr("DeviceToCloudWriteBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Latency"),
		// 				Value: to.Ptr("DeviceToCloudReadLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Latency"),
		// 				Value: to.Ptr("DeviceToCloudWriteLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Outstanding I/O"),
		// 				Value: to.Ptr("DeviceToCloudOutStandingIO"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metricsDefinitions"),
		// 			Category: to.Ptr("DeviceToCloudIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 	}},
		// }
	}
}

Output:

func (*VolumeContainersClient) NewListMetricsPager 

func (client *VolumeContainersClient) NewListMetricsPager(deviceName string, volumeContainerName string, resourceGroupName string, managerName string, filter string, options *VolumeContainersClientListMetricsOptions) *runtime.Pager[VolumeContainersClientListMetricsResponse]

NewListMetricsPager - Gets the metrics for the specified volume container.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • filter - OData Filter options
  • options - VolumeContainersClientListMetricsOptions contains the optional parameters for the VolumeContainersClient.NewListMetricsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumeContainersListMetrics.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumeContainersClient().NewListMetricsPager("Device05ForSDKTest", "vcForOdataFilterTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", "name/value%20eq%20'CloudConsumedStorage'%20and%20timeGrain%20eq%20'PT1M'%20and%20startTime%20ge%20'2017-06-17T18:30:00Z'%20and%20endTime%20le%20'2017-06-21T18:30:00Z'%20and%20category%20eq%20'CapacityUtilization'", 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.MetricList = armstorsimple8000series.MetricList{
		// 	Value: []*armstorsimple8000series.Metrics{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Cloud Storage Used"),
		// 				Value: to.Ptr("CloudConsumedStorage"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/metrics"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("VolumeContainer"),
		// 					Value: to.Ptr("vcForOdataFilterTest"),
		// 			}},
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-21T18:30:00.000Z"); return t}()),
		// 			PrimaryAggregation: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest"),
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-17T18:30:00.000Z"); return t}()),
		// 			TimeGrain: to.Ptr("00:01:00"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 			Values: []*armstorsimple8000series.MetricData{
		// 			},
		// 	}},
		// }
	}
}

Output:

type VolumeContainersClientBeginCreateOrUpdateOptions 

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

VolumeContainersClientBeginCreateOrUpdateOptions contains the optional parameters for the VolumeContainersClient.BeginCreateOrUpdate method.

type VolumeContainersClientBeginDeleteOptions 

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

VolumeContainersClientBeginDeleteOptions contains the optional parameters for the VolumeContainersClient.BeginDelete method.

type VolumeContainersClientCreateOrUpdateResponse 

type VolumeContainersClientCreateOrUpdateResponse struct {
	// The volume container.
	VolumeContainer
}

VolumeContainersClientCreateOrUpdateResponse contains the response from method VolumeContainersClient.BeginCreateOrUpdate.

type VolumeContainersClientDeleteResponse 

type VolumeContainersClientDeleteResponse struct {
}

VolumeContainersClientDeleteResponse contains the response from method VolumeContainersClient.BeginDelete.

type VolumeContainersClientGetOptions 

type VolumeContainersClientGetOptions struct {
}

VolumeContainersClientGetOptions contains the optional parameters for the VolumeContainersClient.Get method.

type VolumeContainersClientGetResponse 

type VolumeContainersClientGetResponse struct {
	// The volume container.
	VolumeContainer
}

VolumeContainersClientGetResponse contains the response from method VolumeContainersClient.Get.

type VolumeContainersClientListByDeviceOptions 

type VolumeContainersClientListByDeviceOptions struct {
}

VolumeContainersClientListByDeviceOptions contains the optional parameters for the VolumeContainersClient.NewListByDevicePager method.

type VolumeContainersClientListByDeviceResponse 

type VolumeContainersClientListByDeviceResponse struct {
	// The collection of volume container entities.
	VolumeContainerList
}

VolumeContainersClientListByDeviceResponse contains the response from method VolumeContainersClient.NewListByDevicePager.

type VolumeContainersClientListMetricDefinitionOptions 

type VolumeContainersClientListMetricDefinitionOptions struct {
}

VolumeContainersClientListMetricDefinitionOptions contains the optional parameters for the VolumeContainersClient.NewListMetricDefinitionPager method.

type VolumeContainersClientListMetricDefinitionResponse 

type VolumeContainersClientListMetricDefinitionResponse struct {
	// The list of metric definitions.
	MetricDefinitionList
}

VolumeContainersClientListMetricDefinitionResponse contains the response from method VolumeContainersClient.NewListMetricDefinitionPager.

type VolumeContainersClientListMetricsOptions 

type VolumeContainersClientListMetricsOptions struct {
}

VolumeContainersClientListMetricsOptions contains the optional parameters for the VolumeContainersClient.NewListMetricsPager method.

type VolumeContainersClientListMetricsResponse 

type VolumeContainersClientListMetricsResponse struct {
	// The metric list.
	MetricList
}

VolumeContainersClientListMetricsResponse contains the response from method VolumeContainersClient.NewListMetricsPager.

type VolumeFailoverMetadata 

type VolumeFailoverMetadata struct {
	// The date at which the snapshot was taken.
	BackupCreatedDate *time.Time

	// The path ID of the backup-element for this volume, inside the backup set.
	BackupElementID *string

	// The path ID of the backup set.
	BackupID *string

	// The path ID of the backup policy using which the snapshot was taken.
	BackupPolicyID *string

	// The size of the volume in bytes at the time the snapshot was taken.
	SizeInBytes *int64

	// The path ID of the volume.
	VolumeID *string

	// The type of the volume.
	VolumeType *VolumeType
}

VolumeFailoverMetadata - The metadata of a volume that has valid cloud snapshot.

func (VolumeFailoverMetadata) MarshalJSON 

func (v VolumeFailoverMetadata) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeFailoverMetadata.

func (*VolumeFailoverMetadata) UnmarshalJSON 

func (v *VolumeFailoverMetadata) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeFailoverMetadata.

type VolumeList 

type VolumeList struct {
	// REQUIRED; The value.
	Value []*Volume
}

VolumeList - The collection of volumes.

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 VolumeProperties 

type VolumeProperties struct {
	// REQUIRED; The IDs of the access control records, associated with the volume.
	AccessControlRecordIDs []*string

	// REQUIRED; The monitoring status of the volume.
	MonitoringStatus *MonitoringStatus

	// REQUIRED; The size of the volume in bytes.
	SizeInBytes *int64

	// REQUIRED; The volume status.
	VolumeStatus *VolumeStatus

	// REQUIRED; The type of the volume.
	VolumeType *VolumeType

	// READ-ONLY; The IDs of the backup policies, in which this volume is part of.
	BackupPolicyIDs []*string

	// READ-ONLY; The backup status of the volume.
	BackupStatus *BackupStatus

	// READ-ONLY; The operation status on the volume.
	OperationStatus *OperationStatus

	// READ-ONLY; The ID of the volume container, in which this volume is created.
	VolumeContainerID *string
}

VolumeProperties - The properties of volume.

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 VolumeStatus 

type VolumeStatus string

VolumeStatus - The volume status. 

const (
	VolumeStatusOffline VolumeStatus = "Offline"
	VolumeStatusOnline  VolumeStatus = "Online"
)

func PossibleVolumeStatusValues 

func PossibleVolumeStatusValues() []VolumeStatus

PossibleVolumeStatusValues returns the possible values for the VolumeStatus const type.

type VolumeType 

type VolumeType string

VolumeType - The volume type. 

const (
	VolumeTypeArchival      VolumeType = "Archival"
	VolumeTypeLocallyPinned VolumeType = "LocallyPinned"
	VolumeTypeTiered        VolumeType = "Tiered"
)

func PossibleVolumeTypeValues 

func PossibleVolumeTypeValues() []VolumeType

PossibleVolumeTypeValues returns the possible values for the VolumeType 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 subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VolumesClient) BeginCreateOrUpdate 

func (client *VolumesClient) BeginCreateOrUpdate(ctx context.Context, deviceName string, volumeContainerName string, volumeName string, resourceGroupName string, managerName string, parameters Volume, options *VolumesClientBeginCreateOrUpdateOptions) (*runtime.Poller[VolumesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates the volume. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • volumeName - The volume name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • parameters - Volume to be created or updated.
  • 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/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesCreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVolumesClient().BeginCreateOrUpdate(ctx, "Device05ForSDKTest", "VolumeContainerForSDKTest", "Volume1ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", armstorsimple8000series.Volume{
		Properties: &armstorsimple8000series.VolumeProperties{
			AccessControlRecordIDs: []*string{
				to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
			MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
			SizeInBytes:      to.Ptr[int64](5368709120),
			VolumeStatus:     to.Ptr(armstorsimple8000series.VolumeStatusOffline),
			VolumeType:       to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		},
	}, 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 = armstorsimple8000series.Volume{
	// 	Name: to.Ptr("Volume1ForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/VolumeContainerForSDKTest/volumes/Volume1ForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.VolumeProperties{
	// 		AccessControlRecordIDs: []*string{
	// 			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
	// 			BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusDisabled),
	// 			MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
	// 			OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
	// 			SizeInBytes: to.Ptr[int64](5368709120),
	// 			VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/VolumeContainerForSDKTest"),
	// 			VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOffline),
	// 			VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
	// 		},
	// 	}
}

Output:

func (*VolumesClient) BeginDelete 

func (client *VolumesClient) BeginDelete(ctx context.Context, deviceName string, volumeContainerName string, volumeName string, resourceGroupName string, managerName string, options *VolumesClientBeginDeleteOptions) (*runtime.Poller[VolumesClientDeleteResponse], error)

BeginDelete - Deletes the volume. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • volumeName - The volume name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • 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/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVolumesClient().BeginDelete(ctx, "Device05ForSDKTest", "VolumeContainerForSDKTest", "Volume1ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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) Get 

func (client *VolumesClient) Get(ctx context.Context, deviceName string, volumeContainerName string, volumeName string, resourceGroupName string, managerName string, options *VolumesClientGetOptions) (VolumesClientGetResponse, error)

Get - Returns the properties of the specified volume name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • volumeName - The volume name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • 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/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVolumesClient().Get(ctx, "Device05ForSDKTest", "VolumeContainerForSDKTest", "Volume1ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 = armstorsimple8000series.Volume{
	// 	Name: to.Ptr("Volume1ForSDKTest"),
	// 	Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
	// 	ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/VolumeContainerForSDKTest/volumes/Volume1ForSDKTest"),
	// 	Kind: to.Ptr("Series8000"),
	// 	Properties: &armstorsimple8000series.VolumeProperties{
	// 		AccessControlRecordIDs: []*string{
	// 			to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
	// 			BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusDisabled),
	// 			MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
	// 			OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
	// 			SizeInBytes: to.Ptr[int64](5368709120),
	// 			VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/VolumeContainerForSDKTest"),
	// 			VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOffline),
	// 			VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
	// 		},
	// 	}
}

Output:

func (*VolumesClient) NewListByDevicePager 

func (client *VolumesClient) NewListByDevicePager(deviceName string, resourceGroupName string, managerName string, options *VolumesClientListByDeviceOptions) *runtime.Pager[VolumesClientListByDeviceResponse]

NewListByDevicePager - Retrieves all the volumes in a device.

Generated from API version 2017-06-01

  • deviceName - The device name
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumesClientListByDeviceOptions contains the optional parameters for the VolumesClient.NewListByDevicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesListByDevice.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumesClient().NewListByDevicePager("Device05ForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 = armstorsimple8000series.VolumeList{
		// 	Value: []*armstorsimple8000series.Volume{
		// 		{
		// 			Name: to.Ptr("Clonedvolume1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/Clonedvolume1"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.VolumeProperties{
		// 				AccessControlRecordIDs: []*string{
		// 					to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		// 					BackupPolicyIDs: []*string{
		// 						to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest")},
		// 						BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusEnabled),
		// 						MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusDisabled),
		// 						OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
		// 						SizeInBytes: to.Ptr[int64](10737418240),
		// 						VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 						VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOnline),
		// 						VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 					},
		// 				},
		// 				{
		// 					Name: to.Ptr("volume1"),
		// 					Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
		// 					ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume1"),
		// 					Kind: to.Ptr("Series8000"),
		// 					Properties: &armstorsimple8000series.VolumeProperties{
		// 						AccessControlRecordIDs: []*string{
		// 							to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		// 							BackupPolicyIDs: []*string{
		// 								to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest1032280949"),
		// 								to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicy01ForSDKTest")},
		// 								BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusEnabled),
		// 								MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
		// 								OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
		// 								SizeInBytes: to.Ptr[int64](10737418240),
		// 								VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 								VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOnline),
		// 								VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 							},
		// 						},
		// 						{
		// 							Name: to.Ptr("volume2"),
		// 							Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
		// 							ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume2"),
		// 							Kind: to.Ptr("Series8000"),
		// 							Properties: &armstorsimple8000series.VolumeProperties{
		// 								AccessControlRecordIDs: []*string{
		// 									to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR1"),
		// 									to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		// 									BackupPolicyIDs: []*string{
		// 										to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest1032280949")},
		// 										BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusDisabled),
		// 										MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
		// 										OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
		// 										SizeInBytes: to.Ptr[int64](16106127360),
		// 										VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 										VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOnline),
		// 										VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 									},
		// 							}},
		// 						}
	}
}

Output:

func (*VolumesClient) NewListByVolumeContainerPager 

func (client *VolumesClient) NewListByVolumeContainerPager(deviceName string, volumeContainerName string, resourceGroupName string, managerName string, options *VolumesClientListByVolumeContainerOptions) *runtime.Pager[VolumesClientListByVolumeContainerResponse]

NewListByVolumeContainerPager - Retrieves all the volumes in a volume container.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumesClientListByVolumeContainerOptions contains the optional parameters for the VolumesClient.NewListByVolumeContainerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesListByVolumeContainer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumesClient().NewListByVolumeContainerPager("Device05ForSDKTest", "volumeContainerForSDKTest", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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 = armstorsimple8000series.VolumeList{
		// 	Value: []*armstorsimple8000series.Volume{
		// 		{
		// 			Name: to.Ptr("Clonedvolume1"),
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
		// 			ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/Clonedvolume1"),
		// 			Kind: to.Ptr("Series8000"),
		// 			Properties: &armstorsimple8000series.VolumeProperties{
		// 				AccessControlRecordIDs: []*string{
		// 					to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		// 					BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusDisabled),
		// 					MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusDisabled),
		// 					OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
		// 					SizeInBytes: to.Ptr[int64](10737418240),
		// 					VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 					VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOnline),
		// 					VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("volume1"),
		// 				Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
		// 				ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume1"),
		// 				Kind: to.Ptr("Series8000"),
		// 				Properties: &armstorsimple8000series.VolumeProperties{
		// 					AccessControlRecordIDs: []*string{
		// 						to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		// 						BackupPolicyIDs: []*string{
		// 							to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest1032280949")},
		// 							BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusDisabled),
		// 							MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
		// 							OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
		// 							SizeInBytes: to.Ptr[int64](10737418240),
		// 							VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 							VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOnline),
		// 							VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 						},
		// 					},
		// 					{
		// 						Name: to.Ptr("volume2"),
		// 						Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes"),
		// 						ID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest/volumes/volume2"),
		// 						Kind: to.Ptr("Series8000"),
		// 						Properties: &armstorsimple8000series.VolumeProperties{
		// 							AccessControlRecordIDs: []*string{
		// 								to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR1"),
		// 								to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/accessControlRecords/ACR2")},
		// 								BackupPolicyIDs: []*string{
		// 									to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/backupPolicies/BkUpPolicyForSDKTest1032280949")},
		// 									BackupStatus: to.Ptr(armstorsimple8000series.BackupStatusDisabled),
		// 									MonitoringStatus: to.Ptr(armstorsimple8000series.MonitoringStatusEnabled),
		// 									OperationStatus: to.Ptr(armstorsimple8000series.OperationStatusNone),
		// 									SizeInBytes: to.Ptr[int64](16106127360),
		// 									VolumeContainerID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/volumeContainerForSDKTest"),
		// 									VolumeStatus: to.Ptr(armstorsimple8000series.VolumeStatusOnline),
		// 									VolumeType: to.Ptr(armstorsimple8000series.VolumeTypeTiered),
		// 								},
		// 						}},
		// 					}
	}
}

Output:

func (*VolumesClient) NewListMetricDefinitionPager 

func (client *VolumesClient) NewListMetricDefinitionPager(deviceName string, volumeContainerName string, volumeName string, resourceGroupName string, managerName string, options *VolumesClientListMetricDefinitionOptions) *runtime.Pager[VolumesClientListMetricDefinitionResponse]

NewListMetricDefinitionPager - Gets the metric definitions for the specified volume.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • volumeName - The volume name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • options - VolumesClientListMetricDefinitionOptions contains the optional parameters for the VolumesClient.NewListMetricDefinitionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesListMetricDefinition.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumesClient().NewListMetricDefinitionPager("Device05ForSDKTest", "vcForOdataFilterTest", "CloneVolForSDKTest890836587", "ResourceGroupForSDKTest", "ManagerForSDKTest1", 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.MetricDefinitionList = armstorsimple8000series.MetricDefinitionList{
		// 	Value: []*armstorsimple8000series.MetricDefinition{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Tiered Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageTieredUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Locally Pinned Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageLocallyPinnedUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("CapacityUtilization"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read I/O Operations/s"),
		// 				Value: to.Ptr("InitiatorToDeviceReadOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write I/O Operations/s"),
		// 				Value: to.Ptr("InitiatorToDeviceWriteOperations"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Bytes/s"),
		// 				Value: to.Ptr("InitiatorToDeviceReadBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Bytes/s"),
		// 				Value: to.Ptr("InitiatorToDeviceWriteBytes"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytesPerSecond),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Read Latency"),
		// 				Value: to.Ptr("InitiatorToDeviceReadLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Write Latency"),
		// 				Value: to.Ptr("InitiatorToDeviceWriteLatency"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitSeconds),
		// 		},
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Outstanding I/O"),
		// 				Value: to.Ptr("InitiatorToDeviceOutStandingIO"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metricsDefinitions"),
		// 			Category: to.Ptr("InitiatorToDeviceIOPerformance"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			MetricAvailabilities: []*armstorsimple8000series.MetricAvailablity{
		// 				{
		// 					Retention: to.Ptr("PT6H"),
		// 					TimeGrain: to.Ptr("PT1M"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P7D"),
		// 					TimeGrain: to.Ptr("PT1H"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P3M"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 				},
		// 				{
		// 					Retention: to.Ptr("P1Y"),
		// 					TimeGrain: to.Ptr("P1D"),
		// 			}},
		// 			PrimaryAggregationType: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitCount),
		// 	}},
		// }
	}
}

Output:

func (*VolumesClient) NewListMetricsPager 

func (client *VolumesClient) NewListMetricsPager(deviceName string, volumeContainerName string, volumeName string, resourceGroupName string, managerName string, filter string, options *VolumesClientListMetricsOptions) *runtime.Pager[VolumesClientListMetricsResponse]

NewListMetricsPager - Gets the metrics for the specified volume.

Generated from API version 2017-06-01

  • deviceName - The device name
  • volumeContainerName - The volume container name.
  • volumeName - The volume name.
  • resourceGroupName - The resource group name
  • managerName - The manager name
  • filter - OData Filter options
  • options - VolumesClientListMetricsOptions contains the optional parameters for the VolumesClient.NewListMetricsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/storsimple8000series/resource-manager/Microsoft.StorSimple/stable/2017-06-01/examples/VolumesListMetrics.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storsimple8000series/armstorsimple8000series"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorsimple8000series.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVolumesClient().NewListMetricsPager("Device05ForSDKTest", "vcForOdataFilterTest", "CloneVolForSDKTest890836587", "ResourceGroupForSDKTest", "ManagerForSDKTest1", "name/value%20eq%20'PrimaryStorageTieredUsed'%20and%20timeGrain%20eq%20'PT1H'%20and%20startTime%20ge%20'2017-06-17T18:30:00Z'%20and%20endTime%20le%20'2017-06-21T18:30:00Z'%20and%20category%20eq%20'CapacityUtilization'", 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.MetricList = armstorsimple8000series.MetricList{
		// 	Value: []*armstorsimple8000series.Metrics{
		// 		{
		// 			Name: &armstorsimple8000series.MetricName{
		// 				LocalizedValue: to.Ptr("Primary Tiered Storage Used"),
		// 				Value: to.Ptr("PrimaryStorageTieredUsed"),
		// 			},
		// 			Type: to.Ptr("Microsoft.StorSimple/managers/devices/volumeContainers/volumes/metrics"),
		// 			Dimensions: []*armstorsimple8000series.MetricDimension{
		// 				{
		// 					Name: to.Ptr("Volume"),
		// 					Value: to.Ptr("CloneVolForSDKTest890836587"),
		// 			}},
		// 			EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-21T18:30:00.000Z"); return t}()),
		// 			PrimaryAggregation: to.Ptr(armstorsimple8000series.MetricAggregationTypeAverage),
		// 			ResourceID: to.Ptr("/subscriptions/4385cf00-2d3a-425a-832f-f4285b1c9dce/resourceGroups/ResourceGroupForSDKTest/providers/Microsoft.StorSimple/managers/ManagerForSDKTest1/devices/Device05ForSDKTest/volumeContainers/vcForOdataFilterTest/volumes/CloneVolForSDKTest890836587"),
		// 			StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-06-17T18:30:00.000Z"); return t}()),
		// 			TimeGrain: to.Ptr("01:00:00"),
		// 			Unit: to.Ptr(armstorsimple8000series.MetricUnitBytes),
		// 			Values: []*armstorsimple8000series.MetricData{
		// 			},
		// 	}},
		// }
	}
}

Output:

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 {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

VolumesClientBeginDeleteOptions contains the optional parameters for the VolumesClient.BeginDelete method.

type VolumesClientCreateOrUpdateResponse 

type VolumesClientCreateOrUpdateResponse struct {
	// The volume.
	Volume
}

VolumesClientCreateOrUpdateResponse contains the response from method VolumesClient.BeginCreateOrUpdate.

type VolumesClientDeleteResponse 

type VolumesClientDeleteResponse struct {
}

VolumesClientDeleteResponse contains the response from method VolumesClient.BeginDelete.

type VolumesClientGetOptions 

type VolumesClientGetOptions struct {
}

VolumesClientGetOptions contains the optional parameters for the VolumesClient.Get method.

type VolumesClientGetResponse 

type VolumesClientGetResponse struct {
	// The volume.
	Volume
}

VolumesClientGetResponse contains the response from method VolumesClient.Get.

type VolumesClientListByDeviceOptions 

type VolumesClientListByDeviceOptions struct {
}

VolumesClientListByDeviceOptions contains the optional parameters for the VolumesClient.NewListByDevicePager method.

type VolumesClientListByDeviceResponse 

type VolumesClientListByDeviceResponse struct {
	// The collection of volumes.
	VolumeList
}

VolumesClientListByDeviceResponse contains the response from method VolumesClient.NewListByDevicePager.

type VolumesClientListByVolumeContainerOptions 

type VolumesClientListByVolumeContainerOptions struct {
}

VolumesClientListByVolumeContainerOptions contains the optional parameters for the VolumesClient.NewListByVolumeContainerPager method.

type VolumesClientListByVolumeContainerResponse 

type VolumesClientListByVolumeContainerResponse struct {
	// The collection of volumes.
	VolumeList
}

VolumesClientListByVolumeContainerResponse contains the response from method VolumesClient.NewListByVolumeContainerPager.

type VolumesClientListMetricDefinitionOptions 

type VolumesClientListMetricDefinitionOptions struct {
}

VolumesClientListMetricDefinitionOptions contains the optional parameters for the VolumesClient.NewListMetricDefinitionPager method.

type VolumesClientListMetricDefinitionResponse 

type VolumesClientListMetricDefinitionResponse struct {
	// The list of metric definitions.
	MetricDefinitionList
}

VolumesClientListMetricDefinitionResponse contains the response from method VolumesClient.NewListMetricDefinitionPager.

type VolumesClientListMetricsOptions 

type VolumesClientListMetricsOptions struct {
}

VolumesClientListMetricsOptions contains the optional parameters for the VolumesClient.NewListMetricsPager method.

type VolumesClientListMetricsResponse 

type VolumesClientListMetricsResponse struct {
	// The metric list.
	MetricList
}

VolumesClientListMetricsResponse contains the response from method VolumesClient.NewListMetricsPager.

type WebproxySettings 

type WebproxySettings struct {
	// REQUIRED; The authentication type.
	Authentication *AuthenticationType

	// REQUIRED; The webproxy username.
	Username *string

	// The connection URI.
	ConnectionURI *string
}

WebproxySettings - The web proxy settings on the device.

func (WebproxySettings) MarshalJSON 

func (w WebproxySettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WebproxySettings.

func (*WebproxySettings) UnmarshalJSON 

func (w *WebproxySettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WebproxySettings.

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.