armquantum

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 Quantum Module for Go

The armquantum module provides operations for working with Azure Quantum.

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

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum

Authorization

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

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 Quantum 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 APIKey 

type APIKey struct {
	// The creation time of the api key.
	CreatedAt *time.Time

	// READ-ONLY; The Api key.
	Key *string
}

APIKey - Azure quantum workspace Api key details.

func (APIKey) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type APIKey.

func (*APIKey) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKey.

type APIKeys 

type APIKeys struct {
	// A list of api key names.
	Keys []*KeyType
}

APIKeys - List of api keys to be generated.

func (APIKeys) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type APIKeys.

func (*APIKeys) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKeys.

type CheckNameAvailabilityParameters 

type CheckNameAvailabilityParameters struct {
	// Name for checking availability.
	Name *string

	// The resource type of Quantum Workspace.
	Type *string
}

CheckNameAvailabilityParameters - Details of check name availability request body.

func (CheckNameAvailabilityParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityParameters.

func (*CheckNameAvailabilityParameters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityParameters.

type CheckNameAvailabilityResult 

type CheckNameAvailabilityResult struct {
	// Indicator of availability of the Quantum Workspace resource name.
	NameAvailable *bool

	// The reason of unavailability.
	Reason *string

	// READ-ONLY; The detailed info regarding the reason associated with the Namespace.
	Message *string
}

CheckNameAvailabilityResult - Result of check name availability.

func (CheckNameAvailabilityResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResult.

func (*CheckNameAvailabilityResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityResult.

type ClientFactory 

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

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

func NewClientFactory 

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

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

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

func (*ClientFactory) NewOfferingsClient 

func (c *ClientFactory) NewOfferingsClient() *OfferingsClient

NewOfferingsClient creates a new instance of OfferingsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewWorkspaceClient 

func (c *ClientFactory) NewWorkspaceClient() *WorkspaceClient

NewWorkspaceClient creates a new instance of WorkspaceClient.

func (*ClientFactory) NewWorkspacesClient 

func (c *ClientFactory) NewWorkspacesClient() *WorkspacesClient

NewWorkspacesClient creates a new instance of WorkspacesClient.

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 KeyType 

type KeyType string
const (
	KeyTypePrimary   KeyType = "Primary"
	KeyTypeSecondary KeyType = "Secondary"
)

func PossibleKeyTypeValues 

func PossibleKeyTypeValues() []KeyType

PossibleKeyTypeValues returns the possible values for the KeyType const type.

type ListKeysResult 

type ListKeysResult struct {
	// Indicator of enablement of the Quantum workspace Api keys.
	APIKeyEnabled *bool

	// The quantum workspace primary api key.
	PrimaryKey *APIKey

	// The quantum workspace secondary api key.
	SecondaryKey *APIKey

	// READ-ONLY; The connection string of the primary api key.
	PrimaryConnectionString *string

	// READ-ONLY; The connection string of the secondary api key.
	SecondaryConnectionString *string
}

ListKeysResult - Result of list Api keys and connection strings.

func (ListKeysResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ListKeysResult.

func (*ListKeysResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListKeysResult.

type OfferingsClient 

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

OfferingsClient contains the methods for the Offerings group. Don't use this type directly, use NewOfferingsClient() instead.

func NewOfferingsClient 

func NewOfferingsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OfferingsClient, error)

NewOfferingsClient creates a new instance of OfferingsClient with the specified values.

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

func (*OfferingsClient) NewListPager 

func (client *OfferingsClient) NewListPager(locationName string, options *OfferingsClientListOptions) *runtime.Pager[OfferingsClientListResponse]

NewListPager - Returns the list of all provider offerings available for the given location.

Generated from API version 2023-11-13-preview

  • locationName - Location.
  • options - OfferingsClientListOptions contains the optional parameters for the OfferingsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/offeringsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOfferingsClient().NewListPager("westus2", 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.OfferingsListResult = armquantum.OfferingsListResult{
		// 	Value: []*armquantum.ProviderDescription{
		// 		{
		// 			Name: to.Ptr("Quantum Inspired Optimization"),
		// 			ID: to.Ptr("QIO"),
		// 			Properties: &armquantum.ProviderProperties{
		// 				Description: to.Ptr("Provide Quantum Inspired Optimization solvers"),
		// 				PricingDimensions: []*armquantum.PricingDimension{
		// 					{
		// 						Name: to.Ptr("Pricing"),
		// 						ID: to.Ptr("price"),
		// 					},
		// 					{
		// 						Name: to.Ptr("Minimum monthly rate"),
		// 						ID: to.Ptr("rate"),
		// 				}},
		// 				QuotaDimensions: []*armquantum.QuotaDimension{
		// 					{
		// 						Name: to.Ptr("Job count"),
		// 						Description: to.Ptr("The number of jobs you may submit per month"),
		// 						ID: to.Ptr("job-count"),
		// 						Period: to.Ptr("Monthly"),
		// 						Quota: to.Ptr[float32](30),
		// 						Scope: to.Ptr("Workspace"),
		// 						Unit: to.Ptr("job"),
		// 						UnitPlural: to.Ptr("jobs"),
		// 					},
		// 					{
		// 						Name: to.Ptr("Job hours"),
		// 						Description: to.Ptr("The number of hours of solver time you may use per month"),
		// 						ID: to.Ptr("job-hour"),
		// 						Period: to.Ptr("Monthly"),
		// 						Quota: to.Ptr[float32](1000),
		// 						Scope: to.Ptr("Subscription"),
		// 						Unit: to.Ptr("hour"),
		// 						UnitPlural: to.Ptr("hours"),
		// 				}},
		// 				SKUs: []*armquantum.SKUDescription{
		// 					{
		// 						Name: to.Ptr("Standard"),
		// 						Description: to.Ptr("Provider CPU and FPGA QIO based solver."),
		// 						AutoAdd: to.Ptr(true),
		// 						ID: to.Ptr("Standard"),
		// 						PricingDetails: []*armquantum.PricingDetail{
		// 							{
		// 								ID: to.Ptr("price"),
		// 								Value: to.Ptr("200 dollars"),
		// 							},
		// 							{
		// 								ID: to.Ptr("rate"),
		// 								Value: to.Ptr("10 hours/month"),
		// 						}},
		// 						QuotaDimensions: []*armquantum.QuotaDimension{
		// 							{
		// 								ID: to.Ptr("quota1"),
		// 								Scope: to.Ptr("Workspace"),
		// 						}},
		// 						RestrictedAccessURI: to.Ptr("https://endpoint"),
		// 						Targets: []*string{
		// 							to.Ptr("p1")},
		// 							Version: to.Ptr("1.0"),
		// 					}},
		// 					Targets: []*armquantum.TargetDescription{
		// 						{
		// 							Name: to.Ptr("CPU annealer"),
		// 							Description: to.Ptr("CPU annealer algorithm"),
		// 							ID: to.Ptr("p1"),
		// 					}},
		// 				},
		// 		}},
		// 	}
	}
}

Output:

type OfferingsClientListOptions 

type OfferingsClientListOptions struct {
}

OfferingsClientListOptions contains the optional parameters for the OfferingsClient.NewListPager method.

type OfferingsClientListResponse 

type OfferingsClientListResponse struct {
	// The response of a list Providers operation.
	OfferingsListResult
}

OfferingsClientListResponse contains the response from method OfferingsClient.NewListPager.

type OfferingsListResult 

type OfferingsListResult struct {
	// Link to the next set of results. Not empty if Value contains incomplete list of Providers.
	NextLink *string

	// Result of a list Providers operation.
	Value []*ProviderDescription
}

OfferingsListResult - The response of a list Providers operation.

func (OfferingsListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OfferingsListResult.

func (*OfferingsListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OfferingsListResult.

type Operation 

type Operation struct {
	// Properties of the operation
	Display *OperationDisplay

	// Indicates whether the operation is a data action
	IsDataAction *bool

	// Name of the operation
	Name *string
}

Operation provided by provider

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 {
	// Description of the operation
	Description *string

	// Operation name
	Operation *string

	// Provider name
	Provider *string

	// Resource name
	Resource *string
}

OperationDisplay - Properties of 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 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 - Returns list of operations.

Generated from API version 2023-11-13-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/operations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.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.OperationsList = armquantum.OperationsList{
		// 	Value: []*armquantum.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.Quantum/Locations/Offerings/Read"),
		// 			Display: &armquantum.OperationDisplay{
		// 				Description: to.Ptr("Read providers supported"),
		// 				Operation: to.Ptr("Read quantum workspace's available providers"),
		// 				Provider: to.Ptr("Microsoft.Quantum"),
		// 				Resource: to.Ptr("Workspaces"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Lists the operations available.
	OperationsList
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OperationsList 

type OperationsList struct {
	// REQUIRED; Array of operations
	Value []*Operation

	// Url to follow for getting next page of operations.
	NextLink *string
}

OperationsList - Lists the operations available.

func (OperationsList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationsList.

func (*OperationsList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationsList.

type PricingDetail 

type PricingDetail struct {
	// Unique id for this pricing information.
	ID *string

	// The unit cost of this sku.
	Value *string
}

PricingDetail - Detailed pricing information for an sku.

func (PricingDetail) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PricingDetail.

func (*PricingDetail) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PricingDetail.

type PricingDimension 

type PricingDimension struct {
	// Unique id of this pricing dimension.
	ID *string

	// The display name of this pricing dimension.
	Name *string
}

PricingDimension - Information about pricing dimension.

func (PricingDimension) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PricingDimension.

func (*PricingDimension) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PricingDimension.

type Provider 

type Provider struct {
	// The provider's marketplace application display name.
	ApplicationName *string

	// A Uri identifying the specific instance of this provider.
	InstanceURI *string

	// Unique id of this provider.
	ProviderID *string

	// The sku associated with pricing information for this provider.
	ProviderSKU *string

	// Provisioning status field
	ProvisioningState *Status

	// Id to track resource usage for the provider.
	ResourceUsageID *string
}

Provider - Information about a Provider. A Provider is an entity that offers Targets to run Azure Quantum Jobs.

func (Provider) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Provider.

func (*Provider) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Provider.

type ProviderDescription 

type ProviderDescription struct {
	// Unique provider's id.
	ID *string

	// Provider properties.
	Properties *ProviderProperties

	// READ-ONLY; Provider's display name.
	Name *string
}

ProviderDescription - Information about an offering. A provider offering is an entity that offers Targets to run Azure Quantum Jobs.

func (ProviderDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProviderDescription.

func (*ProviderDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProviderDescription.

type ProviderProperties 

type ProviderProperties struct {
	// Azure Active Directory info.
	AAD *ProviderPropertiesAAD

	// Provider's Managed-Application info
	ManagedApplication *ProviderPropertiesManagedApplication

	// The list of pricing dimensions from the provider.
	PricingDimensions []*PricingDimension

	// The list of quota dimensions from the provider.
	QuotaDimensions []*QuotaDimension

	// The list of skus available from this provider.
	SKUs []*SKUDescription

	// The list of targets available from this provider.
	Targets []*TargetDescription

	// READ-ONLY; Company name.
	Company *string

	// READ-ONLY; Provider's default endpoint.
	DefaultEndpoint *string

	// READ-ONLY; A description about this provider.
	Description *string

	// READ-ONLY; Provider type.
	ProviderType *string
}

ProviderProperties - Provider properties.

func (ProviderProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProviderProperties.

func (*ProviderProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProviderProperties.

type ProviderPropertiesAAD 

type ProviderPropertiesAAD struct {
	// READ-ONLY; Provider's application id.
	ApplicationID *string

	// READ-ONLY; Provider's tenant id.
	TenantID *string
}

ProviderPropertiesAAD - Azure Active Directory info.

func (ProviderPropertiesAAD) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProviderPropertiesAAD.

func (*ProviderPropertiesAAD) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProviderPropertiesAAD.

type ProviderPropertiesManagedApplication 

type ProviderPropertiesManagedApplication struct {
	// READ-ONLY; Provider's offer id.
	OfferID *string

	// READ-ONLY; Provider's publisher id.
	PublisherID *string
}

ProviderPropertiesManagedApplication - Provider's Managed-Application info

func (ProviderPropertiesManagedApplication) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProviderPropertiesManagedApplication.

func (*ProviderPropertiesManagedApplication) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProviderPropertiesManagedApplication.

type ProvisioningStatus 

type ProvisioningStatus string

ProvisioningStatus - Provisioning status field 

const (
	ProvisioningStatusFailed               ProvisioningStatus = "Failed"
	ProvisioningStatusProviderDeleting     ProvisioningStatus = "ProviderDeleting"
	ProvisioningStatusProviderLaunching    ProvisioningStatus = "ProviderLaunching"
	ProvisioningStatusProviderProvisioning ProvisioningStatus = "ProviderProvisioning"
	ProvisioningStatusProviderUpdating     ProvisioningStatus = "ProviderUpdating"
	ProvisioningStatusSucceeded            ProvisioningStatus = "Succeeded"
)

func PossibleProvisioningStatusValues 

func PossibleProvisioningStatusValues() []ProvisioningStatus

PossibleProvisioningStatusValues returns the possible values for the ProvisioningStatus const type.

type QuotaDimension 

type QuotaDimension struct {
	// A description about this quota dimension.
	Description *string

	// Unique id of this dimension.
	ID *string

	// The display name of this quota dimension.
	Name *string

	// The reset period of this quota dimension.
	Period *string

	// The max limit of this dimension.
	Quota *float32

	// The scope of this quota dimension.
	Scope *string

	// The standard unit of measurement used for this quota dimension.
	Unit *string

	// The standard unit of measurement used for this quota dimension in plural form.
	UnitPlural *string
}

QuotaDimension - Information about a specific quota dimension.

func (QuotaDimension) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type QuotaDimension.

func (*QuotaDimension) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type QuotaDimension.

type ResourceIdentityType 

type ResourceIdentityType string

ResourceIdentityType - The identity type. 

const (
	ResourceIdentityTypeNone           ResourceIdentityType = "None"
	ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
)

func PossibleResourceIdentityTypeValues 

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type SKUDescription 

type SKUDescription struct {
	// Flag to indicate whether the sku should be automatically added during workspace creation.
	AutoAdd *bool

	// Description about this sku.
	Description *string

	// Unique sku id.
	ID *string

	// Display name of this sku.
	Name *string

	// The list of pricing details for the sku.
	PricingDetails []*PricingDetail

	// The list of quota dimensions for this sku.
	QuotaDimensions []*QuotaDimension

	// Uri to subscribe to the restricted access sku.
	RestrictedAccessURI *string

	// The list of targets available for this sku.
	Targets []*string

	// Display name of this sku.
	Version *string
}

SKUDescription - Information about a specific sku.

func (SKUDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SKUDescription.

func (*SKUDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKUDescription.

type Status 

type Status string

Status - Provisioning status field 

const (
	StatusDeleted   Status = "Deleted"
	StatusDeleting  Status = "Deleting"
	StatusFailed    Status = "Failed"
	StatusLaunching Status = "Launching"
	StatusSucceeded Status = "Succeeded"
	StatusUpdating  Status = "Updating"
)

func PossibleStatusValues 

func PossibleStatusValues() []Status

PossibleStatusValues returns the possible values for the Status const type.

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 TagsObject 

type TagsObject struct {
	// Resource tags.
	Tags map[string]*string
}

TagsObject - Tags object for patch operations.

func (TagsObject) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TagsObject.

func (*TagsObject) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TagsObject.

type TargetDescription 

type TargetDescription struct {
	// List of content encodings accepted by this target.
	AcceptedContentEncodings []*string

	// List of data formats accepted by this target.
	AcceptedDataFormats []*string

	// A description about this target.
	Description *string

	// Unique target id.
	ID *string

	// Display name of this target.
	Name *string
}

TargetDescription - Information about a Target. A target is the component that can process a specific type of Job.

func (TargetDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TargetDescription.

func (*TargetDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TargetDescription.

type UsableStatus 

type UsableStatus string

UsableStatus - Whether the current workspace is ready to accept Jobs. 

const (
	UsableStatusNo      UsableStatus = "No"
	UsableStatusPartial UsableStatus = "Partial"
	UsableStatusYes     UsableStatus = "Yes"
)

func PossibleUsableStatusValues 

func PossibleUsableStatusValues() []UsableStatus

PossibleUsableStatusValues returns the possible values for the UsableStatus const type.

type Workspace 

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

	// Managed Identity information.
	Identity *WorkspaceIdentity

	// Gets or sets the properties. Define quantum workspace's specific properties.
	Properties *WorkspaceResourceProperties

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

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

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

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

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

Workspace - The resource proxy definition object for quantum workspace.

func (Workspace) MarshalJSON 

func (w Workspace) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Workspace.

func (*Workspace) UnmarshalJSON 

func (w *Workspace) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Workspace.

type WorkspaceClient 

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

WorkspaceClient contains the methods for the Workspace group. Don't use this type directly, use NewWorkspaceClient() instead.

func NewWorkspaceClient 

func NewWorkspaceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*WorkspaceClient, error)

NewWorkspaceClient creates a new instance of WorkspaceClient with the specified values.

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

func (*WorkspaceClient) CheckNameAvailability 

func (client *WorkspaceClient) CheckNameAvailability(ctx context.Context, locationName string, checkNameAvailabilityParameters CheckNameAvailabilityParameters, options *WorkspaceClientCheckNameAvailabilityOptions) (WorkspaceClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check the availability of the resource name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • locationName - Location.
  • checkNameAvailabilityParameters - The name and type of the resource.
  • options - WorkspaceClientCheckNameAvailabilityOptions contains the optional parameters for the WorkspaceClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesCheckNameAvailability.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/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkspaceClient().CheckNameAvailability(ctx, "westus2", armquantum.CheckNameAvailabilityParameters{
		Name: to.Ptr("sample-workspace-name"),
		Type: to.Ptr("Microsoft.Quantum/Workspaces"),
	}, 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.CheckNameAvailabilityResult = armquantum.CheckNameAvailabilityResult{
	// 	Message: to.Ptr("Resource name already exists"),
	// 	NameAvailable: to.Ptr(false),
	// 	Reason: to.Ptr("AlreadyExists"),
	// }
}

Output:

func (*WorkspaceClient) ListKeys 

func (client *WorkspaceClient) ListKeys(ctx context.Context, resourceGroupName string, workspaceName string, options *WorkspaceClientListKeysOptions) (WorkspaceClientListKeysResponse, error)

ListKeys - Get the keys to use with the Quantum APIs. A key is used to authenticate and authorize access to the Quantum REST APIs. Only one key is needed at a time; two are given to provide seamless key regeneration. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • workspaceName - The name of the quantum workspace resource.
  • options - WorkspaceClientListKeysOptions contains the optional parameters for the WorkspaceClient.ListKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/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/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkspaceClient().ListKeys(ctx, "quantumResourcegroup", "quantumworkspace1", 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.ListKeysResult = armquantum.ListKeysResult{
	// 	APIKeyEnabled: to.Ptr(true),
	// 	PrimaryConnectionString: to.Ptr("<primaryConnectionString>"),
	// 	PrimaryKey: &armquantum.APIKey{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-13T23:06:09.147Z"); return t}()),
	// 		Key: to.Ptr("<primaryKey>"),
	// 	},
	// 	SecondaryConnectionString: to.Ptr("<secondaryConnectionString>"),
	// 	SecondaryKey: &armquantum.APIKey{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-13T23:06:09.147Z"); return t}()),
	// 		Key: to.Ptr("<secondaryKey>"),
	// 	},
	// }
}

Output:

func (*WorkspaceClient) RegenerateKeys 

func (client *WorkspaceClient) RegenerateKeys(ctx context.Context, resourceGroupName string, workspaceName string, keySpecification APIKeys, options *WorkspaceClientRegenerateKeysOptions) (WorkspaceClientRegenerateKeysResponse, error)

RegenerateKeys - Regenerate either the primary or secondary key for use with the Quantum APIs. The old key will stop working immediately. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • workspaceName - The name of the quantum workspace resource.
  • keySpecification - Which key to regenerate: primary or secondary.
  • options - WorkspaceClientRegenerateKeysOptions contains the optional parameters for the WorkspaceClient.RegenerateKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/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/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewWorkspaceClient().RegenerateKeys(ctx, "quantumResourcegroup", "quantumworkspace1", armquantum.APIKeys{
		Keys: []*armquantum.KeyType{
			to.Ptr(armquantum.KeyTypePrimary),
			to.Ptr(armquantum.KeyTypeSecondary)},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

type WorkspaceClientCheckNameAvailabilityOptions 

type WorkspaceClientCheckNameAvailabilityOptions struct {
}

WorkspaceClientCheckNameAvailabilityOptions contains the optional parameters for the WorkspaceClient.CheckNameAvailability method.

type WorkspaceClientCheckNameAvailabilityResponse 

type WorkspaceClientCheckNameAvailabilityResponse struct {
	// Result of check name availability.
	CheckNameAvailabilityResult
}

WorkspaceClientCheckNameAvailabilityResponse contains the response from method WorkspaceClient.CheckNameAvailability.

type WorkspaceClientListKeysOptions 

type WorkspaceClientListKeysOptions struct {
}

WorkspaceClientListKeysOptions contains the optional parameters for the WorkspaceClient.ListKeys method.

type WorkspaceClientListKeysResponse 

type WorkspaceClientListKeysResponse struct {
	// Result of list Api keys and connection strings.
	ListKeysResult
}

WorkspaceClientListKeysResponse contains the response from method WorkspaceClient.ListKeys.

type WorkspaceClientRegenerateKeysOptions 

type WorkspaceClientRegenerateKeysOptions struct {
}

WorkspaceClientRegenerateKeysOptions contains the optional parameters for the WorkspaceClient.RegenerateKeys method.

type WorkspaceClientRegenerateKeysResponse 

type WorkspaceClientRegenerateKeysResponse struct {
}

WorkspaceClientRegenerateKeysResponse contains the response from method WorkspaceClient.RegenerateKeys.

type WorkspaceIdentity 

type WorkspaceIdentity struct {
	// The identity type.
	Type *ResourceIdentityType

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

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

WorkspaceIdentity - Managed Identity information.

func (WorkspaceIdentity) MarshalJSON 

func (w WorkspaceIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkspaceIdentity.

func (*WorkspaceIdentity) UnmarshalJSON 

func (w *WorkspaceIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceIdentity.

type WorkspaceListResult 

type WorkspaceListResult struct {
	// Link to the next set of results. Not empty if Value contains incomplete list of Workspaces.
	NextLink *string

	// Result of a list Workspaces operation.
	Value []*Workspace
}

WorkspaceListResult - The response of a list Workspaces operation.

func (WorkspaceListResult) MarshalJSON 

func (w WorkspaceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkspaceListResult.

func (*WorkspaceListResult) UnmarshalJSON 

func (w *WorkspaceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceListResult.

type WorkspaceResourceProperties 

type WorkspaceResourceProperties struct {
	// Indicator of enablement of the Quantum workspace Api keys.
	APIKeyEnabled *bool

	// List of Providers selected for this Workspace
	Providers []*Provider

	// ARM Resource Id of the storage account associated with this workspace.
	StorageAccount *string

	// READ-ONLY; The URI of the workspace endpoint.
	EndpointURI *string

	// READ-ONLY; Provisioning status field
	ProvisioningState *ProvisioningStatus

	// READ-ONLY; Whether the current workspace is ready to accept Jobs.
	Usable *UsableStatus
}

WorkspaceResourceProperties - Properties of a Workspace

func (WorkspaceResourceProperties) MarshalJSON 

func (w WorkspaceResourceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkspaceResourceProperties.

func (*WorkspaceResourceProperties) UnmarshalJSON 

func (w *WorkspaceResourceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceResourceProperties.

type WorkspacesClient 

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

WorkspacesClient contains the methods for the Workspaces group. Don't use this type directly, use NewWorkspacesClient() instead.

func NewWorkspacesClient 

func NewWorkspacesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*WorkspacesClient, error)

NewWorkspacesClient creates a new instance of WorkspacesClient with the specified values.

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

func (*WorkspacesClient) BeginCreateOrUpdate 

func (client *WorkspacesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, workspaceName string, quantumWorkspace Workspace, options *WorkspacesClientBeginCreateOrUpdateOptions) (*runtime.Poller[WorkspacesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a workspace resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • workspaceName - The name of the quantum workspace resource.
  • quantumWorkspace - Workspace details.
  • options - WorkspacesClientBeginCreateOrUpdateOptions contains the optional parameters for the WorkspacesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesPut.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/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWorkspacesClient().BeginCreateOrUpdate(ctx, "quantumResourcegroup", "quantumworkspace1", armquantum.Workspace{
		Location: to.Ptr("West US"),
		Properties: &armquantum.WorkspaceResourceProperties{
			Providers: []*armquantum.Provider{
				{
					ProviderID:  to.Ptr("Honeywell"),
					ProviderSKU: to.Ptr("Basic"),
				},
				{
					ProviderID:  to.Ptr("IonQ"),
					ProviderSKU: to.Ptr("Basic"),
				},
				{
					ProviderID:  to.Ptr("OneQBit"),
					ProviderSKU: to.Ptr("Basic"),
				}},
			StorageAccount: to.Ptr("/subscriptions/1C4B2828-7D49-494F-933D-061373BE28C2/resourceGroups/quantumResourcegroup/providers/Microsoft.Storage/storageAccounts/testStorageAccount"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Workspace = armquantum.Workspace{
	// 	Name: to.Ptr("quantumworkspace1"),
	// 	Type: to.Ptr("Microsoft.Quantum/Workspaces"),
	// 	ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/quantumResourcegroup/providers/Microsoft.Quantum/Workspaces/quantumworkspace1"),
	// 	SystemData: &armquantum.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
	// 		CreatedBy: to.Ptr("user1"),
	// 		CreatedByType: to.Ptr(armquantum.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user2"),
	// 		LastModifiedByType: to.Ptr(armquantum.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"company": to.Ptr("Contoso"),
	// 		"department": to.Ptr("MightyMight"),
	// 	},
	// 	Identity: &armquantum.WorkspaceIdentity{
	// 		Type: to.Ptr(armquantum.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 		TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 	},
	// 	Properties: &armquantum.WorkspaceResourceProperties{
	// 		APIKeyEnabled: to.Ptr(true),
	// 		EndpointURI: to.Ptr("https://quantumworkspace1.westus.quantum.azure.com"),
	// 		Providers: []*armquantum.Provider{
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-h1"),
	// 				InstanceURI: to.Ptr("https://h1.endpoint.com"),
	// 				ProviderID: to.Ptr("Honeywell"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 			},
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-i1"),
	// 				InstanceURI: to.Ptr("https://i1.endpoint.com"),
	// 				ProviderID: to.Ptr("IonQ"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444445"),
	// 			},
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-o1"),
	// 				InstanceURI: to.Ptr("https://o1.endpoint.com"),
	// 				ProviderID: to.Ptr("OneQBit"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444446"),
	// 		}},
	// 		ProvisioningState: to.Ptr(armquantum.ProvisioningStatusSucceeded),
	// 		StorageAccount: to.Ptr("/subscriptions/1C4B2828-7D49-494F-933D-061373BE28C2/resourceGroups/quantumResourcegroup/providers/Microsoft.Storage/storageAccounts/testStorageAccount"),
	// 		Usable: to.Ptr(armquantum.UsableStatusYes),
	// 	},
	// }
}

Output:

func (*WorkspacesClient) BeginDelete 

func (client *WorkspacesClient) BeginDelete(ctx context.Context, resourceGroupName string, workspaceName string, options *WorkspacesClientBeginDeleteOptions) (*runtime.Poller[WorkspacesClientDeleteResponse], error)

BeginDelete - Deletes a Workspace resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • workspaceName - The name of the quantum workspace resource.
  • options - WorkspacesClientBeginDeleteOptions contains the optional parameters for the WorkspacesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum"
)

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

Output:

func (*WorkspacesClient) Get 

func (client *WorkspacesClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, options *WorkspacesClientGetOptions) (WorkspacesClientGetResponse, error)

Get - Returns the Workspace resource associated with the given name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • workspaceName - The name of the quantum workspace resource.
  • options - WorkspacesClientGetOptions contains the optional parameters for the WorkspacesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkspacesClient().Get(ctx, "quantumResourcegroup", "quantumworkspace1", 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.Workspace = armquantum.Workspace{
	// 	Name: to.Ptr("quantumworkspace1"),
	// 	Type: to.Ptr("Microsoft.Quantum/Workspaces"),
	// 	ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/quantumResourcegroup/providers/Microsoft.Quantum/Workspaces/quantumworkspace1"),
	// 	SystemData: &armquantum.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
	// 		CreatedBy: to.Ptr("user1"),
	// 		CreatedByType: to.Ptr(armquantum.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user2"),
	// 		LastModifiedByType: to.Ptr(armquantum.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"company": to.Ptr("Contoso"),
	// 		"department": to.Ptr("MightyMight"),
	// 	},
	// 	Identity: &armquantum.WorkspaceIdentity{
	// 		Type: to.Ptr(armquantum.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 		TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 	},
	// 	Properties: &armquantum.WorkspaceResourceProperties{
	// 		APIKeyEnabled: to.Ptr(true),
	// 		EndpointURI: to.Ptr("https://quantumworkspace1.westus.quantum.azure.com"),
	// 		Providers: []*armquantum.Provider{
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-h1"),
	// 				InstanceURI: to.Ptr("https://h1.endpoint.com"),
	// 				ProviderID: to.Ptr("Honeywell"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 			},
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-i1"),
	// 				InstanceURI: to.Ptr("https://i1.endpoint.com"),
	// 				ProviderID: to.Ptr("IonQ"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 			},
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-o1"),
	// 				InstanceURI: to.Ptr("https://o1.endpoint.com"),
	// 				ProviderID: to.Ptr("OneQBit"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 		}},
	// 		ProvisioningState: to.Ptr(armquantum.ProvisioningStatusSucceeded),
	// 		StorageAccount: to.Ptr("/subscriptions/1C4B2828-7D49-494F-933D-061373BE28C2/resourceGroups/quantumResourcegroup/providers/Microsoft.Storage/storageAccounts/testStorageAccount"),
	// 		Usable: to.Ptr(armquantum.UsableStatusYes),
	// 	},
	// }
}

Output:

func (*WorkspacesClient) NewListByResourceGroupPager 

func (client *WorkspacesClient) NewListByResourceGroupPager(resourceGroupName string, options *WorkspacesClientListByResourceGroupOptions) *runtime.Pager[WorkspacesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets the list of Workspaces within a resource group.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - WorkspacesClientListByResourceGroupOptions contains the optional parameters for the WorkspacesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesListResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkspacesClient().NewListByResourceGroupPager("quantumResourcegroup", 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.WorkspaceListResult = armquantum.WorkspaceListResult{
		// 	Value: []*armquantum.Workspace{
		// 		{
		// 			Name: to.Ptr("quantumworkspace1"),
		// 			Type: to.Ptr("Microsoft.Quantum/Workspaces"),
		// 			ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/quantumResourcegroup/providers/Microsoft.Quantum/Workspaces/quantumworkspace1"),
		// 			SystemData: &armquantum.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
		// 				CreatedBy: to.Ptr("user1"),
		// 				CreatedByType: to.Ptr(armquantum.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user2"),
		// 				LastModifiedByType: to.Ptr(armquantum.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("West US"),
		// 			Tags: map[string]*string{
		// 				"company": to.Ptr("Contoso"),
		// 				"department": to.Ptr("MightyMight"),
		// 			},
		// 			Identity: &armquantum.WorkspaceIdentity{
		// 				Type: to.Ptr(armquantum.ResourceIdentityTypeSystemAssigned),
		// 				PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"),
		// 				TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"),
		// 			},
		// 			Properties: &armquantum.WorkspaceResourceProperties{
		// 				APIKeyEnabled: to.Ptr(true),
		// 				EndpointURI: to.Ptr("https://quantumworkspace1.westus.quantum.azure.com"),
		// 				Providers: []*armquantum.Provider{
		// 					{
		// 						ApplicationName: to.Ptr("quantumworkspace1-h1"),
		// 						InstanceURI: to.Ptr("https://h1.endpoint.com"),
		// 						ProviderID: to.Ptr("Honeywell"),
		// 						ProviderSKU: to.Ptr("Basic"),
		// 						ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
		// 						ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
		// 				}},
		// 				ProvisioningState: to.Ptr(armquantum.ProvisioningStatusSucceeded),
		// 				StorageAccount: to.Ptr("/subscriptions/1C4B2828-7D49-494F-933D-061373BE28C2/resourceGroups/quantumResourcegroup/providers/Microsoft.Storage/storageAccounts/testStorageAccount"),
		// 				Usable: to.Ptr(armquantum.UsableStatusYes),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*WorkspacesClient) NewListBySubscriptionPager 

func (client *WorkspacesClient) NewListBySubscriptionPager(options *WorkspacesClientListBySubscriptionOptions) *runtime.Pager[WorkspacesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets the list of Workspaces within a Subscription.

Generated from API version 2023-11-13-preview

  • options - WorkspacesClientListBySubscriptionOptions contains the optional parameters for the WorkspacesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesListSubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkspacesClient().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.WorkspaceListResult = armquantum.WorkspaceListResult{
		// 	Value: []*armquantum.Workspace{
		// 		{
		// 			Name: to.Ptr("quantumworkspace1"),
		// 			Type: to.Ptr("Microsoft.Quantum/Workspaces"),
		// 			ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/quantumResourcegroup/providers/Microsoft.Quantum/Workspaces/quantumworkspace1"),
		// 			SystemData: &armquantum.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
		// 				CreatedBy: to.Ptr("user1"),
		// 				CreatedByType: to.Ptr(armquantum.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user2"),
		// 				LastModifiedByType: to.Ptr(armquantum.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("West US"),
		// 			Tags: map[string]*string{
		// 				"company": to.Ptr("Contoso"),
		// 				"department": to.Ptr("MightyMight"),
		// 			},
		// 			Identity: &armquantum.WorkspaceIdentity{
		// 				Type: to.Ptr(armquantum.ResourceIdentityTypeSystemAssigned),
		// 				PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"),
		// 				TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"),
		// 			},
		// 			Properties: &armquantum.WorkspaceResourceProperties{
		// 				APIKeyEnabled: to.Ptr(true),
		// 				EndpointURI: to.Ptr("https://quantumworkspace1.westus.quantum.azure.com"),
		// 				Providers: []*armquantum.Provider{
		// 					{
		// 						ApplicationName: to.Ptr("quantumworkspace1-h1"),
		// 						InstanceURI: to.Ptr("https://h1.endpoint.com"),
		// 						ProviderID: to.Ptr("Honeywell"),
		// 						ProviderSKU: to.Ptr("Basic"),
		// 						ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
		// 						ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
		// 				}},
		// 				ProvisioningState: to.Ptr(armquantum.ProvisioningStatusSucceeded),
		// 				StorageAccount: to.Ptr("/subscriptions/1C4B2828-7D49-494F-933D-061373BE28C2/resourceGroups/quantumResourcegroup/providers/Microsoft.Storage/storageAccounts/testStorageAccount"),
		// 				Usable: to.Ptr(armquantum.UsableStatusYes),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*WorkspacesClient) UpdateTags 

func (client *WorkspacesClient) UpdateTags(ctx context.Context, resourceGroupName string, workspaceName string, workspaceTags TagsObject, options *WorkspacesClientUpdateTagsOptions) (WorkspacesClientUpdateTagsResponse, error)

UpdateTags - Updates an existing workspace's tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-11-13-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • workspaceName - The name of the quantum workspace resource.
  • workspaceTags - Parameters supplied to update tags.
  • options - WorkspacesClientUpdateTagsOptions contains the optional parameters for the WorkspacesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/quantum/resource-manager/Microsoft.Quantum/preview/2023-11-13-preview/examples/quantumWorkspacesPatch.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/quantum/armquantum"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armquantum.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkspacesClient().UpdateTags(ctx, "quantumResourcegroup", "quantumworkspace1", armquantum.TagsObject{
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
			"tag2": to.Ptr("value2"),
		},
	}, 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.Workspace = armquantum.Workspace{
	// 	Name: to.Ptr("quantumworkspace1"),
	// 	Type: to.Ptr("Microsoft.Quantum/Workspaces"),
	// 	ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/quantumResourcegroup/providers/Microsoft.Quantum/Workspaces/quantumworkspace1"),
	// 	SystemData: &armquantum.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
	// 		CreatedBy: to.Ptr("user1"),
	// 		CreatedByType: to.Ptr(armquantum.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user2"),
	// 		LastModifiedByType: to.Ptr(armquantum.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"tag1": to.Ptr("value1"),
	// 		"tag2": to.Ptr("value2"),
	// 	},
	// 	Identity: &armquantum.WorkspaceIdentity{
	// 		Type: to.Ptr(armquantum.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 		TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 	},
	// 	Properties: &armquantum.WorkspaceResourceProperties{
	// 		APIKeyEnabled: to.Ptr(true),
	// 		EndpointURI: to.Ptr("https://quantumworkspace1.westus.quantum.azure.com"),
	// 		Providers: []*armquantum.Provider{
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-h1"),
	// 				InstanceURI: to.Ptr("https://h1.endpoint.com"),
	// 				ProviderID: to.Ptr("Honeywell"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444444"),
	// 			},
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-i1"),
	// 				InstanceURI: to.Ptr("https://i1.endpoint.com"),
	// 				ProviderID: to.Ptr("IonQ"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444445"),
	// 			},
	// 			{
	// 				ApplicationName: to.Ptr("quantumworkspace1-o1"),
	// 				InstanceURI: to.Ptr("https://o1.endpoint.com"),
	// 				ProviderID: to.Ptr("OneQBit"),
	// 				ProviderSKU: to.Ptr("Basic"),
	// 				ProvisioningState: to.Ptr(armquantum.StatusSucceeded),
	// 				ResourceUsageID: to.Ptr("00000000-1111-2222-3333-444444444446"),
	// 		}},
	// 		ProvisioningState: to.Ptr(armquantum.ProvisioningStatusSucceeded),
	// 		StorageAccount: to.Ptr("/subscriptions/1C4B2828-7D49-494F-933D-061373BE28C2/resourceGroups/quantumResourcegroup/providers/Microsoft.Storage/storageAccounts/testStorageAccount"),
	// 		Usable: to.Ptr(armquantum.UsableStatusYes),
	// 	},
	// }
}

Output:

type WorkspacesClientBeginCreateOrUpdateOptions 

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

WorkspacesClientBeginCreateOrUpdateOptions contains the optional parameters for the WorkspacesClient.BeginCreateOrUpdate method.

type WorkspacesClientBeginDeleteOptions 

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

WorkspacesClientBeginDeleteOptions contains the optional parameters for the WorkspacesClient.BeginDelete method.

type WorkspacesClientCreateOrUpdateResponse 

type WorkspacesClientCreateOrUpdateResponse struct {
	// The resource proxy definition object for quantum workspace.
	Workspace
}

WorkspacesClientCreateOrUpdateResponse contains the response from method WorkspacesClient.BeginCreateOrUpdate.

type WorkspacesClientDeleteResponse 

type WorkspacesClientDeleteResponse struct {
}

WorkspacesClientDeleteResponse contains the response from method WorkspacesClient.BeginDelete.

type WorkspacesClientGetOptions 

type WorkspacesClientGetOptions struct {
}

WorkspacesClientGetOptions contains the optional parameters for the WorkspacesClient.Get method.

type WorkspacesClientGetResponse 

type WorkspacesClientGetResponse struct {
	// The resource proxy definition object for quantum workspace.
	Workspace
}

WorkspacesClientGetResponse contains the response from method WorkspacesClient.Get.

type WorkspacesClientListByResourceGroupOptions 

type WorkspacesClientListByResourceGroupOptions struct {
}

WorkspacesClientListByResourceGroupOptions contains the optional parameters for the WorkspacesClient.NewListByResourceGroupPager method.

type WorkspacesClientListByResourceGroupResponse 

type WorkspacesClientListByResourceGroupResponse struct {
	// The response of a list Workspaces operation.
	WorkspaceListResult
}

WorkspacesClientListByResourceGroupResponse contains the response from method WorkspacesClient.NewListByResourceGroupPager.

type WorkspacesClientListBySubscriptionOptions 

type WorkspacesClientListBySubscriptionOptions struct {
}

WorkspacesClientListBySubscriptionOptions contains the optional parameters for the WorkspacesClient.NewListBySubscriptionPager method.

type WorkspacesClientListBySubscriptionResponse 

type WorkspacesClientListBySubscriptionResponse struct {
	// The response of a list Workspaces operation.
	WorkspaceListResult
}

WorkspacesClientListBySubscriptionResponse contains the response from method WorkspacesClient.NewListBySubscriptionPager.

type WorkspacesClientUpdateTagsOptions 

type WorkspacesClientUpdateTagsOptions struct {
}

WorkspacesClientUpdateTagsOptions contains the optional parameters for the WorkspacesClient.UpdateTags method.

type WorkspacesClientUpdateTagsResponse 

type WorkspacesClientUpdateTagsResponse struct {
	// The resource proxy definition object for quantum workspace.
	Workspace
}

WorkspacesClientUpdateTagsResponse contains the response from method WorkspacesClient.UpdateTags.

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.