armmixedreality

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: 14 Imported by: 0

README

Azure Mixed Readlity Module for Go

The armmixedreality module provides operations for working with Azure Mixed Readlity.

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 Mixed Readlity module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality

Authorization

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

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 Mixed Readlity 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 AccountKeyRegenerateRequest 

type AccountKeyRegenerateRequest struct {
	// Serial of key to be regenerated
	Serial *Serial
}

AccountKeyRegenerateRequest - Request for account key regeneration

func (AccountKeyRegenerateRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountKeyRegenerateRequest.

func (*AccountKeyRegenerateRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountKeyRegenerateRequest.

type AccountKeys 

type AccountKeys struct {
	// READ-ONLY; value of primary key.
	PrimaryKey *string

	// READ-ONLY; value of secondary key.
	SecondaryKey *string
}

AccountKeys - Developer Keys of account

func (AccountKeys) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountKeys.

func (*AccountKeys) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountKeys.

type AccountProperties 

type AccountProperties struct {
	// The name of the storage account associated with this accountId
	StorageAccountName *string

	// READ-ONLY; Correspond domain name of certain Spatial Anchors Account
	AccountDomain *string

	// READ-ONLY; unique id of certain account.
	AccountID *string
}

AccountProperties - Common Properties shared by Mixed Reality Accounts

func (AccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountProperties.

func (*AccountProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountProperties.

type CheckNameAvailabilityRequest 

type CheckNameAvailabilityRequest struct {
	// REQUIRED; Resource Name To Verify
	Name *string

	// REQUIRED; Fully qualified resource type which includes provider namespace
	Type *string
}

CheckNameAvailabilityRequest - Check Name Availability Request

func (CheckNameAvailabilityRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityRequest.

func (*CheckNameAvailabilityRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityRequest.

type CheckNameAvailabilityResponse 

type CheckNameAvailabilityResponse struct {
	// REQUIRED; if name Available
	NameAvailable *bool

	// detail message
	Message *string

	// Resource Name To Verify
	Reason *NameUnavailableReason
}

CheckNameAvailabilityResponse - Check Name Availability Response

func (CheckNameAvailabilityResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResponse.

func (*CheckNameAvailabilityResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityResponse.

type Client 

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

Client contains the methods for the MixedRealityClient group. Don't use this type directly, use NewClient() instead.

func NewClient 

func NewClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*Client, error)

NewClient creates a new instance of Client with the specified values.

  • subscriptionID - The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*Client) CheckNameAvailabilityLocal 

func (client *Client) CheckNameAvailabilityLocal(ctx context.Context, location string, checkNameAvailability CheckNameAvailabilityRequest, options *ClientCheckNameAvailabilityLocalOptions) (ClientCheckNameAvailabilityLocalResponse, error)

CheckNameAvailabilityLocal - Check Name Availability for local uniqueness If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • location - The location in which uniqueness will be verified.
  • checkNameAvailability - Check Name Availability Request.
  • options - ClientCheckNameAvailabilityLocalOptions contains the optional parameters for the Client.CheckNameAvailabilityLocal method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/proxy/CheckNameAvailabilityForLocalUniqueness.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().CheckNameAvailabilityLocal(ctx, "eastus2euap", armmixedreality.CheckNameAvailabilityRequest{
		Name: to.Ptr("MyAccount"),
		Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
	}, 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.CheckNameAvailabilityResponse = armmixedreality.CheckNameAvailabilityResponse{
	// 	Message: to.Ptr("..."),
	// 	NameAvailable: to.Ptr(false),
	// 	Reason: to.Ptr(armmixedreality.NameUnavailableReasonAlreadyExists),
	// }
}

Output:

type ClientCheckNameAvailabilityLocalOptions 

type ClientCheckNameAvailabilityLocalOptions struct {
}

ClientCheckNameAvailabilityLocalOptions contains the optional parameters for the Client.CheckNameAvailabilityLocal method.

type ClientCheckNameAvailabilityLocalResponse 

type ClientCheckNameAvailabilityLocalResponse struct {
	// Check Name Availability Response
	CheckNameAvailabilityResponse
}

ClientCheckNameAvailabilityLocalResponse contains the response from method Client.CheckNameAvailabilityLocal.

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 Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewClient 

func (c *ClientFactory) NewClient() *Client

NewClient creates a new instance of Client.

func (*ClientFactory) NewObjectAnchorsAccountsClient 

func (c *ClientFactory) NewObjectAnchorsAccountsClient() *ObjectAnchorsAccountsClient

NewObjectAnchorsAccountsClient creates a new instance of ObjectAnchorsAccountsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewRemoteRenderingAccountsClient 

func (c *ClientFactory) NewRemoteRenderingAccountsClient() *RemoteRenderingAccountsClient

NewRemoteRenderingAccountsClient creates a new instance of RemoteRenderingAccountsClient.

func (*ClientFactory) NewSpatialAnchorsAccountsClient 

func (c *ClientFactory) NewSpatialAnchorsAccountsClient() *SpatialAnchorsAccountsClient

NewSpatialAnchorsAccountsClient creates a new instance of SpatialAnchorsAccountsClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type Identity 

type Identity struct {
	// The identity type.
	Type *string

	// READ-ONLY; The principal ID of resource identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of resource.
	TenantID *string
}

Identity for the resource.

func (Identity) MarshalJSON 

func (i Identity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Identity.

func (*Identity) UnmarshalJSON 

func (i *Identity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Identity.

type LogSpecification 

type LogSpecification struct {
	// Blob duration of the log
	BlobDuration *string

	// Localized friendly display name of the log
	DisplayName *string

	// Name of the log
	Name *string
}

LogSpecification - Specifications of the Log for Azure Monitoring

func (LogSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LogSpecification.

func (*LogSpecification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LogSpecification.

type MetricDimension 

type MetricDimension struct {
	// Localized friendly display name of the dimension
	DisplayName *string

	// Internal name of the dimension.
	InternalName *string

	// Name of the dimension
	Name *string

	// Flag to indicate export for Shoebox
	ToBeExportedForShoebox *bool
}

MetricDimension - Specifications of the Dimension of metrics

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 MetricSpecification 

type MetricSpecification struct {
	// Only provide one value for this field. Valid values: Average, Minimum, Maximum, Total, Count.
	AggregationType *string

	// Metric category
	Category *string

	// Dimensions of the metric
	Dimensions []*MetricDimension

	// Localized friendly description of the metric
	DisplayDescription *string

	// Localized friendly display name of the metric
	DisplayName *string

	// Flag to indicate use of regional Mdm accounts
	EnableRegionalMdmAccount *bool

	// Flag to determine is Zero is returned for time duration where no metric is emitted
	FillGapWithZero *bool

	// Internal metric name.
	InternalMetricName *string

	// Locked aggregation type of the metric
	LockedAggregationType *string

	// Metric filter regex pattern
	MetricFilterPattern *string

	// Name of the metric
	Name *string

	// Source mdm account
	SourceMdmAccount *string

	// Source mdm namespace
	SourceMdmNamespace *string

	// Supported aggregation types. Valid values: Average, Minimum, Maximum, Total, Count.
	SupportedAggregationTypes []*string

	// Supported time grains. Valid values: PT1M, PT5M, PT15M, PT30M, PT1H, PT6H, PT12H, P1D
	SupportedTimeGrainTypes []*string

	// Unit that makes sense for the metric
	Unit *string
}

MetricSpecification - Specifications of the Metrics for Azure Monitoring

func (MetricSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricSpecification.

func (*MetricSpecification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetricSpecification.

type NameUnavailableReason 

type NameUnavailableReason string

NameUnavailableReason - reason of name unavailable. 

const (
	NameUnavailableReasonAlreadyExists NameUnavailableReason = "AlreadyExists"
	NameUnavailableReasonInvalid       NameUnavailableReason = "Invalid"
)

func PossibleNameUnavailableReasonValues 

func PossibleNameUnavailableReasonValues() []NameUnavailableReason

PossibleNameUnavailableReasonValues returns the possible values for the NameUnavailableReason const type.

type ObjectAnchorsAccount 

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

	// The kind of account, if supported
	Kind *SKU

	// The plan associated with this account
	Plan *Identity

	// Property bag.
	Properties *AccountProperties

	// The sku associated with this account
	SKU *SKU

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

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

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

	// READ-ONLY; The system metadata related to an object anchors account.
	SystemData *SystemData

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

ObjectAnchorsAccount Response.

func (ObjectAnchorsAccount) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ObjectAnchorsAccount.

func (*ObjectAnchorsAccount) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ObjectAnchorsAccount.

type ObjectAnchorsAccountIdentity 

type ObjectAnchorsAccountIdentity struct {
	// The identity type.
	Type *string

	// READ-ONLY; The principal ID of resource identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of resource.
	TenantID *string
}

func (ObjectAnchorsAccountIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ObjectAnchorsAccountIdentity.

func (*ObjectAnchorsAccountIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ObjectAnchorsAccountIdentity.

type ObjectAnchorsAccountPage 

type ObjectAnchorsAccountPage struct {
	// URL to get the next set of resource list results if there are any.
	NextLink *string

	// List of resources supported by the Resource Provider.
	Value []*ObjectAnchorsAccount
}

ObjectAnchorsAccountPage - Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of results.

func (ObjectAnchorsAccountPage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ObjectAnchorsAccountPage.

func (*ObjectAnchorsAccountPage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ObjectAnchorsAccountPage.

type ObjectAnchorsAccountsClient 

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

ObjectAnchorsAccountsClient contains the methods for the ObjectAnchorsAccounts group. Don't use this type directly, use NewObjectAnchorsAccountsClient() instead.

func NewObjectAnchorsAccountsClient 

func NewObjectAnchorsAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ObjectAnchorsAccountsClient, error)

NewObjectAnchorsAccountsClient creates a new instance of ObjectAnchorsAccountsClient with the specified values.

  • subscriptionID - The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ObjectAnchorsAccountsClient) Create 

func (client *ObjectAnchorsAccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, objectAnchorsAccount ObjectAnchorsAccount, options *ObjectAnchorsAccountsClientCreateOptions) (ObjectAnchorsAccountsClientCreateResponse, error)

Create - Creating or Updating an object anchors Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • objectAnchorsAccount - Object Anchors Account parameter.
  • options - ObjectAnchorsAccountsClientCreateOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/Put.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewObjectAnchorsAccountsClient().Create(ctx, "MyResourceGroup", "MyAccount", armmixedreality.ObjectAnchorsAccount{
		Location: to.Ptr("eastus2euap"),
		Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
			Type: to.Ptr("SystemAssigned"),
		},
	}, 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.ObjectAnchorsAccount = armmixedreality.ObjectAnchorsAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

func (*ObjectAnchorsAccountsClient) Delete 

func (client *ObjectAnchorsAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, options *ObjectAnchorsAccountsClientDeleteOptions) (ObjectAnchorsAccountsClientDeleteResponse, error)

Delete - Delete an Object Anchors Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - ObjectAnchorsAccountsClientDeleteOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewObjectAnchorsAccountsClient().Delete(ctx, "MyResourceGroup", "MyAccount", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ObjectAnchorsAccountsClient) Get 

func (client *ObjectAnchorsAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *ObjectAnchorsAccountsClientGetOptions) (ObjectAnchorsAccountsClientGetResponse, error)

Get - Retrieve an Object Anchors Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - ObjectAnchorsAccountsClientGetOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewObjectAnchorsAccountsClient().Get(ctx, "MyResourceGroup", "MyAccount", 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.ObjectAnchorsAccount = armmixedreality.ObjectAnchorsAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

func (*ObjectAnchorsAccountsClient) ListKeys 

func (client *ObjectAnchorsAccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string, options *ObjectAnchorsAccountsClientListKeysOptions) (ObjectAnchorsAccountsClientListKeysResponse, error)

ListKeys - List Both of the 2 Keys of an object anchors Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - ObjectAnchorsAccountsClientListKeysOptions contains the optional parameters for the ObjectAnchorsAccountsClient.ListKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/ListKeys.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewObjectAnchorsAccountsClient().ListKeys(ctx, "MyResourceGroup", "MyAccount", 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.AccountKeys = armmixedreality.AccountKeys{
	// 	PrimaryKey: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// 	SecondaryKey: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// }
}

Output:

func (*ObjectAnchorsAccountsClient) NewListByResourceGroupPager 

func (client *ObjectAnchorsAccountsClient) NewListByResourceGroupPager(resourceGroupName string, options *ObjectAnchorsAccountsClientListByResourceGroupOptions) *runtime.Pager[ObjectAnchorsAccountsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List Resources by Resource Group

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • options - ObjectAnchorsAccountsClientListByResourceGroupOptions contains the optional parameters for the ObjectAnchorsAccountsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/GetByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewObjectAnchorsAccountsClient().NewListByResourceGroupPager("MyResourceGroup", 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.ObjectAnchorsAccountPage = armmixedreality.ObjectAnchorsAccountPage{
		// 	Value: []*armmixedreality.ObjectAnchorsAccount{
		// 		{
		// 			Name: to.Ptr("alpha"),
		// 			Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/alpha"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("omega"),
		// 			Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/omega"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ObjectAnchorsAccountsClient) NewListBySubscriptionPager 

func (client *ObjectAnchorsAccountsClient) NewListBySubscriptionPager(options *ObjectAnchorsAccountsClientListBySubscriptionOptions) *runtime.Pager[ObjectAnchorsAccountsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List Object Anchors Accounts by Subscription

Generated from API version 2021-03-01-preview

  • options - ObjectAnchorsAccountsClientListBySubscriptionOptions contains the optional parameters for the ObjectAnchorsAccountsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/GetBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewObjectAnchorsAccountsClient().NewListBySubscriptionPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ObjectAnchorsAccountPage = armmixedreality.ObjectAnchorsAccountPage{
		// 	Value: []*armmixedreality.ObjectAnchorsAccount{
		// 		{
		// 			Name: to.Ptr("alpha"),
		// 			Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/alpha"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("omega"),
		// 			Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/omega"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ObjectAnchorsAccountsClient) RegenerateKeys 

func (client *ObjectAnchorsAccountsClient) RegenerateKeys(ctx context.Context, resourceGroupName string, accountName string, regenerate AccountKeyRegenerateRequest, options *ObjectAnchorsAccountsClientRegenerateKeysOptions) (ObjectAnchorsAccountsClientRegenerateKeysResponse, error)

RegenerateKeys - Regenerate specified Key of an object anchors Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • regenerate - Required information for key regeneration.
  • options - ObjectAnchorsAccountsClientRegenerateKeysOptions contains the optional parameters for the ObjectAnchorsAccountsClient.RegenerateKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/RegenerateKey.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewObjectAnchorsAccountsClient().RegenerateKeys(ctx, "MyResourceGroup", "MyAccount", armmixedreality.AccountKeyRegenerateRequest{
		Serial: to.Ptr(armmixedreality.SerialPrimary),
	}, 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.AccountKeys = armmixedreality.AccountKeys{
	// 	PrimaryKey: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// 	SecondaryKey: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// }
}

Output:

func (*ObjectAnchorsAccountsClient) Update 

func (client *ObjectAnchorsAccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, objectAnchorsAccount ObjectAnchorsAccount, options *ObjectAnchorsAccountsClientUpdateOptions) (ObjectAnchorsAccountsClientUpdateResponse, error)

Update - Updating an Object Anchors Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • objectAnchorsAccount - Object Anchors Account parameter.
  • options - ObjectAnchorsAccountsClientUpdateOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/object-anchors/Patch.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewObjectAnchorsAccountsClient().Update(ctx, "MyResourceGroup", "MyAccount", armmixedreality.ObjectAnchorsAccount{
		Location: to.Ptr("eastus2euap"),
		Tags: map[string]*string{
			"hero":    to.Ptr("romeo"),
			"heroine": to.Ptr("juliet"),
		},
		Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
			Type: to.Ptr("SystemAssigned"),
		},
	}, 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.ObjectAnchorsAccount = armmixedreality.ObjectAnchorsAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/objectAnchorsAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/objectAnchorsAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 		"hero": to.Ptr("romeo"),
	// 		"heroine": to.Ptr("juliet"),
	// 	},
	// 	Identity: &armmixedreality.ObjectAnchorsAccountIdentity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

type ObjectAnchorsAccountsClientCreateOptions 

type ObjectAnchorsAccountsClientCreateOptions struct {
}

ObjectAnchorsAccountsClientCreateOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Create method.

type ObjectAnchorsAccountsClientCreateResponse 

type ObjectAnchorsAccountsClientCreateResponse struct {
	// ObjectAnchorsAccount Response.
	ObjectAnchorsAccount
}

ObjectAnchorsAccountsClientCreateResponse contains the response from method ObjectAnchorsAccountsClient.Create.

type ObjectAnchorsAccountsClientDeleteOptions 

type ObjectAnchorsAccountsClientDeleteOptions struct {
}

ObjectAnchorsAccountsClientDeleteOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Delete method.

type ObjectAnchorsAccountsClientDeleteResponse 

type ObjectAnchorsAccountsClientDeleteResponse struct {
}

ObjectAnchorsAccountsClientDeleteResponse contains the response from method ObjectAnchorsAccountsClient.Delete.

type ObjectAnchorsAccountsClientGetOptions 

type ObjectAnchorsAccountsClientGetOptions struct {
}

ObjectAnchorsAccountsClientGetOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Get method.

type ObjectAnchorsAccountsClientGetResponse 

type ObjectAnchorsAccountsClientGetResponse struct {
	// ObjectAnchorsAccount Response.
	ObjectAnchorsAccount
}

ObjectAnchorsAccountsClientGetResponse contains the response from method ObjectAnchorsAccountsClient.Get.

type ObjectAnchorsAccountsClientListByResourceGroupOptions 

type ObjectAnchorsAccountsClientListByResourceGroupOptions struct {
}

ObjectAnchorsAccountsClientListByResourceGroupOptions contains the optional parameters for the ObjectAnchorsAccountsClient.NewListByResourceGroupPager method.

type ObjectAnchorsAccountsClientListByResourceGroupResponse 

type ObjectAnchorsAccountsClientListByResourceGroupResponse struct {
	// Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of
	// results.
	ObjectAnchorsAccountPage
}

ObjectAnchorsAccountsClientListByResourceGroupResponse contains the response from method ObjectAnchorsAccountsClient.NewListByResourceGroupPager.

type ObjectAnchorsAccountsClientListBySubscriptionOptions 

type ObjectAnchorsAccountsClientListBySubscriptionOptions struct {
}

ObjectAnchorsAccountsClientListBySubscriptionOptions contains the optional parameters for the ObjectAnchorsAccountsClient.NewListBySubscriptionPager method.

type ObjectAnchorsAccountsClientListBySubscriptionResponse 

type ObjectAnchorsAccountsClientListBySubscriptionResponse struct {
	// Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of
	// results.
	ObjectAnchorsAccountPage
}

ObjectAnchorsAccountsClientListBySubscriptionResponse contains the response from method ObjectAnchorsAccountsClient.NewListBySubscriptionPager.

type ObjectAnchorsAccountsClientListKeysOptions 

type ObjectAnchorsAccountsClientListKeysOptions struct {
}

ObjectAnchorsAccountsClientListKeysOptions contains the optional parameters for the ObjectAnchorsAccountsClient.ListKeys method.

type ObjectAnchorsAccountsClientListKeysResponse 

type ObjectAnchorsAccountsClientListKeysResponse struct {
	// Developer Keys of account
	AccountKeys
}

ObjectAnchorsAccountsClientListKeysResponse contains the response from method ObjectAnchorsAccountsClient.ListKeys.

type ObjectAnchorsAccountsClientRegenerateKeysOptions 

type ObjectAnchorsAccountsClientRegenerateKeysOptions struct {
}

ObjectAnchorsAccountsClientRegenerateKeysOptions contains the optional parameters for the ObjectAnchorsAccountsClient.RegenerateKeys method.

type ObjectAnchorsAccountsClientRegenerateKeysResponse 

type ObjectAnchorsAccountsClientRegenerateKeysResponse struct {
	// Developer Keys of account
	AccountKeys
}

ObjectAnchorsAccountsClientRegenerateKeysResponse contains the response from method ObjectAnchorsAccountsClient.RegenerateKeys.

type ObjectAnchorsAccountsClientUpdateOptions 

type ObjectAnchorsAccountsClientUpdateOptions struct {
}

ObjectAnchorsAccountsClientUpdateOptions contains the optional parameters for the ObjectAnchorsAccountsClient.Update method.

type ObjectAnchorsAccountsClientUpdateResponse 

type ObjectAnchorsAccountsClientUpdateResponse struct {
	// ObjectAnchorsAccount Response.
	ObjectAnchorsAccount
}

ObjectAnchorsAccountsClientUpdateResponse contains the response from method ObjectAnchorsAccountsClient.Update.

type Operation 

type Operation struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// Whether or not this is a data plane operation
	IsDataAction *bool

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

	// The origin
	Origin *string

	// Properties of the operation
	Properties *OperationProperties
}

Operation - REST API operation

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// REQUIRED; Description of operation
	Description *string

	// REQUIRED; Operation type: Read, write, delete, etc.
	Operation *string

	// REQUIRED; Service provider: Microsoft.ResourceProvider
	Provider *string

	// REQUIRED; Resource on which the operation is performed: Profile, endpoint, etc.
	Resource *string
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationPage 

type OperationPage struct {
	// URL to get the next set of operation list results if there are any.
	NextLink *string

	// List of operations supported by the Resource Provider.
	Value []*Operation
}

OperationPage - Result of the request to list Resource Provider operations. It contains a list of operations and a URL link to get the next set of results.

func (OperationPage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationPage.

func (*OperationPage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationPage.

type OperationProperties 

type OperationProperties struct {
	// Service specification.
	ServiceSpecification *ServiceSpecification
}

OperationProperties - Operation properties.

func (OperationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationProperties.

func (*OperationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationProperties.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager 

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

NewListPager - Exposing Available Operations

Generated from API version 2021-03-01-preview

  • 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/proxy/ExposingAvailableOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.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.OperationPage = armmixedreality.OperationPage{
		// 	Value: []*armmixedreality.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.MixedReality/register/action"),
		// 			Display: &armmixedreality.OperationDisplay{
		// 				Description: to.Ptr("Registers a subscription for the Mixed Reality resource provider."),
		// 				Operation: to.Ptr("Registers the Mixed Reality resource provider"),
		// 				Provider: to.Ptr("Microsoft.MixedReality"),
		// 				Resource: to.Ptr("Mixed Reality resource provider"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.MixedReality/SpatialAnchorsAccounts/delete"),
		// 			Display: &armmixedreality.OperationDisplay{
		// 				Description: to.Ptr("Deletes the resource for Microsoft.MixedReality/SpatialAnchorsAccounts"),
		// 				Operation: to.Ptr("Delete Spatial Anchors Accounts"),
		// 				Provider: to.Ptr("Microsoft.MixedReality"),
		// 				Resource: to.Ptr("SpatialAnchorsAccounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.MixedReality/SpatialAnchorsAccounts/read"),
		// 			Display: &armmixedreality.OperationDisplay{
		// 				Description: to.Ptr("Gets the resource for Microsoft.MixedReality/SpatialAnchorsAccounts"),
		// 				Operation: to.Ptr("Get Spatial Anchors Accounts"),
		// 				Provider: to.Ptr("Microsoft.MixedReality"),
		// 				Resource: to.Ptr("SpatialAnchorsAccounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.MixedReality/SpatialAnchorsAccounts/write"),
		// 			Display: &armmixedreality.OperationDisplay{
		// 				Description: to.Ptr("Updates the resource for Microsoft.MixedReality/SpatialAnchorsAccounts"),
		// 				Operation: to.Ptr("Update Spatial Anchors Accounts"),
		// 				Provider: to.Ptr("Microsoft.MixedReality"),
		// 				Resource: to.Ptr("SpatialAnchorsAccounts"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

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

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type RemoteRenderingAccount 

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

	// The identity associated with this account
	Identity *Identity

	// The kind of account, if supported
	Kind *SKU

	// The plan associated with this account
	Plan *Identity

	// Property bag.
	Properties *AccountProperties

	// The sku associated with this account
	SKU *SKU

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

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

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

	// READ-ONLY; System metadata for this account
	SystemData *SystemData

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

RemoteRenderingAccount Response.

func (RemoteRenderingAccount) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RemoteRenderingAccount.

func (*RemoteRenderingAccount) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RemoteRenderingAccount.

type RemoteRenderingAccountPage 

type RemoteRenderingAccountPage struct {
	// URL to get the next set of resource list results if there are any.
	NextLink *string

	// List of resources supported by the Resource Provider.
	Value []*RemoteRenderingAccount
}

RemoteRenderingAccountPage - Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of results.

func (RemoteRenderingAccountPage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RemoteRenderingAccountPage.

func (*RemoteRenderingAccountPage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RemoteRenderingAccountPage.

type RemoteRenderingAccountsClient 

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

RemoteRenderingAccountsClient contains the methods for the RemoteRenderingAccounts group. Don't use this type directly, use NewRemoteRenderingAccountsClient() instead.

func NewRemoteRenderingAccountsClient 

func NewRemoteRenderingAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*RemoteRenderingAccountsClient, error)

NewRemoteRenderingAccountsClient creates a new instance of RemoteRenderingAccountsClient with the specified values.

  • subscriptionID - The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*RemoteRenderingAccountsClient) Create 

func (client *RemoteRenderingAccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, remoteRenderingAccount RemoteRenderingAccount, options *RemoteRenderingAccountsClientCreateOptions) (RemoteRenderingAccountsClientCreateResponse, error)

Create - Creating or Updating a Remote Rendering Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • remoteRenderingAccount - Remote Rendering Account parameter.
  • options - RemoteRenderingAccountsClientCreateOptions contains the optional parameters for the RemoteRenderingAccountsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/Put.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewRemoteRenderingAccountsClient().Create(ctx, "MyResourceGroup", "MyAccount", armmixedreality.RemoteRenderingAccount{
		Location: to.Ptr("eastus2euap"),
		Identity: &armmixedreality.Identity{
			Type: to.Ptr("SystemAssigned"),
		},
	}, 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.RemoteRenderingAccount = armmixedreality.RemoteRenderingAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Identity: &armmixedreality.Identity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

func (*RemoteRenderingAccountsClient) Delete 

func (client *RemoteRenderingAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, options *RemoteRenderingAccountsClientDeleteOptions) (RemoteRenderingAccountsClientDeleteResponse, error)

Delete - Delete a Remote Rendering Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - RemoteRenderingAccountsClientDeleteOptions contains the optional parameters for the RemoteRenderingAccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewRemoteRenderingAccountsClient().Delete(ctx, "MyResourceGroup", "MyAccount", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*RemoteRenderingAccountsClient) Get 

func (client *RemoteRenderingAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *RemoteRenderingAccountsClientGetOptions) (RemoteRenderingAccountsClientGetResponse, error)

Get - Retrieve a Remote Rendering Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - RemoteRenderingAccountsClientGetOptions contains the optional parameters for the RemoteRenderingAccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewRemoteRenderingAccountsClient().Get(ctx, "MyResourceGroup", "MyAccount", 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.RemoteRenderingAccount = armmixedreality.RemoteRenderingAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Identity: &armmixedreality.Identity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

func (*RemoteRenderingAccountsClient) ListKeys 

func (client *RemoteRenderingAccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string, options *RemoteRenderingAccountsClientListKeysOptions) (RemoteRenderingAccountsClientListKeysResponse, error)

ListKeys - List Both of the 2 Keys of a Remote Rendering Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - RemoteRenderingAccountsClientListKeysOptions contains the optional parameters for the RemoteRenderingAccountsClient.ListKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/ListKeys.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewRemoteRenderingAccountsClient().ListKeys(ctx, "MyResourceGroup", "MyAccount", 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.AccountKeys = armmixedreality.AccountKeys{
	// 	PrimaryKey: to.Ptr("<primaryKey>"),
	// 	SecondaryKey: to.Ptr("<secondaryKey>"),
	// }
}

Output:

func (*RemoteRenderingAccountsClient) NewListByResourceGroupPager 

func (client *RemoteRenderingAccountsClient) NewListByResourceGroupPager(resourceGroupName string, options *RemoteRenderingAccountsClientListByResourceGroupOptions) *runtime.Pager[RemoteRenderingAccountsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List Resources by Resource Group

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • options - RemoteRenderingAccountsClientListByResourceGroupOptions contains the optional parameters for the RemoteRenderingAccountsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/GetByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewRemoteRenderingAccountsClient().NewListByResourceGroupPager("MyResourceGroup", 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.RemoteRenderingAccountPage = armmixedreality.RemoteRenderingAccountPage{
		// 	Value: []*armmixedreality.RemoteRenderingAccount{
		// 		{
		// 			Name: to.Ptr("alpha"),
		// 			Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/alpha"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.Identity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("omega"),
		// 			Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/omega"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.Identity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*RemoteRenderingAccountsClient) NewListBySubscriptionPager 

func (client *RemoteRenderingAccountsClient) NewListBySubscriptionPager(options *RemoteRenderingAccountsClientListBySubscriptionOptions) *runtime.Pager[RemoteRenderingAccountsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List Remote Rendering Accounts by Subscription

Generated from API version 2021-03-01-preview

  • options - RemoteRenderingAccountsClientListBySubscriptionOptions contains the optional parameters for the RemoteRenderingAccountsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/GetBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewRemoteRenderingAccountsClient().NewListBySubscriptionPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.RemoteRenderingAccountPage = armmixedreality.RemoteRenderingAccountPage{
		// 	Value: []*armmixedreality.RemoteRenderingAccount{
		// 		{
		// 			Name: to.Ptr("alpha"),
		// 			Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/alpha"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.Identity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("omega"),
		// 			Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/omega"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Identity: &armmixedreality.Identity{
		// 				Type: to.Ptr("SystemAssigned"),
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*RemoteRenderingAccountsClient) RegenerateKeys 

func (client *RemoteRenderingAccountsClient) RegenerateKeys(ctx context.Context, resourceGroupName string, accountName string, regenerate AccountKeyRegenerateRequest, options *RemoteRenderingAccountsClientRegenerateKeysOptions) (RemoteRenderingAccountsClientRegenerateKeysResponse, error)

RegenerateKeys - Regenerate specified Key of a Remote Rendering Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • regenerate - Required information for key regeneration.
  • options - RemoteRenderingAccountsClientRegenerateKeysOptions contains the optional parameters for the RemoteRenderingAccountsClient.RegenerateKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/RegenerateKey.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewRemoteRenderingAccountsClient().RegenerateKeys(ctx, "MyResourceGroup", "MyAccount", armmixedreality.AccountKeyRegenerateRequest{
		Serial: to.Ptr(armmixedreality.SerialPrimary),
	}, 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.AccountKeys = armmixedreality.AccountKeys{
	// 	PrimaryKey: to.Ptr("************"),
	// 	SecondaryKey: to.Ptr("************"),
	// }
}

Output:

func (*RemoteRenderingAccountsClient) Update 

func (client *RemoteRenderingAccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, remoteRenderingAccount RemoteRenderingAccount, options *RemoteRenderingAccountsClientUpdateOptions) (RemoteRenderingAccountsClientUpdateResponse, error)

Update - Updating a Remote Rendering Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • remoteRenderingAccount - Remote Rendering Account parameter.
  • options - RemoteRenderingAccountsClientUpdateOptions contains the optional parameters for the RemoteRenderingAccountsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/remote-rendering/Patch.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewRemoteRenderingAccountsClient().Update(ctx, "MyResourceGroup", "MyAccount", armmixedreality.RemoteRenderingAccount{
		Location: to.Ptr("eastus2euap"),
		Tags: map[string]*string{
			"hero":    to.Ptr("romeo"),
			"heroine": to.Ptr("juliet"),
		},
		Identity: &armmixedreality.Identity{
			Type: to.Ptr("SystemAssigned"),
		},
	}, 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.RemoteRenderingAccount = armmixedreality.RemoteRenderingAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/remoteRenderingAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/remoteRenderingAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 		"hero": to.Ptr("romeo"),
	// 		"heroine": to.Ptr("juliet"),
	// 	},
	// 	Identity: &armmixedreality.Identity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

type RemoteRenderingAccountsClientCreateOptions 

type RemoteRenderingAccountsClientCreateOptions struct {
}

RemoteRenderingAccountsClientCreateOptions contains the optional parameters for the RemoteRenderingAccountsClient.Create method.

type RemoteRenderingAccountsClientCreateResponse 

type RemoteRenderingAccountsClientCreateResponse struct {
	// RemoteRenderingAccount Response.
	RemoteRenderingAccount
}

RemoteRenderingAccountsClientCreateResponse contains the response from method RemoteRenderingAccountsClient.Create.

type RemoteRenderingAccountsClientDeleteOptions 

type RemoteRenderingAccountsClientDeleteOptions struct {
}

RemoteRenderingAccountsClientDeleteOptions contains the optional parameters for the RemoteRenderingAccountsClient.Delete method.

type RemoteRenderingAccountsClientDeleteResponse 

type RemoteRenderingAccountsClientDeleteResponse struct {
}

RemoteRenderingAccountsClientDeleteResponse contains the response from method RemoteRenderingAccountsClient.Delete.

type RemoteRenderingAccountsClientGetOptions 

type RemoteRenderingAccountsClientGetOptions struct {
}

RemoteRenderingAccountsClientGetOptions contains the optional parameters for the RemoteRenderingAccountsClient.Get method.

type RemoteRenderingAccountsClientGetResponse 

type RemoteRenderingAccountsClientGetResponse struct {
	// RemoteRenderingAccount Response.
	RemoteRenderingAccount
}

RemoteRenderingAccountsClientGetResponse contains the response from method RemoteRenderingAccountsClient.Get.

type RemoteRenderingAccountsClientListByResourceGroupOptions 

type RemoteRenderingAccountsClientListByResourceGroupOptions struct {
}

RemoteRenderingAccountsClientListByResourceGroupOptions contains the optional parameters for the RemoteRenderingAccountsClient.NewListByResourceGroupPager method.

type RemoteRenderingAccountsClientListByResourceGroupResponse 

type RemoteRenderingAccountsClientListByResourceGroupResponse struct {
	// Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of
	// results.
	RemoteRenderingAccountPage
}

RemoteRenderingAccountsClientListByResourceGroupResponse contains the response from method RemoteRenderingAccountsClient.NewListByResourceGroupPager.

type RemoteRenderingAccountsClientListBySubscriptionOptions 

type RemoteRenderingAccountsClientListBySubscriptionOptions struct {
}

RemoteRenderingAccountsClientListBySubscriptionOptions contains the optional parameters for the RemoteRenderingAccountsClient.NewListBySubscriptionPager method.

type RemoteRenderingAccountsClientListBySubscriptionResponse 

type RemoteRenderingAccountsClientListBySubscriptionResponse struct {
	// Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of
	// results.
	RemoteRenderingAccountPage
}

RemoteRenderingAccountsClientListBySubscriptionResponse contains the response from method RemoteRenderingAccountsClient.NewListBySubscriptionPager.

type RemoteRenderingAccountsClientListKeysOptions 

type RemoteRenderingAccountsClientListKeysOptions struct {
}

RemoteRenderingAccountsClientListKeysOptions contains the optional parameters for the RemoteRenderingAccountsClient.ListKeys method.

type RemoteRenderingAccountsClientListKeysResponse 

type RemoteRenderingAccountsClientListKeysResponse struct {
	// Developer Keys of account
	AccountKeys
}

RemoteRenderingAccountsClientListKeysResponse contains the response from method RemoteRenderingAccountsClient.ListKeys.

type RemoteRenderingAccountsClientRegenerateKeysOptions 

type RemoteRenderingAccountsClientRegenerateKeysOptions struct {
}

RemoteRenderingAccountsClientRegenerateKeysOptions contains the optional parameters for the RemoteRenderingAccountsClient.RegenerateKeys method.

type RemoteRenderingAccountsClientRegenerateKeysResponse 

type RemoteRenderingAccountsClientRegenerateKeysResponse struct {
	// Developer Keys of account
	AccountKeys
}

RemoteRenderingAccountsClientRegenerateKeysResponse contains the response from method RemoteRenderingAccountsClient.RegenerateKeys.

type RemoteRenderingAccountsClientUpdateOptions 

type RemoteRenderingAccountsClientUpdateOptions struct {
}

RemoteRenderingAccountsClientUpdateOptions contains the optional parameters for the RemoteRenderingAccountsClient.Update method.

type RemoteRenderingAccountsClientUpdateResponse 

type RemoteRenderingAccountsClientUpdateResponse struct {
	// RemoteRenderingAccount Response.
	RemoteRenderingAccount
}

RemoteRenderingAccountsClientUpdateResponse contains the response from method RemoteRenderingAccountsClient.Update.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

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

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

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

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 SKU 

type SKU struct {
	// REQUIRED; The name of the SKU. Ex - P3. It is typically a letter+number code
	Name *string

	// If the SKU supports scale out/in then the capacity integer should be included. If scale out/in is not possible for the
	// resource this may be omitted.
	Capacity *int32

	// If the service has different generations of hardware, for the same SKU, then that can be captured here.
	Family *string

	// The SKU size. When the name field is the combination of tier and some other value, this would be the standalone code.
	Size *string

	// This field is required to be implemented by the Resource Provider if the service has more than one tier, but is not required
	// on a PUT.
	Tier *SKUTier
}

SKU - The resource model definition representing SKU

func (SKU) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SKUTier 

type SKUTier string

SKUTier - This field is required to be implemented by the Resource Provider if the service has more than one tier, but is not required on a PUT. 

const (
	SKUTierBasic    SKUTier = "Basic"
	SKUTierFree     SKUTier = "Free"
	SKUTierPremium  SKUTier = "Premium"
	SKUTierStandard SKUTier = "Standard"
)

func PossibleSKUTierValues 

func PossibleSKUTierValues() []SKUTier

PossibleSKUTierValues returns the possible values for the SKUTier const type.

type Serial 

type Serial int32

Serial - Serial of key to be regenerated 

const (
	// SerialPrimary - The Primary Key
	SerialPrimary Serial = 1
	// SerialSecondary - The Secondary Key
	SerialSecondary Serial = 2
)

func PossibleSerialValues 

func PossibleSerialValues() []Serial

PossibleSerialValues returns the possible values for the Serial const type.

type ServiceSpecification 

type ServiceSpecification struct {
	// Specifications of the Log for Azure Monitoring
	LogSpecifications []*LogSpecification

	// Specifications of the Metrics for Azure Monitoring
	MetricSpecifications []*MetricSpecification
}

ServiceSpecification - Service specification payload

func (ServiceSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceSpecification.

func (*ServiceSpecification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceSpecification.

type SpatialAnchorsAccount 

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

	// The identity associated with this account
	Identity *Identity

	// The kind of account, if supported
	Kind *SKU

	// The plan associated with this account
	Plan *Identity

	// Property bag.
	Properties *AccountProperties

	// The sku associated with this account
	SKU *SKU

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

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

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

	// READ-ONLY; System metadata for this account
	SystemData *SystemData

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

SpatialAnchorsAccount Response.

func (SpatialAnchorsAccount) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SpatialAnchorsAccount.

func (*SpatialAnchorsAccount) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SpatialAnchorsAccount.

type SpatialAnchorsAccountPage 

type SpatialAnchorsAccountPage struct {
	// URL to get the next set of resource list results if there are any.
	NextLink *string

	// List of resources supported by the Resource Provider.
	Value []*SpatialAnchorsAccount
}

SpatialAnchorsAccountPage - Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of results.

func (SpatialAnchorsAccountPage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SpatialAnchorsAccountPage.

func (*SpatialAnchorsAccountPage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SpatialAnchorsAccountPage.

type SpatialAnchorsAccountsClient 

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

SpatialAnchorsAccountsClient contains the methods for the SpatialAnchorsAccounts group. Don't use this type directly, use NewSpatialAnchorsAccountsClient() instead.

func NewSpatialAnchorsAccountsClient 

func NewSpatialAnchorsAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SpatialAnchorsAccountsClient, error)

NewSpatialAnchorsAccountsClient creates a new instance of SpatialAnchorsAccountsClient with the specified values.

  • subscriptionID - The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SpatialAnchorsAccountsClient) Create 

func (client *SpatialAnchorsAccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, spatialAnchorsAccount SpatialAnchorsAccount, options *SpatialAnchorsAccountsClientCreateOptions) (SpatialAnchorsAccountsClientCreateResponse, error)

Create - Creating or Updating a Spatial Anchors Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • spatialAnchorsAccount - Spatial Anchors Account parameter.
  • options - SpatialAnchorsAccountsClientCreateOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/Put.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSpatialAnchorsAccountsClient().Create(ctx, "MyResourceGroup", "MyAccount", armmixedreality.SpatialAnchorsAccount{
		Location: to.Ptr("eastus2euap"),
	}, 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.SpatialAnchorsAccount = armmixedreality.SpatialAnchorsAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

func (*SpatialAnchorsAccountsClient) Delete 

func (client *SpatialAnchorsAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, options *SpatialAnchorsAccountsClientDeleteOptions) (SpatialAnchorsAccountsClientDeleteResponse, error)

Delete - Delete a Spatial Anchors Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - SpatialAnchorsAccountsClientDeleteOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewSpatialAnchorsAccountsClient().Delete(ctx, "MyResourceGroup", "MyAccount", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*SpatialAnchorsAccountsClient) Get 

func (client *SpatialAnchorsAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *SpatialAnchorsAccountsClientGetOptions) (SpatialAnchorsAccountsClientGetResponse, error)

Get - Retrieve a Spatial Anchors Account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - SpatialAnchorsAccountsClientGetOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSpatialAnchorsAccountsClient().Get(ctx, "MyResourceGroup", "MyAccount", 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.SpatialAnchorsAccount = armmixedreality.SpatialAnchorsAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

func (*SpatialAnchorsAccountsClient) ListKeys 

func (client *SpatialAnchorsAccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string, options *SpatialAnchorsAccountsClientListKeysOptions) (SpatialAnchorsAccountsClientListKeysResponse, error)

ListKeys - List Both of the 2 Keys of a Spatial Anchors Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • options - SpatialAnchorsAccountsClientListKeysOptions contains the optional parameters for the SpatialAnchorsAccountsClient.ListKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/ListKeys.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSpatialAnchorsAccountsClient().ListKeys(ctx, "MyResourceGroup", "MyAccount", 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.AccountKeys = armmixedreality.AccountKeys{
	// 	PrimaryKey: to.Ptr("************"),
	// 	SecondaryKey: to.Ptr("************"),
	// }
}

Output:

func (*SpatialAnchorsAccountsClient) NewListByResourceGroupPager 

func (client *SpatialAnchorsAccountsClient) NewListByResourceGroupPager(resourceGroupName string, options *SpatialAnchorsAccountsClientListByResourceGroupOptions) *runtime.Pager[SpatialAnchorsAccountsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List Resources by Resource Group

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • options - SpatialAnchorsAccountsClientListByResourceGroupOptions contains the optional parameters for the SpatialAnchorsAccountsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/GetByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSpatialAnchorsAccountsClient().NewListByResourceGroupPager("MyResourceGroup", 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.SpatialAnchorsAccountPage = armmixedreality.SpatialAnchorsAccountPage{
		// 	Value: []*armmixedreality.SpatialAnchorsAccount{
		// 		{
		// 			Name: to.Ptr("alpha"),
		// 			Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/alpha"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("omega"),
		// 			Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/omega"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*SpatialAnchorsAccountsClient) NewListBySubscriptionPager 

func (client *SpatialAnchorsAccountsClient) NewListBySubscriptionPager(options *SpatialAnchorsAccountsClientListBySubscriptionOptions) *runtime.Pager[SpatialAnchorsAccountsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List Spatial Anchors Accounts by Subscription

Generated from API version 2021-03-01-preview

  • options - SpatialAnchorsAccountsClientListBySubscriptionOptions contains the optional parameters for the SpatialAnchorsAccountsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/GetBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSpatialAnchorsAccountsClient().NewListBySubscriptionPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.SpatialAnchorsAccountPage = armmixedreality.SpatialAnchorsAccountPage{
		// 	Value: []*armmixedreality.SpatialAnchorsAccount{
		// 		{
		// 			Name: to.Ptr("alpha"),
		// 			Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/alpha"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("omega"),
		// 			Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
		// 			ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/omega"),
		// 			Location: to.Ptr("eastus2euap"),
		// 			Tags: map[string]*string{
		// 			},
		// 			Properties: &armmixedreality.AccountProperties{
		// 				AccountDomain: to.Ptr("mixedreality.azure.com"),
		// 				AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*SpatialAnchorsAccountsClient) RegenerateKeys 

func (client *SpatialAnchorsAccountsClient) RegenerateKeys(ctx context.Context, resourceGroupName string, accountName string, regenerate AccountKeyRegenerateRequest, options *SpatialAnchorsAccountsClientRegenerateKeysOptions) (SpatialAnchorsAccountsClientRegenerateKeysResponse, error)

RegenerateKeys - Regenerate specified Key of a Spatial Anchors Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • regenerate - Required information for key regeneration.
  • options - SpatialAnchorsAccountsClientRegenerateKeysOptions contains the optional parameters for the SpatialAnchorsAccountsClient.RegenerateKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/RegenerateKey.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSpatialAnchorsAccountsClient().RegenerateKeys(ctx, "MyResourceGroup", "MyAccount", armmixedreality.AccountKeyRegenerateRequest{
		Serial: to.Ptr(armmixedreality.SerialPrimary),
	}, 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.AccountKeys = armmixedreality.AccountKeys{
	// 	PrimaryKey: to.Ptr("************"),
	// 	SecondaryKey: to.Ptr("************"),
	// }
}

Output:

func (*SpatialAnchorsAccountsClient) Update 

func (client *SpatialAnchorsAccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, spatialAnchorsAccount SpatialAnchorsAccount, options *SpatialAnchorsAccountsClientUpdateOptions) (SpatialAnchorsAccountsClientUpdateResponse, error)

Update - Updating a Spatial Anchors Account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-03-01-preview

  • resourceGroupName - Name of an Azure resource group.
  • accountName - Name of an Mixed Reality Account.
  • spatialAnchorsAccount - Spatial Anchors Account parameter.
  • options - SpatialAnchorsAccountsClientUpdateOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/mixedreality/resource-manager/Microsoft.MixedReality/preview/2021-03-01-preview/examples/spatial-anchors/Patch.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/mixedreality/armmixedreality"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmixedreality.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSpatialAnchorsAccountsClient().Update(ctx, "MyResourceGroup", "MyAccount", armmixedreality.SpatialAnchorsAccount{
		Location: to.Ptr("eastus2euap"),
		Tags: map[string]*string{
			"hero":    to.Ptr("romeo"),
			"heroine": to.Ptr("juliet"),
		},
	}, 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.SpatialAnchorsAccount = armmixedreality.SpatialAnchorsAccount{
	// 	Name: to.Ptr("MyAccount"),
	// 	Type: to.Ptr("Microsoft.MixedReality/spatialAnchorsAccounts"),
	// 	ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.MixedReality/spatialAnchorsAccounts/MyAccount"),
	// 	Location: to.Ptr("eastus2euap"),
	// 	Tags: map[string]*string{
	// 		"hero": to.Ptr("romeo"),
	// 		"heroine": to.Ptr("juliet"),
	// 	},
	// 	Properties: &armmixedreality.AccountProperties{
	// 		AccountDomain: to.Ptr("mixedreality.azure.com"),
	// 		AccountID: to.Ptr("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
	// 	},
	// }
}

Output:

type SpatialAnchorsAccountsClientCreateOptions 

type SpatialAnchorsAccountsClientCreateOptions struct {
}

SpatialAnchorsAccountsClientCreateOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Create method.

type SpatialAnchorsAccountsClientCreateResponse 

type SpatialAnchorsAccountsClientCreateResponse struct {
	// SpatialAnchorsAccount Response.
	SpatialAnchorsAccount
}

SpatialAnchorsAccountsClientCreateResponse contains the response from method SpatialAnchorsAccountsClient.Create.

type SpatialAnchorsAccountsClientDeleteOptions 

type SpatialAnchorsAccountsClientDeleteOptions struct {
}

SpatialAnchorsAccountsClientDeleteOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Delete method.

type SpatialAnchorsAccountsClientDeleteResponse 

type SpatialAnchorsAccountsClientDeleteResponse struct {
}

SpatialAnchorsAccountsClientDeleteResponse contains the response from method SpatialAnchorsAccountsClient.Delete.

type SpatialAnchorsAccountsClientGetOptions 

type SpatialAnchorsAccountsClientGetOptions struct {
}

SpatialAnchorsAccountsClientGetOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Get method.

type SpatialAnchorsAccountsClientGetResponse 

type SpatialAnchorsAccountsClientGetResponse struct {
	// SpatialAnchorsAccount Response.
	SpatialAnchorsAccount
}

SpatialAnchorsAccountsClientGetResponse contains the response from method SpatialAnchorsAccountsClient.Get.

type SpatialAnchorsAccountsClientListByResourceGroupOptions 

type SpatialAnchorsAccountsClientListByResourceGroupOptions struct {
}

SpatialAnchorsAccountsClientListByResourceGroupOptions contains the optional parameters for the SpatialAnchorsAccountsClient.NewListByResourceGroupPager method.

type SpatialAnchorsAccountsClientListByResourceGroupResponse 

type SpatialAnchorsAccountsClientListByResourceGroupResponse struct {
	// Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of
	// results.
	SpatialAnchorsAccountPage
}

SpatialAnchorsAccountsClientListByResourceGroupResponse contains the response from method SpatialAnchorsAccountsClient.NewListByResourceGroupPager.

type SpatialAnchorsAccountsClientListBySubscriptionOptions 

type SpatialAnchorsAccountsClientListBySubscriptionOptions struct {
}

SpatialAnchorsAccountsClientListBySubscriptionOptions contains the optional parameters for the SpatialAnchorsAccountsClient.NewListBySubscriptionPager method.

type SpatialAnchorsAccountsClientListBySubscriptionResponse 

type SpatialAnchorsAccountsClientListBySubscriptionResponse struct {
	// Result of the request to get resource collection. It contains a list of resources and a URL link to get the next set of
	// results.
	SpatialAnchorsAccountPage
}

SpatialAnchorsAccountsClientListBySubscriptionResponse contains the response from method SpatialAnchorsAccountsClient.NewListBySubscriptionPager.

type SpatialAnchorsAccountsClientListKeysOptions 

type SpatialAnchorsAccountsClientListKeysOptions struct {
}

SpatialAnchorsAccountsClientListKeysOptions contains the optional parameters for the SpatialAnchorsAccountsClient.ListKeys method.

type SpatialAnchorsAccountsClientListKeysResponse 

type SpatialAnchorsAccountsClientListKeysResponse struct {
	// Developer Keys of account
	AccountKeys
}

SpatialAnchorsAccountsClientListKeysResponse contains the response from method SpatialAnchorsAccountsClient.ListKeys.

type SpatialAnchorsAccountsClientRegenerateKeysOptions 

type SpatialAnchorsAccountsClientRegenerateKeysOptions struct {
}

SpatialAnchorsAccountsClientRegenerateKeysOptions contains the optional parameters for the SpatialAnchorsAccountsClient.RegenerateKeys method.

type SpatialAnchorsAccountsClientRegenerateKeysResponse 

type SpatialAnchorsAccountsClientRegenerateKeysResponse struct {
	// Developer Keys of account
	AccountKeys
}

SpatialAnchorsAccountsClientRegenerateKeysResponse contains the response from method SpatialAnchorsAccountsClient.RegenerateKeys.

type SpatialAnchorsAccountsClientUpdateOptions 

type SpatialAnchorsAccountsClientUpdateOptions struct {
}

SpatialAnchorsAccountsClientUpdateOptions contains the optional parameters for the SpatialAnchorsAccountsClient.Update method.

type SpatialAnchorsAccountsClientUpdateResponse 

type SpatialAnchorsAccountsClientUpdateResponse struct {
	// SpatialAnchorsAccount Response.
	SpatialAnchorsAccount
}

SpatialAnchorsAccountsClientUpdateResponse contains the response from method SpatialAnchorsAccountsClient.Update.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TrackedResource 

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

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

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

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

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

TrackedResource - The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'

func (TrackedResource) MarshalJSON 

func (t TrackedResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON 

func (t *TrackedResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

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.