armhealthcareapis

package module
v2.1.0 Latest Latest
Warning

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

 Go to latest Published: Apr 22, 2024 License: MIT Imports: 14 Imported by: 1

README

Azure Healthcare APIs Module for Go

PkgGoDev

The armhealthcareapis module provides operations for working with Azure Healthcare APIs.

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 Healthcare APIs module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthcareapis/armhealthcareapis/v2

Authorization

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

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 Healthcare APIs 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 ActionType 

type ActionType string

ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type CheckNameAvailabilityParameters 

type CheckNameAvailabilityParameters struct {
	// REQUIRED; The name of the service instance to check.
	Name *string

	// REQUIRED; The fully qualified resource type which includes provider namespace.
	Type *string
}

CheckNameAvailabilityParameters - Input values.

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

func (*ClientFactory) NewDicomServicesClient 

func (c *ClientFactory) NewDicomServicesClient() *DicomServicesClient

NewDicomServicesClient creates a new instance of DicomServicesClient.

func (*ClientFactory) NewFhirDestinationsClient 

func (c *ClientFactory) NewFhirDestinationsClient() *FhirDestinationsClient

NewFhirDestinationsClient creates a new instance of FhirDestinationsClient.

func (*ClientFactory) NewFhirServicesClient 

func (c *ClientFactory) NewFhirServicesClient() *FhirServicesClient

NewFhirServicesClient creates a new instance of FhirServicesClient.

func (*ClientFactory) NewIotConnectorFhirDestinationClient 

func (c *ClientFactory) NewIotConnectorFhirDestinationClient() *IotConnectorFhirDestinationClient

NewIotConnectorFhirDestinationClient creates a new instance of IotConnectorFhirDestinationClient.

func (*ClientFactory) NewIotConnectorsClient 

func (c *ClientFactory) NewIotConnectorsClient() *IotConnectorsClient

NewIotConnectorsClient creates a new instance of IotConnectorsClient.

func (*ClientFactory) NewOperationResultsClient 

func (c *ClientFactory) NewOperationResultsClient() *OperationResultsClient

NewOperationResultsClient creates a new instance of OperationResultsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPrivateEndpointConnectionsClient 

func (c *ClientFactory) NewPrivateEndpointConnectionsClient() *PrivateEndpointConnectionsClient

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient.

func (*ClientFactory) NewPrivateLinkResourcesClient 

func (c *ClientFactory) NewPrivateLinkResourcesClient() *PrivateLinkResourcesClient

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient.

func (*ClientFactory) NewServicesClient 

func (c *ClientFactory) NewServicesClient() *ServicesClient

NewServicesClient creates a new instance of ServicesClient.

func (*ClientFactory) NewWorkspacePrivateEndpointConnectionsClient 

func (c *ClientFactory) NewWorkspacePrivateEndpointConnectionsClient() *WorkspacePrivateEndpointConnectionsClient

NewWorkspacePrivateEndpointConnectionsClient creates a new instance of WorkspacePrivateEndpointConnectionsClient.

func (*ClientFactory) NewWorkspacePrivateLinkResourcesClient 

func (c *ClientFactory) NewWorkspacePrivateLinkResourcesClient() *WorkspacePrivateLinkResourcesClient

NewWorkspacePrivateLinkResourcesClient creates a new instance of WorkspacePrivateLinkResourcesClient.

func (*ClientFactory) NewWorkspacesClient 

func (c *ClientFactory) NewWorkspacesClient() *WorkspacesClient

NewWorkspacesClient creates a new instance of WorkspacesClient.

type CorsConfiguration 

type CorsConfiguration struct {
	// If credentials are allowed via CORS.
	AllowCredentials *bool

	// The headers to be allowed via CORS.
	Headers []*string

	// The max age to be allowed via CORS.
	MaxAge *int32

	// The methods to be allowed via CORS.
	Methods []*string

	// The origins to be allowed via CORS.
	Origins []*string
}

CorsConfiguration - The settings for the CORS configuration of the service instance.

func (CorsConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CorsConfiguration.

func (*CorsConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CorsConfiguration.

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 DicomService 

type DicomService struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity

	// The resource location.
	Location *string

	// Dicom Service configuration.
	Properties *DicomServiceProperties

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

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY; The resource type.
	Type *string
}

DicomService - The description of Dicom Service

func (DicomService) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DicomService.

func (*DicomService) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DicomService.

type DicomServiceAuthenticationConfiguration 

type DicomServiceAuthenticationConfiguration struct {
	// READ-ONLY; The audiences for the service
	Audiences []*string

	// READ-ONLY; The authority url for the service
	Authority *string
}

DicomServiceAuthenticationConfiguration - Authentication configuration information

func (DicomServiceAuthenticationConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DicomServiceAuthenticationConfiguration.

func (*DicomServiceAuthenticationConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DicomServiceAuthenticationConfiguration.

type DicomServiceCollection 

type DicomServiceCollection struct {
	// The link used to get the next page of Dicom Services.
	NextLink *string

	// The list of Dicom Services.
	Value []*DicomService
}

DicomServiceCollection - The collection of Dicom Services.

func (DicomServiceCollection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DicomServiceCollection.

func (*DicomServiceCollection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DicomServiceCollection.

type DicomServicePatchResource 

type DicomServicePatchResource struct {
	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity

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

DicomServicePatchResource - Dicom Service patch properties

func (DicomServicePatchResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DicomServicePatchResource.

func (*DicomServicePatchResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DicomServicePatchResource.

type DicomServiceProperties 

type DicomServiceProperties struct {
	// Dicom Service authentication configuration.
	AuthenticationConfiguration *DicomServiceAuthenticationConfiguration

	// Dicom Service Cors configuration.
	CorsConfiguration *CorsConfiguration

	// If data partitions is enabled or not.
	EnableDataPartitions *bool

	// The encryption settings of the DICOM service
	Encryption *Encryption

	// Control permission for data plane traffic coming from public networks while private endpoint is enabled.
	PublicNetworkAccess *PublicNetworkAccess

	// The configuration of external storage account
	StorageConfiguration *StorageConfiguration

	// READ-ONLY; DICOM Service event support status.
	EventState *ServiceEventState

	// READ-ONLY; The list of private endpoint connections that are set up for this resource.
	PrivateEndpointConnections []*PrivateEndpointConnection

	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The url of the Dicom Services.
	ServiceURL *string
}

DicomServiceProperties - Dicom Service properties.

func (DicomServiceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DicomServiceProperties.

func (*DicomServiceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DicomServiceProperties.

type DicomServicesClient 

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

DicomServicesClient contains the methods for the DicomServices group. Don't use this type directly, use NewDicomServicesClient() instead.

func NewDicomServicesClient 

func NewDicomServicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DicomServicesClient, error)

NewDicomServicesClient creates a new instance of DicomServicesClient with the specified values.

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

func (*DicomServicesClient) BeginCreateOrUpdate 

func (client *DicomServicesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, workspaceName string, dicomServiceName string, dicomservice DicomService, options *DicomServicesClientBeginCreateOrUpdateOptions) (*runtime.Poller[DicomServicesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a DICOM Service resource with the specified parameters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • dicomServiceName - The name of DICOM Service resource.
  • dicomservice - The parameters for creating or updating a Dicom Service resource.
  • options - DicomServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the DicomServicesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/dicomservices/DicomServices_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDicomServicesClient().BeginCreateOrUpdate(ctx, "testRG", "workspace1", "blue", armhealthcareapis.DicomService{
	Location: to.Ptr("westus"),
	Properties: &armhealthcareapis.DicomServiceProperties{
		EnableDataPartitions: to.Ptr(false),
		StorageConfiguration: &armhealthcareapis.StorageConfiguration{
			FileSystemName:    to.Ptr("fileSystemName"),
			StorageResourceID: to.Ptr("/subscriptions/ab309d4e-4c2e-4241-be2e-08e1c8dd4246/resourceGroups/rgname/providers/Microsoft.Storage/storageAccounts/accountname"),
		},
	},
}, 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.DicomService = armhealthcareapis.DicomService{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armhealthcareapis.UserAssignedIdentity{
// 			"/subscriptions/subid/resourcegroups/testRG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-mi": &armhealthcareapis.UserAssignedIdentity{
// 			},
// 		},
// 	},
// 	Name: to.Ptr("blue"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/dicomservices/blue"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armhealthcareapis.DicomServiceProperties{
// 		AuthenticationConfiguration: &armhealthcareapis.DicomServiceAuthenticationConfiguration{
// 			Audiences: []*string{
// 				to.Ptr("https://azurehealthcareapis.com/"),
// 				to.Ptr("https://azurehealthcareapis.com")},
// 				Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			},
// 			CorsConfiguration: &armhealthcareapis.CorsConfiguration{
// 				AllowCredentials: to.Ptr(false),
// 				Headers: []*string{
// 					to.Ptr("*")},
// 					MaxAge: to.Ptr[int32](1440),
// 					Methods: []*string{
// 						to.Ptr("DELETE"),
// 						to.Ptr("GET"),
// 						to.Ptr("OPTIONS"),
// 						to.Ptr("PATCH"),
// 						to.Ptr("POST"),
// 						to.Ptr("PUT")},
// 						Origins: []*string{
// 							to.Ptr("*")},
// 						},
// 						EnableDataPartitions: to.Ptr(false),
// 						Encryption: &armhealthcareapis.Encryption{
// 							CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
// 								KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
// 							},
// 						},
// 						EventState: to.Ptr(armhealthcareapis.ServiceEventStateDisabled),
// 						ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 						StorageConfiguration: &armhealthcareapis.StorageConfiguration{
// 							FileSystemName: to.Ptr("fileSystemName"),
// 							StorageResourceID: to.Ptr("/subscriptions/ab309d4e-4c2e-4241-be2e-08e1c8dd4246/resourceGroups/rgname/providers/Microsoft.Storage/storageAccounts/accountname"),
// 						},
// 					},
// 				}

Output:

func (*DicomServicesClient) BeginDelete 

func (client *DicomServicesClient) BeginDelete(ctx context.Context, resourceGroupName string, dicomServiceName string, workspaceName string, options *DicomServicesClientBeginDeleteOptions) (*runtime.Poller[DicomServicesClientDeleteResponse], error)

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

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • dicomServiceName - The name of DICOM Service resource.
  • workspaceName - The name of workspace resource.
  • options - DicomServicesClientBeginDeleteOptions contains the optional parameters for the DicomServicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/dicomservices/DicomServices_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDicomServicesClient().BeginDelete(ctx, "testRG", "blue", "workspace1", 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 (*DicomServicesClient) BeginUpdate 

func (client *DicomServicesClient) BeginUpdate(ctx context.Context, resourceGroupName string, dicomServiceName string, workspaceName string, dicomservicePatchResource DicomServicePatchResource, options *DicomServicesClientBeginUpdateOptions) (*runtime.Poller[DicomServicesClientUpdateResponse], error)

BeginUpdate - Patch DICOM Service details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • dicomServiceName - The name of DICOM Service resource.
  • workspaceName - The name of workspace resource.
  • dicomservicePatchResource - The parameters for updating a Dicom Service.
  • options - DicomServicesClientBeginUpdateOptions contains the optional parameters for the DicomServicesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/dicomservices/DicomServices_Patch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDicomServicesClient().BeginUpdate(ctx, "testRG", "blue", "workspace1", armhealthcareapis.DicomServicePatchResource{
	Tags: map[string]*string{
		"tagKey": to.Ptr("tagValue"),
	},
}, 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.DicomService = armhealthcareapis.DicomService{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("2f1f372f-edcf-43f5-aedb-173da3cc5c1e"),
// 		TenantID: to.Ptr("abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 	},
// 	Name: to.Ptr("blue"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/dicomservices/blue"),
// 	Tags: map[string]*string{
// 		"tagKey": to.Ptr("tagValue"),
// 	},
// 	Properties: &armhealthcareapis.DicomServiceProperties{
// 		AuthenticationConfiguration: &armhealthcareapis.DicomServiceAuthenticationConfiguration{
// 			Audiences: []*string{
// 				to.Ptr("https://azurehealthcareapis.com/"),
// 				to.Ptr("https://azurehealthcareapis.com")},
// 				Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			},
// 			CorsConfiguration: &armhealthcareapis.CorsConfiguration{
// 				AllowCredentials: to.Ptr(false),
// 				Headers: []*string{
// 					to.Ptr("*")},
// 					MaxAge: to.Ptr[int32](1440),
// 					Methods: []*string{
// 						to.Ptr("DELETE"),
// 						to.Ptr("GET"),
// 						to.Ptr("OPTIONS"),
// 						to.Ptr("PATCH"),
// 						to.Ptr("POST"),
// 						to.Ptr("PUT")},
// 						Origins: []*string{
// 							to.Ptr("*")},
// 						},
// 						EnableDataPartitions: to.Ptr(false),
// 						Encryption: &armhealthcareapis.Encryption{
// 							CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
// 								KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
// 							},
// 						},
// 						EventState: to.Ptr(armhealthcareapis.ServiceEventStateDisabled),
// 						ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 						ServiceURL: to.Ptr("https://workspace1-blue.dicom.azurehealthcareapis.com"),
// 						StorageConfiguration: &armhealthcareapis.StorageConfiguration{
// 							FileSystemName: to.Ptr("fileSystemName"),
// 							StorageResourceID: to.Ptr("/subscriptions/ab309d4e-4c2e-4241-be2e-08e1c8dd4246/resourceGroups/rgname/providers/Microsoft.Storage/storageAccounts/accountname"),
// 						},
// 					},
// 				}

Output:

func (*DicomServicesClient) Get 

func (client *DicomServicesClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, dicomServiceName string, options *DicomServicesClientGetOptions) (DicomServicesClientGetResponse, error)

Get - Gets the properties of the specified DICOM Service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • dicomServiceName - The name of DICOM Service resource.
  • options - DicomServicesClientGetOptions contains the optional parameters for the DicomServicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/dicomservices/DicomServices_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewDicomServicesClient().Get(ctx, "testRG", "workspace1", "blue", 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.DicomService = armhealthcareapis.DicomService{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("2f1f372f-edcf-43f5-aedb-173da3cc5c1e"),
// 		TenantID: to.Ptr("abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 	},
// 	Name: to.Ptr("blue"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/dicomservices/blue"),
// 	Properties: &armhealthcareapis.DicomServiceProperties{
// 		AuthenticationConfiguration: &armhealthcareapis.DicomServiceAuthenticationConfiguration{
// 			Audiences: []*string{
// 				to.Ptr("https://azurehealthcareapis.com/"),
// 				to.Ptr("https://azurehealthcareapis.com")},
// 				Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			},
// 			CorsConfiguration: &armhealthcareapis.CorsConfiguration{
// 				AllowCredentials: to.Ptr(false),
// 				Headers: []*string{
// 					to.Ptr("*")},
// 					MaxAge: to.Ptr[int32](1440),
// 					Methods: []*string{
// 						to.Ptr("DELETE"),
// 						to.Ptr("GET"),
// 						to.Ptr("OPTIONS"),
// 						to.Ptr("PATCH"),
// 						to.Ptr("POST"),
// 						to.Ptr("PUT")},
// 						Origins: []*string{
// 							to.Ptr("*")},
// 						},
// 						EnableDataPartitions: to.Ptr(false),
// 						Encryption: &armhealthcareapis.Encryption{
// 							CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
// 								KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
// 							},
// 						},
// 						EventState: to.Ptr(armhealthcareapis.ServiceEventStateDisabled),
// 						ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 						ServiceURL: to.Ptr("https://workspace1-blue.dicom.azurehealthcareapis.com"),
// 						StorageConfiguration: &armhealthcareapis.StorageConfiguration{
// 							FileSystemName: to.Ptr("fileSystemName"),
// 							StorageResourceID: to.Ptr("/subscriptions/ab309d4e-4c2e-4241-be2e-08e1c8dd4246/resourceGroups/rgname/providers/Microsoft.Storage/storageAccounts/accountname"),
// 						},
// 					},
// 				}

Output:

func (*DicomServicesClient) NewListByWorkspacePager 

func (client *DicomServicesClient) NewListByWorkspacePager(resourceGroupName string, workspaceName string, options *DicomServicesClientListByWorkspaceOptions) *runtime.Pager[DicomServicesClientListByWorkspaceResponse]

NewListByWorkspacePager - Lists all DICOM Services for the given workspace

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • options - DicomServicesClientListByWorkspaceOptions contains the optional parameters for the DicomServicesClient.NewListByWorkspacePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/dicomservices/DicomServices_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewDicomServicesClient().NewListByWorkspacePager("testRG", "workspace1", 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.DicomServiceCollection = armhealthcareapis.DicomServiceCollection{
	// 	Value: []*armhealthcareapis.DicomService{
	// 		{
	// 			Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
	// 				Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
	// 				PrincipalID: to.Ptr("2f1f372f-edcf-43f5-aedb-173da3cc5c1e"),
	// 				TenantID: to.Ptr("abfde7b2-df0f-47e6-aabf-2462b07508dc"),
	// 			},
	// 			Name: to.Ptr("blue"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/dicomservices/blue"),
	// 			Properties: &armhealthcareapis.DicomServiceProperties{
	// 				AuthenticationConfiguration: &armhealthcareapis.DicomServiceAuthenticationConfiguration{
	// 					Audiences: []*string{
	// 						to.Ptr("https://azurehealthcareapis.com/"),
	// 						to.Ptr("https://azurehealthcareapis.com")},
	// 						Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
	// 					},
	// 					CorsConfiguration: &armhealthcareapis.CorsConfiguration{
	// 						AllowCredentials: to.Ptr(false),
	// 						Headers: []*string{
	// 							to.Ptr("*")},
	// 							MaxAge: to.Ptr[int32](1440),
	// 							Methods: []*string{
	// 								to.Ptr("DELETE"),
	// 								to.Ptr("GET"),
	// 								to.Ptr("OPTIONS"),
	// 								to.Ptr("PATCH"),
	// 								to.Ptr("POST"),
	// 								to.Ptr("PUT")},
	// 								Origins: []*string{
	// 									to.Ptr("*")},
	// 								},
	// 								EnableDataPartitions: to.Ptr(false),
	// 								Encryption: &armhealthcareapis.Encryption{
	// 									CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
	// 										KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
	// 									},
	// 								},
	// 								EventState: to.Ptr(armhealthcareapis.ServiceEventStateDisabled),
	// 								ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 								ServiceURL: to.Ptr("https://workspace1-blue.dicom.azurehealthcareapis.com"),
	// 								StorageConfiguration: &armhealthcareapis.StorageConfiguration{
	// 									FileSystemName: to.Ptr("fileSystemName"),
	// 									StorageResourceID: to.Ptr("/subscriptions/ab309d4e-4c2e-4241-be2e-08e1c8dd4246/resourceGroups/rgname/providers/Microsoft.Storage/storageAccounts/accountname"),
	// 								},
	// 							},
	// 						},
	// 						{
	// 							Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
	// 								Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
	// 								PrincipalID: to.Ptr("2f1f372f-edcf-43f5-aedb-173da3cc5c1e"),
	// 								TenantID: to.Ptr("abfde7b2-df0f-47e6-aabf-2462b07508dc"),
	// 							},
	// 							Name: to.Ptr("red"),
	// 							Type: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices"),
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/dicomservices/red"),
	// 							Properties: &armhealthcareapis.DicomServiceProperties{
	// 								AuthenticationConfiguration: &armhealthcareapis.DicomServiceAuthenticationConfiguration{
	// 									Audiences: []*string{
	// 										to.Ptr("https://azurehealthcareapis.com/"),
	// 										to.Ptr("https://azurehealthcareapis.com")},
	// 										Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
	// 									},
	// 									EnableDataPartitions: to.Ptr(false),
	// 									Encryption: &armhealthcareapis.Encryption{
	// 										CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
	// 											KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
	// 										},
	// 									},
	// 									EventState: to.Ptr(armhealthcareapis.ServiceEventStateDisabled),
	// 									ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 									ServiceURL: to.Ptr("https://workspace1-red.dicom.azurehealthcareapis.com"),
	// 									StorageConfiguration: &armhealthcareapis.StorageConfiguration{
	// 										FileSystemName: to.Ptr("fileSystemName"),
	// 										StorageResourceID: to.Ptr("/subscriptions/ab309d4e-4c2e-4241-be2e-08e1c8dd4246/resourceGroups/rgname/providers/Microsoft.Storage/storageAccounts/accountname"),
	// 									},
	// 								},
	// 						}},
	// 					}
}

Output:

type DicomServicesClientBeginCreateOrUpdateOptions 

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

DicomServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the DicomServicesClient.BeginCreateOrUpdate method.

type DicomServicesClientBeginDeleteOptions 

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

DicomServicesClientBeginDeleteOptions contains the optional parameters for the DicomServicesClient.BeginDelete method.

type DicomServicesClientBeginUpdateOptions 

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

DicomServicesClientBeginUpdateOptions contains the optional parameters for the DicomServicesClient.BeginUpdate method.

type DicomServicesClientCreateOrUpdateResponse 

type DicomServicesClientCreateOrUpdateResponse struct {
	// The description of Dicom Service
	DicomService
}

DicomServicesClientCreateOrUpdateResponse contains the response from method DicomServicesClient.BeginCreateOrUpdate.

type DicomServicesClientDeleteResponse 

type DicomServicesClientDeleteResponse struct {
}

DicomServicesClientDeleteResponse contains the response from method DicomServicesClient.BeginDelete.

type DicomServicesClientGetOptions 

type DicomServicesClientGetOptions struct {
}

DicomServicesClientGetOptions contains the optional parameters for the DicomServicesClient.Get method.

type DicomServicesClientGetResponse 

type DicomServicesClientGetResponse struct {
	// The description of Dicom Service
	DicomService
}

DicomServicesClientGetResponse contains the response from method DicomServicesClient.Get.

type DicomServicesClientListByWorkspaceOptions 

type DicomServicesClientListByWorkspaceOptions struct {
}

DicomServicesClientListByWorkspaceOptions contains the optional parameters for the DicomServicesClient.NewListByWorkspacePager method.

type DicomServicesClientListByWorkspaceResponse 

type DicomServicesClientListByWorkspaceResponse struct {
	// The collection of Dicom Services.
	DicomServiceCollection
}

DicomServicesClientListByWorkspaceResponse contains the response from method DicomServicesClient.NewListByWorkspacePager.

type DicomServicesClientUpdateResponse 

type DicomServicesClientUpdateResponse struct {
	// The description of Dicom Service
	DicomService
}

DicomServicesClientUpdateResponse contains the response from method DicomServicesClient.BeginUpdate.

type Encryption 

type Encryption struct {
	// The encryption settings for the customer-managed key
	CustomerManagedKeyEncryption *EncryptionCustomerManagedKeyEncryption
}

Encryption - Settings to encrypt a service

func (Encryption) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Encryption.

func (*Encryption) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Encryption.

type EncryptionCustomerManagedKeyEncryption 

type EncryptionCustomerManagedKeyEncryption struct {
	// The URL of the key to use for encryption
	KeyEncryptionKeyURL *string
}

EncryptionCustomerManagedKeyEncryption - The encryption settings for the customer-managed key

func (EncryptionCustomerManagedKeyEncryption) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionCustomerManagedKeyEncryption.

func (*EncryptionCustomerManagedKeyEncryption) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionCustomerManagedKeyEncryption.

type Error 

type Error struct {
	// Error details
	Error *ErrorDetailsInternal
}

Error details.

func (Error) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Error.

func (*Error) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Error.

type ErrorDetails 

type ErrorDetails struct {
	// Error details
	Error *ErrorDetailsInternal
}

ErrorDetails - Error details.

func (ErrorDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorDetails.

func (*ErrorDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetails.

type ErrorDetailsInternal 

type ErrorDetailsInternal struct {
	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error message.
	Message *string

	// READ-ONLY; The target of the particular error.
	Target *string
}

ErrorDetailsInternal - Error details.

func (ErrorDetailsInternal) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorDetailsInternal.

func (*ErrorDetailsInternal) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetailsInternal.

type FhirDestinationsClient 

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

FhirDestinationsClient contains the methods for the FhirDestinations group. Don't use this type directly, use NewFhirDestinationsClient() instead.

func NewFhirDestinationsClient 

func NewFhirDestinationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FhirDestinationsClient, error)

NewFhirDestinationsClient creates a new instance of FhirDestinationsClient with the specified values.

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

func (*FhirDestinationsClient) NewListByIotConnectorPager 

func (client *FhirDestinationsClient) NewListByIotConnectorPager(resourceGroupName string, workspaceName string, iotConnectorName string, options *FhirDestinationsClientListByIotConnectorOptions) *runtime.Pager[FhirDestinationsClientListByIotConnectorResponse]

NewListByIotConnectorPager - Lists all FHIR destinations for the given IoT Connector

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • iotConnectorName - The name of IoT Connector resource.
  • options - FhirDestinationsClientListByIotConnectorOptions contains the optional parameters for the FhirDestinationsClient.NewListByIotConnectorPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_fhirdestination_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewFhirDestinationsClient().NewListByIotConnectorPager("testRG", "workspace1", "blue", 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.IotFhirDestinationCollection = armhealthcareapis.IotFhirDestinationCollection{
	// 	Value: []*armhealthcareapis.IotFhirDestination{
	// 		{
	// 			Name: to.Ptr("dest1"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/fhirdestinations"),
	// 			Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue/fhirdestinations/dest1"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armhealthcareapis.IotFhirDestinationProperties{
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 				FhirMapping: &armhealthcareapis.IotMappingProperties{
	// 					Content: map[string]any{
	// 						"template":[]any{
	// 							map[string]any{
	// 								"template":map[string]any{
	// 									"codes":[]any{
	// 										map[string]any{
	// 											"code": "8867-4",
	// 											"display": "Heart rate",
	// 											"system": "http://loinc.org",
	// 										},
	// 									},
	// 									"periodInterval": float64(60),
	// 									"typeName": "heartrate",
	// 									"value":map[string]any{
	// 										"defaultPeriod": float64(5000),
	// 										"unit": "count/min",
	// 										"valueName": "hr",
	// 										"valueType": "SampledData",
	// 									},
	// 								},
	// 								"templateType": "CodeValueFhir",
	// 							},
	// 						},
	// 						"templateType": "CollectionFhirTemplate",
	// 					},
	// 				},
	// 				FhirServiceResourceID: to.Ptr("subscriptions/11111111-2222-3333-4444-555566667777/resourceGroups/myrg/providers/Microsoft.HealthcareApis/workspaces/myworkspace/fhirservices/myfhirservice"),
	// 				ResourceIdentityResolutionType: to.Ptr(armhealthcareapis.IotIdentityResolutionTypeCreate),
	// 			},
	// 			SystemData: &armhealthcareapis.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
	// 				CreatedBy: to.Ptr("string"),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("string"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("dest2"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/fhirdestinations"),
	// 			Etag: to.Ptr("00000000-0000-0000-f6ac-912ca49e01d6"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue/fhirdestinations/dest2"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armhealthcareapis.IotFhirDestinationProperties{
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 				FhirMapping: &armhealthcareapis.IotMappingProperties{
	// 					Content: map[string]any{
	// 						"template":[]any{
	// 							map[string]any{
	// 								"template":map[string]any{
	// 									"codes":[]any{
	// 										map[string]any{
	// 											"code": "8867-4",
	// 											"display": "Heart rate",
	// 											"system": "http://loinc.org",
	// 										},
	// 									},
	// 									"periodInterval": float64(60),
	// 									"typeName": "heartrate",
	// 									"value":map[string]any{
	// 										"defaultPeriod": float64(5000),
	// 										"unit": "count/min",
	// 										"valueName": "hr",
	// 										"valueType": "SampledData",
	// 									},
	// 								},
	// 								"templateType": "CodeValueFhir",
	// 							},
	// 						},
	// 						"templateType": "CollectionFhirTemplate",
	// 					},
	// 				},
	// 				FhirServiceResourceID: to.Ptr("subscriptions/11111111-2222-3333-4444-555566667777/resourceGroups/myrg/providers/Microsoft.HealthcareApis/workspaces/myworkspace/fhirservices/myfhirservice"),
	// 				ResourceIdentityResolutionType: to.Ptr(armhealthcareapis.IotIdentityResolutionTypeLookup),
	// 			},
	// 			SystemData: &armhealthcareapis.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-27T19:26:24.072Z"); return t}()),
	// 				CreatedBy: to.Ptr("string"),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-27T19:26:24.072Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("string"),
	// 			},
	// 	}},
	// }
}

Output:

type FhirDestinationsClientListByIotConnectorOptions 

type FhirDestinationsClientListByIotConnectorOptions struct {
}

FhirDestinationsClientListByIotConnectorOptions contains the optional parameters for the FhirDestinationsClient.NewListByIotConnectorPager method.

type FhirDestinationsClientListByIotConnectorResponse 

type FhirDestinationsClientListByIotConnectorResponse struct {
	// A collection of IoT Connector FHIR destinations.
	IotFhirDestinationCollection
}

FhirDestinationsClientListByIotConnectorResponse contains the response from method FhirDestinationsClient.NewListByIotConnectorPager.

type FhirResourceVersionPolicy 

type FhirResourceVersionPolicy string

FhirResourceVersionPolicy - Controls how resources are versioned on the FHIR service 

const (
	FhirResourceVersionPolicyNoVersion       FhirResourceVersionPolicy = "no-version"
	FhirResourceVersionPolicyVersioned       FhirResourceVersionPolicy = "versioned"
	FhirResourceVersionPolicyVersionedUpdate FhirResourceVersionPolicy = "versioned-update"
)

func PossibleFhirResourceVersionPolicyValues 

func PossibleFhirResourceVersionPolicyValues() []FhirResourceVersionPolicy

PossibleFhirResourceVersionPolicyValues returns the possible values for the FhirResourceVersionPolicy const type.

type FhirService 

type FhirService struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity

	// The kind of the service.
	Kind *FhirServiceKind

	// The resource location.
	Location *string

	// Fhir Service configuration.
	Properties *FhirServiceProperties

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

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY; The resource type.
	Type *string
}

FhirService - The description of Fhir Service

func (FhirService) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirService.

func (*FhirService) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirService.

type FhirServiceAcrConfiguration 

type FhirServiceAcrConfiguration struct {
	// The list of the Azure container registry login servers.
	LoginServers []*string

	// The list of Open Container Initiative (OCI) artifacts.
	OciArtifacts []*ServiceOciArtifactEntry
}

FhirServiceAcrConfiguration - Azure container registry configuration information

func (FhirServiceAcrConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceAcrConfiguration.

func (*FhirServiceAcrConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceAcrConfiguration.

type FhirServiceAuthenticationConfiguration 

type FhirServiceAuthenticationConfiguration struct {
	// The audience url for the service
	Audience *string

	// The authority url for the service
	Authority *string

	// The array of identity provider configurations for SMART on FHIR authentication.
	SmartIdentityProviders []*SmartIdentityProviderConfiguration

	// If the SMART on FHIR proxy is enabled
	SmartProxyEnabled *bool
}

FhirServiceAuthenticationConfiguration - Authentication configuration information

func (FhirServiceAuthenticationConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceAuthenticationConfiguration.

func (*FhirServiceAuthenticationConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceAuthenticationConfiguration.

type FhirServiceCollection 

type FhirServiceCollection struct {
	// The link used to get the next page of Fhir Services.
	NextLink *string

	// The list of Fhir Services.
	Value []*FhirService
}

FhirServiceCollection - A collection of Fhir services.

func (FhirServiceCollection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceCollection.

func (*FhirServiceCollection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceCollection.

type FhirServiceCorsConfiguration 

type FhirServiceCorsConfiguration struct {
	// If credentials are allowed via CORS.
	AllowCredentials *bool

	// The headers to be allowed via CORS.
	Headers []*string

	// The max age to be allowed via CORS.
	MaxAge *int32

	// The methods to be allowed via CORS.
	Methods []*string

	// The origins to be allowed via CORS.
	Origins []*string
}

FhirServiceCorsConfiguration - The settings for the CORS configuration of the service instance.

func (FhirServiceCorsConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceCorsConfiguration.

func (*FhirServiceCorsConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceCorsConfiguration.

type FhirServiceExportConfiguration 

type FhirServiceExportConfiguration struct {
	// The name of the default export storage account.
	StorageAccountName *string
}

FhirServiceExportConfiguration - Export operation configuration information

func (FhirServiceExportConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceExportConfiguration.

func (*FhirServiceExportConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceExportConfiguration.

type FhirServiceImportConfiguration 

type FhirServiceImportConfiguration struct {
	// If the import operation is enabled.
	Enabled *bool

	// If the FHIR service is in InitialImportMode.
	InitialImportMode *bool

	// The name of the default integration storage account.
	IntegrationDataStore *string
}

FhirServiceImportConfiguration - Import operation configuration information

func (FhirServiceImportConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceImportConfiguration.

func (*FhirServiceImportConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceImportConfiguration.

type FhirServiceKind 

type FhirServiceKind string

FhirServiceKind - The kind of the service. 

const (
	FhirServiceKindFhirR4   FhirServiceKind = "fhir-R4"
	FhirServiceKindFhirStu3 FhirServiceKind = "fhir-Stu3"
)

func PossibleFhirServiceKindValues 

func PossibleFhirServiceKindValues() []FhirServiceKind

PossibleFhirServiceKindValues returns the possible values for the FhirServiceKind const type.

type FhirServicePatchResource 

type FhirServicePatchResource struct {
	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity

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

FhirServicePatchResource - FhirService patch properties

func (FhirServicePatchResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServicePatchResource.

func (*FhirServicePatchResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServicePatchResource.

type FhirServiceProperties 

type FhirServiceProperties struct {
	// Fhir Service Azure container registry configuration.
	AcrConfiguration *FhirServiceAcrConfiguration

	// Fhir Service authentication configuration.
	AuthenticationConfiguration *FhirServiceAuthenticationConfiguration

	// Fhir Service Cors configuration.
	CorsConfiguration *FhirServiceCorsConfiguration

	// The encryption settings of the FHIR service
	Encryption *Encryption

	// Fhir Service export configuration.
	ExportConfiguration *FhirServiceExportConfiguration

	// Implementation Guides configuration.
	ImplementationGuidesConfiguration *ImplementationGuidesConfiguration

	// Fhir Service import configuration.
	ImportConfiguration *FhirServiceImportConfiguration

	// Control permission for data plane traffic coming from public networks while private endpoint is enabled.
	PublicNetworkAccess *PublicNetworkAccess

	// Determines tracking of history for resources.
	ResourceVersionPolicyConfiguration *ResourceVersionPolicyConfiguration

	// READ-ONLY; Fhir Service event support status.
	EventState *ServiceEventState

	// READ-ONLY; The list of private endpoint connections that are set up for this resource.
	PrivateEndpointConnections []*PrivateEndpointConnection

	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState
}

FhirServiceProperties - Fhir Service properties.

func (FhirServiceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FhirServiceProperties.

func (*FhirServiceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FhirServiceProperties.

type FhirServicesClient 

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

FhirServicesClient contains the methods for the FhirServices group. Don't use this type directly, use NewFhirServicesClient() instead.

func NewFhirServicesClient 

func NewFhirServicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FhirServicesClient, error)

NewFhirServicesClient creates a new instance of FhirServicesClient with the specified values.

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

func (*FhirServicesClient) BeginCreateOrUpdate 

func (client *FhirServicesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, workspaceName string, fhirServiceName string, fhirservice FhirService, options *FhirServicesClientBeginCreateOrUpdateOptions) (*runtime.Poller[FhirServicesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a FHIR Service resource with the specified parameters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • fhirServiceName - The name of FHIR Service resource.
  • fhirservice - The parameters for creating or updating a Fhir Service resource.
  • options - FhirServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the FhirServicesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/fhirservices/FhirServices_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewFhirServicesClient().BeginCreateOrUpdate(ctx, "testRG", "workspace1", "fhirservice1", armhealthcareapis.FhirService{
	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armhealthcareapis.UserAssignedIdentity{
			"/subscriptions/subid/resourcegroups/testRG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-mi": {},
		},
	},
	Location: to.Ptr("westus"),
	Tags: map[string]*string{
		"additionalProp1": to.Ptr("string"),
		"additionalProp2": to.Ptr("string"),
		"additionalProp3": to.Ptr("string"),
	},
	Kind: to.Ptr(armhealthcareapis.FhirServiceKindFhirR4),
	Properties: &armhealthcareapis.FhirServiceProperties{
		AcrConfiguration: &armhealthcareapis.FhirServiceAcrConfiguration{
			LoginServers: []*string{
				to.Ptr("test1.azurecr.io")},
		},
		AuthenticationConfiguration: &armhealthcareapis.FhirServiceAuthenticationConfiguration{
			Audience:  to.Ptr("https://azurehealthcareapis.com"),
			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
			SmartIdentityProviders: []*armhealthcareapis.SmartIdentityProviderConfiguration{
				{
					Applications: []*armhealthcareapis.SmartIdentityProviderApplication{
						{
							AllowedDataActions: []*armhealthcareapis.SmartDataActions{
								to.Ptr(armhealthcareapis.SmartDataActionsRead)},
							Audience: to.Ptr("22222222-2222-2222-2222-222222222222"),
							ClientID: to.Ptr("22222222-2222-2222-2222-222222222222"),
						}},
					Authority: to.Ptr("https://login.b2clogin.com/11111111-1111-1111-1111-111111111111/v2.0"),
				}},
			SmartProxyEnabled: to.Ptr(true),
		},
		CorsConfiguration: &armhealthcareapis.FhirServiceCorsConfiguration{
			AllowCredentials: to.Ptr(false),
			Headers: []*string{
				to.Ptr("*")},
			MaxAge: to.Ptr[int32](1440),
			Methods: []*string{
				to.Ptr("DELETE"),
				to.Ptr("GET"),
				to.Ptr("OPTIONS"),
				to.Ptr("PATCH"),
				to.Ptr("POST"),
				to.Ptr("PUT")},
			Origins: []*string{
				to.Ptr("*")},
		},
		Encryption: &armhealthcareapis.Encryption{
			CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
				KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
			},
		},
		ExportConfiguration: &armhealthcareapis.FhirServiceExportConfiguration{
			StorageAccountName: to.Ptr("existingStorageAccount"),
		},
		ImplementationGuidesConfiguration: &armhealthcareapis.ImplementationGuidesConfiguration{
			UsCoreMissingData: to.Ptr(false),
		},
		ImportConfiguration: &armhealthcareapis.FhirServiceImportConfiguration{
			Enabled:              to.Ptr(false),
			InitialImportMode:    to.Ptr(false),
			IntegrationDataStore: to.Ptr("existingStorageAccount"),
		},
	},
}, 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.FhirService = armhealthcareapis.FhirService{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armhealthcareapis.UserAssignedIdentity{
// 			"/subscriptions/subid/resourcegroups/testRG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-mi": &armhealthcareapis.UserAssignedIdentity{
// 			},
// 		},
// 	},
// 	Name: to.Ptr("fhirservice1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/fhirservices/fhirservice1"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"additionalProp1": to.Ptr("string"),
// 		"additionalProp2": to.Ptr("string"),
// 		"additionalProp3": to.Ptr("string"),
// 	},
// 	Kind: to.Ptr(armhealthcareapis.FhirServiceKindFhirR4),
// 	Properties: &armhealthcareapis.FhirServiceProperties{
// 		AuthenticationConfiguration: &armhealthcareapis.FhirServiceAuthenticationConfiguration{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartIdentityProviders: []*armhealthcareapis.SmartIdentityProviderConfiguration{
// 				{
// 					Applications: []*armhealthcareapis.SmartIdentityProviderApplication{
// 						{
// 							AllowedDataActions: []*armhealthcareapis.SmartDataActions{
// 								to.Ptr(armhealthcareapis.SmartDataActionsRead)},
// 								Audience: to.Ptr("22222222-2222-2222-2222-222222222222"),
// 								ClientID: to.Ptr("22222222-2222-2222-2222-222222222222"),
// 						}},
// 						Authority: to.Ptr("https://login.b2clogin.com/11111111-1111-1111-1111-111111111111/v2.0"),
// 				}},
// 				SmartProxyEnabled: to.Ptr(true),
// 			},
// 			CorsConfiguration: &armhealthcareapis.FhirServiceCorsConfiguration{
// 				AllowCredentials: to.Ptr(false),
// 				Headers: []*string{
// 					to.Ptr("*")},
// 					MaxAge: to.Ptr[int32](1440),
// 					Methods: []*string{
// 						to.Ptr("DELETE"),
// 						to.Ptr("GET"),
// 						to.Ptr("OPTIONS"),
// 						to.Ptr("PATCH"),
// 						to.Ptr("POST"),
// 						to.Ptr("PUT")},
// 						Origins: []*string{
// 							to.Ptr("*")},
// 						},
// 						Encryption: &armhealthcareapis.Encryption{
// 							CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
// 								KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
// 							},
// 						},
// 						EventState: to.Ptr(armhealthcareapis.ServiceEventStateDisabled),
// 						ExportConfiguration: &armhealthcareapis.FhirServiceExportConfiguration{
// 							StorageAccountName: to.Ptr("existingStorageAccount"),
// 						},
// 						ImplementationGuidesConfiguration: &armhealthcareapis.ImplementationGuidesConfiguration{
// 							UsCoreMissingData: to.Ptr(false),
// 						},
// 						ImportConfiguration: &armhealthcareapis.FhirServiceImportConfiguration{
// 							Enabled: to.Ptr(false),
// 							InitialImportMode: to.Ptr(false),
// 							IntegrationDataStore: to.Ptr("existingStorageAccount"),
// 						},
// 						ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					},
// 				}

Output:

func (*FhirServicesClient) BeginDelete 

func (client *FhirServicesClient) BeginDelete(ctx context.Context, resourceGroupName string, fhirServiceName string, workspaceName string, options *FhirServicesClientBeginDeleteOptions) (*runtime.Poller[FhirServicesClientDeleteResponse], error)

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

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • fhirServiceName - The name of FHIR Service resource.
  • workspaceName - The name of workspace resource.
  • options - FhirServicesClientBeginDeleteOptions contains the optional parameters for the FhirServicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/fhirservices/FhirServices_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewFhirServicesClient().BeginDelete(ctx, "testRG", "fhirservice1", "workspace1", 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 (*FhirServicesClient) BeginUpdate 

func (client *FhirServicesClient) BeginUpdate(ctx context.Context, resourceGroupName string, fhirServiceName string, workspaceName string, fhirservicePatchResource FhirServicePatchResource, options *FhirServicesClientBeginUpdateOptions) (*runtime.Poller[FhirServicesClientUpdateResponse], error)

BeginUpdate - Patch FHIR Service details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • fhirServiceName - The name of FHIR Service resource.
  • workspaceName - The name of workspace resource.
  • fhirservicePatchResource - The parameters for updating a Fhir Service.
  • options - FhirServicesClientBeginUpdateOptions contains the optional parameters for the FhirServicesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/fhirservices/FhirServices_Patch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewFhirServicesClient().BeginUpdate(ctx, "testRG", "fhirservice1", "workspace1", armhealthcareapis.FhirServicePatchResource{
	Tags: map[string]*string{
		"tagKey": to.Ptr("tagValue"),
	},
}, 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.FhirService = armhealthcareapis.FhirService{
// 	Name: to.Ptr("fhirservice1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/fhirservices/fhirservice1"),
// 	Tags: map[string]*string{
// 		"tagKey": to.Ptr("tagValue"),
// 	},
// 	Properties: &armhealthcareapis.FhirServiceProperties{
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*FhirServicesClient) Get 

func (client *FhirServicesClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, fhirServiceName string, options *FhirServicesClientGetOptions) (FhirServicesClientGetResponse, error)

Get - Gets the properties of the specified FHIR Service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • fhirServiceName - The name of FHIR Service resource.
  • options - FhirServicesClientGetOptions contains the optional parameters for the FhirServicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/fhirservices/FhirServices_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewFhirServicesClient().Get(ctx, "testRG", "workspace1", "fhirservices1", 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.FhirService = armhealthcareapis.FhirService{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("2f1f372f-edcf-43f5-aedb-173da3cc5c1e"),
// 		TenantID: to.Ptr("abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 	},
// 	Name: to.Ptr("fhirservices1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/fhirservices/fhirservices1"),
// 	Properties: &armhealthcareapis.FhirServiceProperties{
// 		AuthenticationConfiguration: &armhealthcareapis.FhirServiceAuthenticationConfiguration{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartIdentityProviders: []*armhealthcareapis.SmartIdentityProviderConfiguration{
// 				{
// 					Applications: []*armhealthcareapis.SmartIdentityProviderApplication{
// 						{
// 							AllowedDataActions: []*armhealthcareapis.SmartDataActions{
// 								to.Ptr(armhealthcareapis.SmartDataActionsRead)},
// 								Audience: to.Ptr("22222222-2222-2222-2222-222222222222"),
// 								ClientID: to.Ptr("22222222-2222-2222-2222-222222222222"),
// 						}},
// 						Authority: to.Ptr("https://login.b2clogin.com/11111111-1111-1111-1111-111111111111/v2.0"),
// 				}},
// 				SmartProxyEnabled: to.Ptr(true),
// 			},
// 			CorsConfiguration: &armhealthcareapis.FhirServiceCorsConfiguration{
// 				AllowCredentials: to.Ptr(false),
// 				Headers: []*string{
// 					to.Ptr("*")},
// 					MaxAge: to.Ptr[int32](1440),
// 					Methods: []*string{
// 						to.Ptr("DELETE"),
// 						to.Ptr("GET"),
// 						to.Ptr("OPTIONS"),
// 						to.Ptr("PATCH"),
// 						to.Ptr("POST"),
// 						to.Ptr("PUT")},
// 						Origins: []*string{
// 							to.Ptr("*")},
// 						},
// 						Encryption: &armhealthcareapis.Encryption{
// 							CustomerManagedKeyEncryption: &armhealthcareapis.EncryptionCustomerManagedKeyEncryption{
// 								KeyEncryptionKeyURL: to.Ptr("https://mykeyvault.vault.azure.net/keys/myEncryptionKey/myKeyVersion"),
// 							},
// 						},
// 						ExportConfiguration: &armhealthcareapis.FhirServiceExportConfiguration{
// 							StorageAccountName: to.Ptr("existingStorageAccount"),
// 						},
// 						ImplementationGuidesConfiguration: &armhealthcareapis.ImplementationGuidesConfiguration{
// 							UsCoreMissingData: to.Ptr(false),
// 						},
// 						ImportConfiguration: &armhealthcareapis.FhirServiceImportConfiguration{
// 							Enabled: to.Ptr(false),
// 							InitialImportMode: to.Ptr(false),
// 							IntegrationDataStore: to.Ptr("existingStorageAccount"),
// 						},
// 						ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					},
// 				}

Output:

func (*FhirServicesClient) NewListByWorkspacePager 

func (client *FhirServicesClient) NewListByWorkspacePager(resourceGroupName string, workspaceName string, options *FhirServicesClientListByWorkspaceOptions) *runtime.Pager[FhirServicesClientListByWorkspaceResponse]

NewListByWorkspacePager - Lists all FHIR Services for the given workspace

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • options - FhirServicesClientListByWorkspaceOptions contains the optional parameters for the FhirServicesClient.NewListByWorkspacePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/fhirservices/FhirServices_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewFhirServicesClient().NewListByWorkspacePager("testRG", "workspace1", 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.FhirServiceCollection = armhealthcareapis.FhirServiceCollection{
	// 	Value: []*armhealthcareapis.FhirService{
	// 		{
	// 			Name: to.Ptr("fhirservice1"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/fhirservices/fhirservice1"),
	// 			Properties: &armhealthcareapis.FhirServiceProperties{
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("fhirservice2"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/fhirservices/fhirservice2"),
	// 			Properties: &armhealthcareapis.FhirServiceProperties{
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

type FhirServicesClientBeginCreateOrUpdateOptions 

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

FhirServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the FhirServicesClient.BeginCreateOrUpdate method.

type FhirServicesClientBeginDeleteOptions 

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

FhirServicesClientBeginDeleteOptions contains the optional parameters for the FhirServicesClient.BeginDelete method.

type FhirServicesClientBeginUpdateOptions 

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

FhirServicesClientBeginUpdateOptions contains the optional parameters for the FhirServicesClient.BeginUpdate method.

type FhirServicesClientCreateOrUpdateResponse 

type FhirServicesClientCreateOrUpdateResponse struct {
	// The description of Fhir Service
	FhirService
}

FhirServicesClientCreateOrUpdateResponse contains the response from method FhirServicesClient.BeginCreateOrUpdate.

type FhirServicesClientDeleteResponse 

type FhirServicesClientDeleteResponse struct {
}

FhirServicesClientDeleteResponse contains the response from method FhirServicesClient.BeginDelete.

type FhirServicesClientGetOptions 

type FhirServicesClientGetOptions struct {
}

FhirServicesClientGetOptions contains the optional parameters for the FhirServicesClient.Get method.

type FhirServicesClientGetResponse 

type FhirServicesClientGetResponse struct {
	// The description of Fhir Service
	FhirService
}

FhirServicesClientGetResponse contains the response from method FhirServicesClient.Get.

type FhirServicesClientListByWorkspaceOptions 

type FhirServicesClientListByWorkspaceOptions struct {
}

FhirServicesClientListByWorkspaceOptions contains the optional parameters for the FhirServicesClient.NewListByWorkspacePager method.

type FhirServicesClientListByWorkspaceResponse 

type FhirServicesClientListByWorkspaceResponse struct {
	// A collection of Fhir services.
	FhirServiceCollection
}

FhirServicesClientListByWorkspaceResponse contains the response from method FhirServicesClient.NewListByWorkspacePager.

type FhirServicesClientUpdateResponse 

type FhirServicesClientUpdateResponse struct {
	// The description of Fhir Service
	FhirService
}

FhirServicesClientUpdateResponse contains the response from method FhirServicesClient.BeginUpdate.

type ImplementationGuidesConfiguration 

type ImplementationGuidesConfiguration struct {
	// If US Core Missing Data requirement is enabled.
	UsCoreMissingData *bool
}

ImplementationGuidesConfiguration - The settings for Implementation Guides - defining capabilities for national standards, vendor consortiums, clinical societies, etc.

func (ImplementationGuidesConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ImplementationGuidesConfiguration.

func (*ImplementationGuidesConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ImplementationGuidesConfiguration.

type IotConnector 

type IotConnector struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity

	// The resource location.
	Location *string

	// IoT Connector configuration.
	Properties *IotConnectorProperties

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

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY; The resource type.
	Type *string
}

IotConnector - IoT Connector definition.

func (IotConnector) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotConnector.

func (*IotConnector) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotConnector.

type IotConnectorCollection 

type IotConnectorCollection struct {
	// The link used to get the next page of IoT Connectors.
	NextLink *string

	// The list of IoT Connectors.
	Value []*IotConnector
}

IotConnectorCollection - A collection of IoT Connectors.

func (IotConnectorCollection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotConnectorCollection.

func (*IotConnectorCollection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotConnectorCollection.

type IotConnectorFhirDestinationClient 

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

IotConnectorFhirDestinationClient contains the methods for the IotConnectorFhirDestination group. Don't use this type directly, use NewIotConnectorFhirDestinationClient() instead.

func NewIotConnectorFhirDestinationClient 

func NewIotConnectorFhirDestinationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IotConnectorFhirDestinationClient, error)

NewIotConnectorFhirDestinationClient creates a new instance of IotConnectorFhirDestinationClient with the specified values.

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

func (*IotConnectorFhirDestinationClient) BeginCreateOrUpdate 

func (client *IotConnectorFhirDestinationClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, workspaceName string, iotConnectorName string, fhirDestinationName string, iotFhirDestination IotFhirDestination, options *IotConnectorFhirDestinationClientBeginCreateOrUpdateOptions) (*runtime.Poller[IotConnectorFhirDestinationClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an IoT Connector FHIR destination resource with the specified parameters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • iotConnectorName - The name of IoT Connector resource.
  • fhirDestinationName - The name of IoT Connector FHIR destination resource.
  • iotFhirDestination - The parameters for creating or updating an IoT Connector FHIR destination resource.
  • options - IotConnectorFhirDestinationClientBeginCreateOrUpdateOptions contains the optional parameters for the IotConnectorFhirDestinationClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_fhirdestination_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewIotConnectorFhirDestinationClient().BeginCreateOrUpdate(ctx, "testRG", "workspace1", "blue", "dest1", armhealthcareapis.IotFhirDestination{
	Location: to.Ptr("westus"),
	Properties: &armhealthcareapis.IotFhirDestinationProperties{
		FhirMapping: &armhealthcareapis.IotMappingProperties{
			Content: map[string]any{
				"template": []any{
					map[string]any{
						"template": map[string]any{
							"codes": []any{
								map[string]any{
									"code":    "8867-4",
									"display": "Heart rate",
									"system":  "http://loinc.org",
								},
							},
							"periodInterval": float64(60),
							"typeName":       "heartrate",
							"value": map[string]any{
								"defaultPeriod": float64(5000),
								"unit":          "count/min",
								"valueName":     "hr",
								"valueType":     "SampledData",
							},
						},
						"templateType": "CodeValueFhir",
					},
				},
				"templateType": "CollectionFhirTemplate",
			},
		},
		FhirServiceResourceID:          to.Ptr("subscriptions/11111111-2222-3333-4444-555566667777/resourceGroups/myrg/providers/Microsoft.HealthcareApis/workspaces/myworkspace/fhirservices/myfhirservice"),
		ResourceIdentityResolutionType: to.Ptr(armhealthcareapis.IotIdentityResolutionTypeCreate),
	},
}, 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.IotFhirDestination = armhealthcareapis.IotFhirDestination{
// 	Name: to.Ptr("dest1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/fhirdestinations"),
// 	Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue/fhirdestinations/dest1"),
// 	Location: to.Ptr("West US 2"),
// 	Properties: &armhealthcareapis.IotFhirDestinationProperties{
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 		FhirMapping: &armhealthcareapis.IotMappingProperties{
// 			Content: map[string]any{
// 				"template":[]any{
// 					map[string]any{
// 						"template":map[string]any{
// 							"codes":[]any{
// 								map[string]any{
// 									"code": "8867-4",
// 									"display": "Heart rate",
// 									"system": "http://loinc.org",
// 								},
// 							},
// 							"periodInterval": float64(60),
// 							"typeName": "heartrate",
// 							"value":map[string]any{
// 								"defaultPeriod": float64(5000),
// 								"unit": "count/min",
// 								"valueName": "hr",
// 								"valueType": "SampledData",
// 							},
// 						},
// 						"templateType": "CodeValueFhir",
// 					},
// 				},
// 				"templateType": "CollectionFhirTemplate",
// 			},
// 		},
// 		FhirServiceResourceID: to.Ptr("subscriptions/11111111-2222-3333-4444-555566667777/resourceGroups/myrg/providers/Microsoft.HealthcareApis/workspaces/myworkspace/fhirservices/myfhirservice"),
// 		ResourceIdentityResolutionType: to.Ptr(armhealthcareapis.IotIdentityResolutionTypeCreate),
// 	},
// 	SystemData: &armhealthcareapis.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		CreatedBy: to.Ptr("string"),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		LastModifiedBy: to.Ptr("string"),
// 	},
// }

Output:

func (*IotConnectorFhirDestinationClient) BeginDelete 

func (client *IotConnectorFhirDestinationClient) BeginDelete(ctx context.Context, resourceGroupName string, workspaceName string, iotConnectorName string, fhirDestinationName string, options *IotConnectorFhirDestinationClientBeginDeleteOptions) (*runtime.Poller[IotConnectorFhirDestinationClientDeleteResponse], error)

BeginDelete - Deletes an IoT Connector FHIR destination. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • iotConnectorName - The name of IoT Connector resource.
  • fhirDestinationName - The name of IoT Connector FHIR destination resource.
  • options - IotConnectorFhirDestinationClientBeginDeleteOptions contains the optional parameters for the IotConnectorFhirDestinationClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_fhirdestination_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewIotConnectorFhirDestinationClient().BeginDelete(ctx, "testRG", "workspace1", "blue", "dest1", 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 (*IotConnectorFhirDestinationClient) Get 

func (client *IotConnectorFhirDestinationClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, iotConnectorName string, fhirDestinationName string, options *IotConnectorFhirDestinationClientGetOptions) (IotConnectorFhirDestinationClientGetResponse, error)

Get - Gets the properties of the specified Iot Connector FHIR destination. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • iotConnectorName - The name of IoT Connector resource.
  • fhirDestinationName - The name of IoT Connector FHIR destination resource.
  • options - IotConnectorFhirDestinationClientGetOptions contains the optional parameters for the IotConnectorFhirDestinationClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_fhirdestination_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewIotConnectorFhirDestinationClient().Get(ctx, "testRG", "workspace1", "blue", "dest1", 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.IotFhirDestination = armhealthcareapis.IotFhirDestination{
// 	Name: to.Ptr("dest1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/fhirdestinations"),
// 	Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue/fhirdestinations/dest1"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armhealthcareapis.IotFhirDestinationProperties{
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 		FhirMapping: &armhealthcareapis.IotMappingProperties{
// 			Content: map[string]any{
// 				"template":[]any{
// 					map[string]any{
// 						"template":map[string]any{
// 							"codes":[]any{
// 								map[string]any{
// 									"code": "8867-4",
// 									"display": "Heart rate",
// 									"system": "http://loinc.org",
// 								},
// 							},
// 							"periodInterval": float64(60),
// 							"typeName": "heartrate",
// 							"value":map[string]any{
// 								"defaultPeriod": float64(5000),
// 								"unit": "count/min",
// 								"valueName": "hr",
// 								"valueType": "SampledData",
// 							},
// 						},
// 						"templateType": "CodeValueFhir",
// 					},
// 				},
// 				"templateType": "CollectionFhirTemplate",
// 			},
// 		},
// 		FhirServiceResourceID: to.Ptr("subscriptions/11111111-2222-3333-4444-555566667777/resourceGroups/myrg/providers/Microsoft.HealthcareApis/workspaces/myworkspace/fhirservices/myfhirservice"),
// 		ResourceIdentityResolutionType: to.Ptr(armhealthcareapis.IotIdentityResolutionTypeCreate),
// 	},
// 	SystemData: &armhealthcareapis.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		CreatedBy: to.Ptr("string"),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		LastModifiedBy: to.Ptr("string"),
// 	},
// }

Output:

type IotConnectorFhirDestinationClientBeginCreateOrUpdateOptions 

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

IotConnectorFhirDestinationClientBeginCreateOrUpdateOptions contains the optional parameters for the IotConnectorFhirDestinationClient.BeginCreateOrUpdate method.

type IotConnectorFhirDestinationClientBeginDeleteOptions 

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

IotConnectorFhirDestinationClientBeginDeleteOptions contains the optional parameters for the IotConnectorFhirDestinationClient.BeginDelete method.

type IotConnectorFhirDestinationClientCreateOrUpdateResponse 

type IotConnectorFhirDestinationClientCreateOrUpdateResponse struct {
	// IoT Connector FHIR destination definition.
	IotFhirDestination
}

IotConnectorFhirDestinationClientCreateOrUpdateResponse contains the response from method IotConnectorFhirDestinationClient.BeginCreateOrUpdate.

type IotConnectorFhirDestinationClientDeleteResponse 

type IotConnectorFhirDestinationClientDeleteResponse struct {
}

IotConnectorFhirDestinationClientDeleteResponse contains the response from method IotConnectorFhirDestinationClient.BeginDelete.

type IotConnectorFhirDestinationClientGetOptions 

type IotConnectorFhirDestinationClientGetOptions struct {
}

IotConnectorFhirDestinationClientGetOptions contains the optional parameters for the IotConnectorFhirDestinationClient.Get method.

type IotConnectorFhirDestinationClientGetResponse 

type IotConnectorFhirDestinationClientGetResponse struct {
	// IoT Connector FHIR destination definition.
	IotFhirDestination
}

IotConnectorFhirDestinationClientGetResponse contains the response from method IotConnectorFhirDestinationClient.Get.

type IotConnectorPatchResource 

type IotConnectorPatchResource struct {
	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity

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

IotConnectorPatchResource - Iot Connector patch properties

func (IotConnectorPatchResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotConnectorPatchResource.

func (*IotConnectorPatchResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotConnectorPatchResource.

type IotConnectorProperties 

type IotConnectorProperties struct {
	// Device Mappings.
	DeviceMapping *IotMappingProperties

	// Source configuration.
	IngestionEndpointConfiguration *IotEventHubIngestionEndpointConfiguration

	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState
}

IotConnectorProperties - IoT Connector properties.

func (IotConnectorProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotConnectorProperties.

func (*IotConnectorProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotConnectorProperties.

type IotConnectorsClient 

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

IotConnectorsClient contains the methods for the IotConnectors group. Don't use this type directly, use NewIotConnectorsClient() instead.

func NewIotConnectorsClient 

func NewIotConnectorsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IotConnectorsClient, error)

NewIotConnectorsClient creates a new instance of IotConnectorsClient with the specified values.

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

func (*IotConnectorsClient) BeginCreateOrUpdate 

func (client *IotConnectorsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, workspaceName string, iotConnectorName string, iotConnector IotConnector, options *IotConnectorsClientBeginCreateOrUpdateOptions) (*runtime.Poller[IotConnectorsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an IoT Connector resource with the specified parameters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • iotConnectorName - The name of IoT Connector resource.
  • iotConnector - The parameters for creating or updating an IoT Connectors resource.
  • options - IotConnectorsClientBeginCreateOrUpdateOptions contains the optional parameters for the IotConnectorsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewIotConnectorsClient().BeginCreateOrUpdate(ctx, "testRG", "workspace1", "blue", armhealthcareapis.IotConnector{
	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
	},
	Location: to.Ptr("westus"),
	Tags: map[string]*string{
		"additionalProp1": to.Ptr("string"),
		"additionalProp2": to.Ptr("string"),
		"additionalProp3": to.Ptr("string"),
	},
	Properties: &armhealthcareapis.IotConnectorProperties{
		DeviceMapping: &armhealthcareapis.IotMappingProperties{
			Content: map[string]any{
				"template": []any{
					map[string]any{
						"template": map[string]any{
							"deviceIdExpression":  "$.deviceid",
							"timestampExpression": "$.measurementdatetime",
							"typeMatchExpression": "$..[?(@heartrate)]",
							"typeName":            "heartrate",
							"values": []any{
								map[string]any{
									"required":        "true",
									"valueExpression": "$.heartrate",
									"valueName":       "hr",
								},
							},
						},
						"templateType": "JsonPathContent",
					},
				},
				"templateType": "CollectionContent",
			},
		},
		IngestionEndpointConfiguration: &armhealthcareapis.IotEventHubIngestionEndpointConfiguration{
			ConsumerGroup:                   to.Ptr("ConsumerGroupA"),
			EventHubName:                    to.Ptr("MyEventHubName"),
			FullyQualifiedEventHubNamespace: to.Ptr("myeventhub.servicesbus.windows.net"),
		},
	},
}, 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.IotConnector = armhealthcareapis.IotConnector{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
// 	},
// 	Name: to.Ptr("blue"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors"),
// 	Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"additionalProp1": to.Ptr("string"),
// 		"additionalProp2": to.Ptr("string"),
// 		"additionalProp3": to.Ptr("string"),
// 	},
// 	Properties: &armhealthcareapis.IotConnectorProperties{
// 		DeviceMapping: &armhealthcareapis.IotMappingProperties{
// 			Content: map[string]any{
// 				"template":[]any{
// 					map[string]any{
// 						"template":map[string]any{
// 							"deviceIdExpression": "$.deviceid",
// 							"timestampExpression": "$.measurementdatetime",
// 							"typeMatchExpression": "$..[?(@heartrate)]",
// 							"typeName": "heartrate",
// 							"values":[]any{
// 								map[string]any{
// 									"required": "true",
// 									"valueExpression": "$.heartrate",
// 									"valueName": "hr",
// 								},
// 							},
// 						},
// 						"templateType": "JsonPathContent",
// 					},
// 				},
// 				"templateType": "CollectionContent",
// 			},
// 		},
// 		IngestionEndpointConfiguration: &armhealthcareapis.IotEventHubIngestionEndpointConfiguration{
// 			ConsumerGroup: to.Ptr("ConsumerGroupA"),
// 			EventHubName: to.Ptr("MyEventHubName"),
// 			FullyQualifiedEventHubNamespace: to.Ptr("myeventhub.servicesbus.windows.net"),
// 		},
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// 	SystemData: &armhealthcareapis.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		CreatedBy: to.Ptr("string"),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		LastModifiedBy: to.Ptr("string"),
// 	},
// }

Output:

func (*IotConnectorsClient) BeginDelete 

func (client *IotConnectorsClient) BeginDelete(ctx context.Context, resourceGroupName string, iotConnectorName string, workspaceName string, options *IotConnectorsClientBeginDeleteOptions) (*runtime.Poller[IotConnectorsClientDeleteResponse], error)

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

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • iotConnectorName - The name of IoT Connector resource.
  • workspaceName - The name of workspace resource.
  • options - IotConnectorsClientBeginDeleteOptions contains the optional parameters for the IotConnectorsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewIotConnectorsClient().BeginDelete(ctx, "testRG", "blue", "workspace1", 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 (*IotConnectorsClient) BeginUpdate 

func (client *IotConnectorsClient) BeginUpdate(ctx context.Context, resourceGroupName string, iotConnectorName string, workspaceName string, iotConnectorPatchResource IotConnectorPatchResource, options *IotConnectorsClientBeginUpdateOptions) (*runtime.Poller[IotConnectorsClientUpdateResponse], error)

BeginUpdate - Patch an IoT Connector. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • iotConnectorName - The name of IoT Connector resource.
  • workspaceName - The name of workspace resource.
  • iotConnectorPatchResource - The parameters for updating an IoT Connector.
  • options - IotConnectorsClientBeginUpdateOptions contains the optional parameters for the IotConnectorsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_Patch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewIotConnectorsClient().BeginUpdate(ctx, "testRG", "blue", "workspace1", armhealthcareapis.IotConnectorPatchResource{
	Tags: map[string]*string{
		"additionalProp1": to.Ptr("string"),
		"additionalProp2": to.Ptr("string"),
		"additionalProp3": to.Ptr("string"),
	},
	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
	},
}, 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.IotConnector = armhealthcareapis.IotConnector{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
// 	},
// 	Name: to.Ptr("blue"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors"),
// 	Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"additionalProp1": to.Ptr("string"),
// 		"additionalProp2": to.Ptr("string"),
// 		"additionalProp3": to.Ptr("string"),
// 	},
// 	Properties: &armhealthcareapis.IotConnectorProperties{
// 		DeviceMapping: &armhealthcareapis.IotMappingProperties{
// 			Content: map[string]any{
// 				"template":[]any{
// 					map[string]any{
// 						"template":map[string]any{
// 							"deviceIdExpression": "$.deviceid",
// 							"timestampExpression": "$.measurementdatetime",
// 							"typeMatchExpression": "$..[?(@heartrate)]",
// 							"typeName": "heartrate",
// 							"values":[]any{
// 								map[string]any{
// 									"required": "true",
// 									"valueExpression": "$.heartrate",
// 									"valueName": "hr",
// 								},
// 							},
// 						},
// 						"templateType": "JsonPathContent",
// 					},
// 				},
// 				"templateType": "CollectionContent",
// 			},
// 		},
// 		IngestionEndpointConfiguration: &armhealthcareapis.IotEventHubIngestionEndpointConfiguration{
// 			ConsumerGroup: to.Ptr("ConsumerGroupA"),
// 			EventHubName: to.Ptr("MyEventHubName"),
// 			FullyQualifiedEventHubNamespace: to.Ptr("myeventhub.servicesbus.windows.net"),
// 		},
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// 	SystemData: &armhealthcareapis.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		CreatedBy: to.Ptr("string"),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		LastModifiedBy: to.Ptr("string"),
// 	},
// }

Output:

func (*IotConnectorsClient) Get 

func (client *IotConnectorsClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, iotConnectorName string, options *IotConnectorsClientGetOptions) (IotConnectorsClientGetResponse, error)

Get - Gets the properties of the specified IoT Connector. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • iotConnectorName - The name of IoT Connector resource.
  • options - IotConnectorsClientGetOptions contains the optional parameters for the IotConnectorsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewIotConnectorsClient().Get(ctx, "testRG", "workspace1", "blue", 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.IotConnector = armhealthcareapis.IotConnector{
// 	Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
// 		Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
// 	},
// 	Name: to.Ptr("blue"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors"),
// 	Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"additionalProp1": to.Ptr("string"),
// 		"additionalProp2": to.Ptr("string"),
// 		"additionalProp3": to.Ptr("string"),
// 	},
// 	Properties: &armhealthcareapis.IotConnectorProperties{
// 		DeviceMapping: &armhealthcareapis.IotMappingProperties{
// 			Content: map[string]any{
// 				"template":[]any{
// 					map[string]any{
// 						"template":map[string]any{
// 							"deviceIdExpression": "$.deviceid",
// 							"timestampExpression": "$.measurementdatetime",
// 							"typeMatchExpression": "$..[?(@heartrate)]",
// 							"typeName": "heartrate",
// 							"values":[]any{
// 								map[string]any{
// 									"required": "true",
// 									"valueExpression": "$.heartrate",
// 									"valueName": "hr",
// 								},
// 							},
// 						},
// 						"templateType": "JsonPathContent",
// 					},
// 				},
// 				"templateType": "CollectionContent",
// 			},
// 		},
// 		IngestionEndpointConfiguration: &armhealthcareapis.IotEventHubIngestionEndpointConfiguration{
// 			ConsumerGroup: to.Ptr("ConsumerGroupA"),
// 			EventHubName: to.Ptr("MyEventHubName"),
// 			FullyQualifiedEventHubNamespace: to.Ptr("myeventhub.servicesbus.windows.net"),
// 		},
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// 	SystemData: &armhealthcareapis.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		CreatedBy: to.Ptr("string"),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
// 		LastModifiedBy: to.Ptr("string"),
// 	},
// }

Output:

func (*IotConnectorsClient) NewListByWorkspacePager 

func (client *IotConnectorsClient) NewListByWorkspacePager(resourceGroupName string, workspaceName string, options *IotConnectorsClientListByWorkspaceOptions) *runtime.Pager[IotConnectorsClientListByWorkspaceResponse]

NewListByWorkspacePager - Lists all IoT Connectors for the given workspace

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • options - IotConnectorsClientListByWorkspaceOptions contains the optional parameters for the IotConnectorsClient.NewListByWorkspacePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/iotconnectors/iotconnector_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewIotConnectorsClient().NewListByWorkspacePager("testRG", "workspace1", 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.IotConnectorCollection = armhealthcareapis.IotConnectorCollection{
	// 	Value: []*armhealthcareapis.IotConnector{
	// 		{
	// 			Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
	// 				Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
	// 			},
	// 			Name: to.Ptr("blue"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors"),
	// 			Etag: to.Ptr("00000000-0000-0000-f5ac-912ca49e01d6"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/blue"),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"additionalProp1": to.Ptr("string"),
	// 				"additionalProp2": to.Ptr("string"),
	// 				"additionalProp3": to.Ptr("string"),
	// 			},
	// 			Properties: &armhealthcareapis.IotConnectorProperties{
	// 				DeviceMapping: &armhealthcareapis.IotMappingProperties{
	// 					Content: map[string]any{
	// 						"template":[]any{
	// 							map[string]any{
	// 								"template":map[string]any{
	// 									"deviceIdExpression": "$.deviceid",
	// 									"timestampExpression": "$.measurementdatetime",
	// 									"typeMatchExpression": "$..[?(@heartrate)]",
	// 									"typeName": "heartrate",
	// 									"values":[]any{
	// 										map[string]any{
	// 											"required": "true",
	// 											"valueExpression": "$.heartrate",
	// 											"valueName": "hr",
	// 										},
	// 									},
	// 								},
	// 								"templateType": "JsonPathContent",
	// 							},
	// 						},
	// 						"templateType": "CollectionContent",
	// 					},
	// 				},
	// 				IngestionEndpointConfiguration: &armhealthcareapis.IotEventHubIngestionEndpointConfiguration{
	// 					ConsumerGroup: to.Ptr("ConsumerGroupA"),
	// 					EventHubName: to.Ptr("MyEventHubName"),
	// 					FullyQualifiedEventHubNamespace: to.Ptr("myeventhub.servicesbus.windows.net"),
	// 				},
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 			},
	// 			SystemData: &armhealthcareapis.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
	// 				CreatedBy: to.Ptr("string"),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-28T19:26:24.072Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("string"),
	// 			},
	// 		},
	// 		{
	// 			Identity: &armhealthcareapis.ServiceManagedIdentityIdentity{
	// 				Type: to.Ptr(armhealthcareapis.ServiceManagedIdentityTypeSystemAssigned),
	// 			},
	// 			Name: to.Ptr("red"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors"),
	// 			Etag: to.Ptr("00000000-0000-0000-f6ac-912ca49e01d6"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1/iotconnectors/red"),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"additionalProp1": to.Ptr("string"),
	// 				"additionalProp2": to.Ptr("string"),
	// 				"additionalProp3": to.Ptr("string"),
	// 			},
	// 			Properties: &armhealthcareapis.IotConnectorProperties{
	// 				DeviceMapping: &armhealthcareapis.IotMappingProperties{
	// 					Content: map[string]any{
	// 						"template":[]any{
	// 							map[string]any{
	// 								"template":map[string]any{
	// 									"deviceIdExpression": "$.deviceid",
	// 									"timestampExpression": "$.measurementdatetime",
	// 									"typeMatchExpression": "$..[?(@steps)]",
	// 									"typeName": "steps",
	// 									"values":[]any{
	// 										map[string]any{
	// 											"required": "true",
	// 											"valueExpression": "$.steps",
	// 											"valueName": "steps",
	// 										},
	// 									},
	// 								},
	// 								"templateType": "JsonPathContent",
	// 							},
	// 						},
	// 						"templateType": "CollectionContent",
	// 					},
	// 				},
	// 				IngestionEndpointConfiguration: &armhealthcareapis.IotEventHubIngestionEndpointConfiguration{
	// 					ConsumerGroup: to.Ptr("ConsumerGroupA"),
	// 					EventHubName: to.Ptr("MyEventHubName"),
	// 					FullyQualifiedEventHubNamespace: to.Ptr("myeventhub.servicesbus.windows.net"),
	// 				},
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 			},
	// 			SystemData: &armhealthcareapis.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-27T19:26:24.072Z"); return t}()),
	// 				CreatedBy: to.Ptr("string"),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-01-27T19:26:24.072Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("string"),
	// 			},
	// 	}},
	// }
}

Output:

type IotConnectorsClientBeginCreateOrUpdateOptions 

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

IotConnectorsClientBeginCreateOrUpdateOptions contains the optional parameters for the IotConnectorsClient.BeginCreateOrUpdate method.

type IotConnectorsClientBeginDeleteOptions 

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

IotConnectorsClientBeginDeleteOptions contains the optional parameters for the IotConnectorsClient.BeginDelete method.

type IotConnectorsClientBeginUpdateOptions 

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

IotConnectorsClientBeginUpdateOptions contains the optional parameters for the IotConnectorsClient.BeginUpdate method.

type IotConnectorsClientCreateOrUpdateResponse 

type IotConnectorsClientCreateOrUpdateResponse struct {
	// IoT Connector definition.
	IotConnector
}

IotConnectorsClientCreateOrUpdateResponse contains the response from method IotConnectorsClient.BeginCreateOrUpdate.

type IotConnectorsClientDeleteResponse 

type IotConnectorsClientDeleteResponse struct {
}

IotConnectorsClientDeleteResponse contains the response from method IotConnectorsClient.BeginDelete.

type IotConnectorsClientGetOptions 

type IotConnectorsClientGetOptions struct {
}

IotConnectorsClientGetOptions contains the optional parameters for the IotConnectorsClient.Get method.

type IotConnectorsClientGetResponse 

type IotConnectorsClientGetResponse struct {
	// IoT Connector definition.
	IotConnector
}

IotConnectorsClientGetResponse contains the response from method IotConnectorsClient.Get.

type IotConnectorsClientListByWorkspaceOptions 

type IotConnectorsClientListByWorkspaceOptions struct {
}

IotConnectorsClientListByWorkspaceOptions contains the optional parameters for the IotConnectorsClient.NewListByWorkspacePager method.

type IotConnectorsClientListByWorkspaceResponse 

type IotConnectorsClientListByWorkspaceResponse struct {
	// A collection of IoT Connectors.
	IotConnectorCollection
}

IotConnectorsClientListByWorkspaceResponse contains the response from method IotConnectorsClient.NewListByWorkspacePager.

type IotConnectorsClientUpdateResponse 

type IotConnectorsClientUpdateResponse struct {
	// IoT Connector definition.
	IotConnector
}

IotConnectorsClientUpdateResponse contains the response from method IotConnectorsClient.BeginUpdate.

type IotDestinationProperties 

type IotDestinationProperties struct {
	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState
}

IotDestinationProperties - Common IoT Connector destination properties.

func (IotDestinationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotDestinationProperties.

func (*IotDestinationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotDestinationProperties.

type IotEventHubIngestionEndpointConfiguration 

type IotEventHubIngestionEndpointConfiguration struct {
	// Consumer group of the event hub to connected to.
	ConsumerGroup *string

	// Event Hub name to connect to.
	EventHubName *string

	// Fully qualified namespace of the Event Hub to connect to.
	FullyQualifiedEventHubNamespace *string
}

IotEventHubIngestionEndpointConfiguration - Event Hub ingestion endpoint configuration

func (IotEventHubIngestionEndpointConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotEventHubIngestionEndpointConfiguration.

func (*IotEventHubIngestionEndpointConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotEventHubIngestionEndpointConfiguration.

type IotFhirDestination 

type IotFhirDestination struct {
	// REQUIRED; IoT FHIR Destination settings.
	Properties *IotFhirDestinationProperties

	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// The resource location.
	Location *string

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY; The resource type.
	Type *string
}

IotFhirDestination - IoT Connector FHIR destination definition.

func (IotFhirDestination) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotFhirDestination.

func (*IotFhirDestination) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotFhirDestination.

type IotFhirDestinationCollection 

type IotFhirDestinationCollection struct {
	// The link used to get the next page of IoT FHIR destinations.
	NextLink *string

	// The list of IoT Connector FHIR destinations.
	Value []*IotFhirDestination
}

IotFhirDestinationCollection - A collection of IoT Connector FHIR destinations.

func (IotFhirDestinationCollection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotFhirDestinationCollection.

func (*IotFhirDestinationCollection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotFhirDestinationCollection.

type IotFhirDestinationProperties 

type IotFhirDestinationProperties struct {
	// REQUIRED; FHIR Mappings
	FhirMapping *IotMappingProperties

	// REQUIRED; Fully qualified resource id of the FHIR service to connect to.
	FhirServiceResourceID *string

	// REQUIRED; Determines how resource identity is resolved on the destination.
	ResourceIdentityResolutionType *IotIdentityResolutionType

	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState
}

IotFhirDestinationProperties - IoT Connector destination properties for an Azure FHIR service.

func (IotFhirDestinationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotFhirDestinationProperties.

func (*IotFhirDestinationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotFhirDestinationProperties.

type IotIdentityResolutionType 

type IotIdentityResolutionType string

IotIdentityResolutionType - The type of IoT identity resolution to use with the destination. 

const (
	IotIdentityResolutionTypeCreate IotIdentityResolutionType = "Create"
	IotIdentityResolutionTypeLookup IotIdentityResolutionType = "Lookup"
)

func PossibleIotIdentityResolutionTypeValues 

func PossibleIotIdentityResolutionTypeValues() []IotIdentityResolutionType

PossibleIotIdentityResolutionTypeValues returns the possible values for the IotIdentityResolutionType const type.

type IotMappingProperties 

type IotMappingProperties struct {
	// The mapping.
	Content any
}

IotMappingProperties - The mapping content.

func (IotMappingProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotMappingProperties.

func (*IotMappingProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotMappingProperties.

type Kind 

type Kind string

Kind - The kind of the service. 

const (
	KindFhir     Kind = "fhir"
	KindFhirR4   Kind = "fhir-R4"
	KindFhirStu3 Kind = "fhir-Stu3"
)

func PossibleKindValues 

func PossibleKindValues() []Kind

PossibleKindValues returns the possible values for the Kind const type.

type ListOperations 

type ListOperations struct {
	// URL client should use to fetch the next page (per server side paging). It's null for now, added for future use.
	NextLink *string

	// READ-ONLY; Collection of available operation details
	Value []*OperationDetail
}

ListOperations - Available operations of the service

func (ListOperations) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ListOperations.

func (*ListOperations) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListOperations.

type LocationBasedResource 

type LocationBasedResource struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// The resource location.
	Location *string

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

LocationBasedResource - The common properties for any location based resource, tracked or proxy.

func (LocationBasedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LocationBasedResource.

func (*LocationBasedResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LocationBasedResource.

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 ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of identity being specified, currently SystemAssigned and None are allowed. 

const (
	ManagedServiceIdentityTypeNone           ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type MetricDimension 

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

	// Name of the dimension
	Name *string

	// Whether this dimension should be included for the Shoebox export scenario
	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

	// Name of the metric category that the metric belongs to. A metric can only belong to a single 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

	// Whether regional MDM account enabled.
	EnableRegionalMdmAccount *bool

	// Optional. If set to true, then zero will be returned for time duration where no metric is emitted/published.
	FillGapWithZero *bool

	// Whether the metric is internal.
	IsInternal *bool

	// Pattern for the filter of the metric.
	MetricFilterPattern *string

	// Name of the metric
	Name *string

	// The resource Id dimension name override.
	ResourceIDDimensionNameOverride *string

	// The source MDM account.
	SourceMdmAccount *string

	// The source MDM namespace.
	SourceMdmNamespace *string

	// Supported aggregation types
	SupportedAggregationTypes []*string

	// Supported time grain types
	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 OperationDetail 

type OperationDetail struct {
	// Display of the operation
	Display *OperationDisplay

	// Properties of the operation
	Properties *OperationProperties

	// READ-ONLY; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
	// operations.
	IsDataAction *bool

	// READ-ONLY; Name of the operation
	Name *string

	// READ-ONLY; Default value is 'user,system'.
	Origin *string
}

OperationDetail - Service REST API operation.

func (OperationDetail) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDetail.

func (*OperationDetail) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDetail.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; Friendly description for the operation,
	Description *string

	// READ-ONLY; Name of the operation
	Operation *string

	// READ-ONLY; Service provider: Microsoft.HealthcareApis
	Provider *string

	// READ-ONLY; Resource Type: Services
	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 OperationProperties 

type OperationProperties struct {
	// Service specifications of the operation
	ServiceSpecification *ServiceSpecification
}

OperationProperties - Extra 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 OperationResultStatus 

type OperationResultStatus string

OperationResultStatus - The status of the operation being performed. 

const (
	OperationResultStatusCanceled  OperationResultStatus = "Canceled"
	OperationResultStatusFailed    OperationResultStatus = "Failed"
	OperationResultStatusRequested OperationResultStatus = "Requested"
	OperationResultStatusRunning   OperationResultStatus = "Running"
	OperationResultStatusSucceeded OperationResultStatus = "Succeeded"
)

func PossibleOperationResultStatusValues 

func PossibleOperationResultStatusValues() []OperationResultStatus

PossibleOperationResultStatusValues returns the possible values for the OperationResultStatus const type.

type OperationResultsClient 

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

OperationResultsClient contains the methods for the OperationResults group. Don't use this type directly, use NewOperationResultsClient() instead.

func NewOperationResultsClient 

func NewOperationResultsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationResultsClient, error)

NewOperationResultsClient creates a new instance of OperationResultsClient with the specified values.

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

func (*OperationResultsClient) Get 

func (client *OperationResultsClient) Get(ctx context.Context, locationName string, operationResultID string, options *OperationResultsClientGetOptions) (OperationResultsClientGetResponse, error)

Get - Get the operation result for a long running operation. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • locationName - The location of the operation.
  • operationResultID - The ID of the operation result to get.
  • options - OperationResultsClientGetOptions contains the optional parameters for the OperationResultsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/OperationResultsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewOperationResultsClient().Get(ctx, "westus", "exampleid", 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.OperationResultsDescription = armhealthcareapis.OperationResultsDescription{
// 	Name: to.Ptr("servicename"),
// 	EndTime: to.Ptr("2019-01-21T06:04:12.3413202Z"),
// 	ID: to.Ptr("/subscriptions/subid/providers/Microsoft.HealthcareApis/locations/westus/operationresults/exampleid"),
// 	Properties: map[string]any{
// 	},
// 	StartTime: to.Ptr("2019-01-21T06:03:30.2716301Z"),
// 	Status: to.Ptr(armhealthcareapis.OperationResultStatusRequested),
// }

Output:

type OperationResultsClientGetOptions 

type OperationResultsClientGetOptions struct {
}

OperationResultsClientGetOptions contains the optional parameters for the OperationResultsClient.Get method.

type OperationResultsClientGetResponse 

type OperationResultsClientGetResponse struct {
	// The properties indicating the operation result of an operation on a service.
	OperationResultsDescription
}

OperationResultsClientGetResponse contains the response from method OperationResultsClient.Get.

type OperationResultsDescription 

type OperationResultsDescription struct {
	// Additional properties of the operation result.
	Properties any

	// READ-ONLY; The time that the operation finished.
	EndTime *string

	// READ-ONLY; The ID of the operation returned.
	ID *string

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

	// READ-ONLY; The time that the operation was started.
	StartTime *string

	// READ-ONLY; The status of the operation being performed.
	Status *OperationResultStatus
}

OperationResultsDescription - The properties indicating the operation result of an operation on a service.

func (OperationResultsDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationResultsDescription.

func (*OperationResultsDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationResultsDescription.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager 

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

NewListPager - Lists all of the available operations supported by Microsoft Healthcare resource provider.

Generated from API version 2024-03-31

  • 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/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/OperationsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.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.ListOperations = armhealthcareapis.ListOperations{
	// 	Value: []*armhealthcareapis.OperationDetail{
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/services/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/services/write"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/services/delete"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/locations/operationresults/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 				Description: to.Ptr("Get the status of an asynchronous operation"),
	// 				Operation: to.Ptr("read"),
	// 				Provider: to.Ptr("Microsoft.HealthcareApis"),
	// 				Resource: to.Ptr("operationresults"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/write"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/delete"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices/write"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/dicomservices/delete"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/write"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/iotconnectors/delete"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices/write"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/workspaces/fhirservices/delete"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/checkNameAvailability/post"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 			},
	// 			Origin: to.Ptr("user"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.HealthcareApis/Operations/read"),
	// 			Display: &armhealthcareapis.OperationDisplay{
	// 				Description: to.Ptr("Get the list of operations supported by this Resource Provider."),
	// 				Operation: to.Ptr("read"),
	// 				Provider: to.Ptr("Microsoft.HealthcareApis"),
	// 				Resource: to.Ptr("operations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Available operations of the service
	ListOperations
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// READ-ONLY; The ARM identifier for Private Endpoint
	ID *string
}

PrivateEndpoint - The Private Endpoint resource.

func (PrivateEndpoint) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpoint.

func (*PrivateEndpoint) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpoint.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// Resource properties.
	Properties *PrivateEndpointConnectionProperties

	// 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
}

PrivateEndpointConnection - The Private Endpoint Connection resource.

func (PrivateEndpointConnection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnection.

func (*PrivateEndpointConnection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnection.

type PrivateEndpointConnectionDescription 

type PrivateEndpointConnectionDescription struct {
	// Resource properties.
	Properties *PrivateEndpointConnectionProperties

	// 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; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

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

PrivateEndpointConnectionDescription - The Private Endpoint Connection resource.

func (PrivateEndpointConnectionDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionDescription.

func (*PrivateEndpointConnectionDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionDescription.

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult struct {
	// Array of private endpoint connections
	Value []*PrivateEndpointConnection
}

PrivateEndpointConnectionListResult - List of private endpoint connection associated with the specified storage account

func (PrivateEndpointConnectionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionListResult.

func (*PrivateEndpointConnectionListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionListResult.

type PrivateEndpointConnectionListResultDescription 

type PrivateEndpointConnectionListResultDescription struct {
	// Array of private endpoint connections
	Value []*PrivateEndpointConnectionDescription
}

PrivateEndpointConnectionListResultDescription - List of private endpoint connection associated with the specified storage account

func (PrivateEndpointConnectionListResultDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionListResultDescription.

func (*PrivateEndpointConnectionListResultDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionListResultDescription.

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState

	// The resource of private end point.
	PrivateEndpoint *PrivateEndpoint

	// READ-ONLY; The provisioning state of the private endpoint connection resource.
	ProvisioningState *PrivateEndpointConnectionProvisioningState
}

PrivateEndpointConnectionProperties - Properties of the PrivateEndpointConnectProperties.

func (PrivateEndpointConnectionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionProperties.

func (*PrivateEndpointConnectionProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionProperties.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionsClient 

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

PrivateEndpointConnectionsClient contains the methods for the PrivateEndpointConnections group. Don't use this type directly, use NewPrivateEndpointConnectionsClient() instead.

func NewPrivateEndpointConnectionsClient 

func NewPrivateEndpointConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateEndpointConnectionsClient, error)

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient with the specified values.

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

func (*PrivateEndpointConnectionsClient) BeginCreateOrUpdate 

func (client *PrivateEndpointConnectionsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, properties PrivateEndpointConnection, options *PrivateEndpointConnectionsClientBeginCreateOrUpdateOptions) (*runtime.Poller[PrivateEndpointConnectionsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Update the state of the specified private endpoint connection associated with the service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • properties - The private endpoint connection properties.
  • options - PrivateEndpointConnectionsClientBeginCreateOrUpdateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceCreatePrivateEndpointConnection.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginCreateOrUpdate(ctx, "rgname", "service1", "myConnection", armhealthcareapis.PrivateEndpointConnection{
	Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
		PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
			Description: to.Ptr("Auto-Approved"),
			Status:      to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
		},
	},
}, 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.PrivateEndpointConnectionDescription = armhealthcareapis.PrivateEndpointConnectionDescription{
// 	Name: to.Ptr("myConnection"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1/privateEndpointConnections/myConnection"),
// 	Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
// 		PrivateEndpoint: &armhealthcareapis.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/c80fb759-c965-4c6a-9110-9b2b2d038882/resourceGroups/myResourceGroup/providers/Microsoft.Network/privateEndpoints/peexample01"),
// 		},
// 		PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
// 			Description: to.Ptr("Auto-Approved"),
// 			ActionsRequired: to.Ptr("None"),
// 			Status: to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
// 		},
// 		ProvisioningState: to.Ptr(armhealthcareapis.PrivateEndpointConnectionProvisioningStateSucceeded),
// 	},
// }

Output:

func (*PrivateEndpointConnectionsClient) BeginDelete 

func (client *PrivateEndpointConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientBeginDeleteOptions) (*runtime.Poller[PrivateEndpointConnectionsClientDeleteResponse], error)

BeginDelete - Deletes a private endpoint connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • options - PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceDeletePrivateEndpointConnection.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginDelete(ctx, "rgname", "service1", "myConnection", 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 (*PrivateEndpointConnectionsClient) Get 

func (client *PrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientGetOptions) (PrivateEndpointConnectionsClientGetResponse, error)

Get - Gets the specified private endpoint connection associated with the service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • options - PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceGetPrivateEndpointConnection.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "rgname", "service1", "myConnection", 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.PrivateEndpointConnectionDescription = armhealthcareapis.PrivateEndpointConnectionDescription{
// 	Name: to.Ptr("myConnection"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1/privateEndpointConnections/myConnection"),
// 	Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
// 		PrivateEndpoint: &armhealthcareapis.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/peexample01"),
// 		},
// 		PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
// 			Description: to.Ptr("Auto-Approved"),
// 			ActionsRequired: to.Ptr("None"),
// 			Status: to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
// 		},
// 	},
// }

Output:

func (*PrivateEndpointConnectionsClient) NewListByServicePager 

func (client *PrivateEndpointConnectionsClient) NewListByServicePager(resourceGroupName string, resourceName string, options *PrivateEndpointConnectionsClientListByServiceOptions) *runtime.Pager[PrivateEndpointConnectionsClientListByServiceResponse]

NewListByServicePager - Lists all private endpoint connections for a service.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • options - PrivateEndpointConnectionsClientListByServiceOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByServicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceListPrivateEndpointConnections.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPrivateEndpointConnectionsClient().NewListByServicePager("rgname", "service1", 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.PrivateEndpointConnectionListResultDescription = armhealthcareapis.PrivateEndpointConnectionListResultDescription{
	// 	Value: []*armhealthcareapis.PrivateEndpointConnectionDescription{
	// 		{
	// 			Name: to.Ptr("myConnection"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/services/privateEndpointConnections"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1/privateEndpointConnections/myConnection"),
	// 			Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
	// 				PrivateEndpoint: &armhealthcareapis.PrivateEndpoint{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/peexample01"),
	// 				},
	// 				PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
	// 					Description: to.Ptr("Auto-Approved"),
	// 					ActionsRequired: to.Ptr("None"),
	// 					Status: to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type PrivateEndpointConnectionsClientBeginCreateOrUpdateOptions 

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

PrivateEndpointConnectionsClientBeginCreateOrUpdateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginCreateOrUpdate method.

type PrivateEndpointConnectionsClientBeginDeleteOptions 

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

PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.

type PrivateEndpointConnectionsClientCreateOrUpdateResponse 

type PrivateEndpointConnectionsClientCreateOrUpdateResponse struct {
	// The Private Endpoint Connection resource.
	PrivateEndpointConnectionDescription
}

PrivateEndpointConnectionsClientCreateOrUpdateResponse contains the response from method PrivateEndpointConnectionsClient.BeginCreateOrUpdate.

type PrivateEndpointConnectionsClientDeleteResponse 

type PrivateEndpointConnectionsClientDeleteResponse struct {
}

PrivateEndpointConnectionsClientDeleteResponse contains the response from method PrivateEndpointConnectionsClient.BeginDelete.

type PrivateEndpointConnectionsClientGetOptions 

type PrivateEndpointConnectionsClientGetOptions struct {
}

PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.

type PrivateEndpointConnectionsClientGetResponse 

type PrivateEndpointConnectionsClientGetResponse struct {
	// The Private Endpoint Connection resource.
	PrivateEndpointConnectionDescription
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListByServiceOptions 

type PrivateEndpointConnectionsClientListByServiceOptions struct {
}

PrivateEndpointConnectionsClientListByServiceOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByServicePager method.

type PrivateEndpointConnectionsClientListByServiceResponse 

type PrivateEndpointConnectionsClientListByServiceResponse struct {
	// List of private endpoint connection associated with the specified storage account
	PrivateEndpointConnectionListResultDescription
}

PrivateEndpointConnectionsClientListByServiceResponse contains the response from method PrivateEndpointConnectionsClient.NewListByServicePager.

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string

PrivateEndpointServiceConnectionStatus - The private endpoint connection status. 

const (
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
)

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// Resource properties.
	Properties *PrivateLinkResourceProperties

	// 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
}

PrivateLinkResource - A private link resource

func (PrivateLinkResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResource.

func (*PrivateLinkResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResource.

type PrivateLinkResourceDescription 

type PrivateLinkResourceDescription struct {
	// Resource properties.
	Properties *PrivateLinkResourceProperties

	// 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; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

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

PrivateLinkResourceDescription - The Private Endpoint Connection resource.

func (PrivateLinkResourceDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceDescription.

func (*PrivateLinkResourceDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceDescription.

type PrivateLinkResourceListResultDescription 

type PrivateLinkResourceListResultDescription struct {
	// Array of private link resources
	Value []*PrivateLinkResourceDescription
}

PrivateLinkResourceListResultDescription - A list of private link resources

func (PrivateLinkResourceListResultDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceListResultDescription.

func (*PrivateLinkResourceListResultDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceListResultDescription.

type PrivateLinkResourceProperties 

type PrivateLinkResourceProperties struct {
	// The private link resource Private link DNS zone name.
	RequiredZoneNames []*string

	// READ-ONLY; The private link resource group id.
	GroupID *string

	// READ-ONLY; The private link resource required member names.
	RequiredMembers []*string
}

PrivateLinkResourceProperties - Properties of a private link resource.

func (PrivateLinkResourceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceProperties.

func (*PrivateLinkResourceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceProperties.

type PrivateLinkResourcesClient 

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

PrivateLinkResourcesClient contains the methods for the PrivateLinkResources group. Don't use this type directly, use NewPrivateLinkResourcesClient() instead.

func NewPrivateLinkResourcesClient 

func NewPrivateLinkResourcesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateLinkResourcesClient, error)

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient with the specified values.

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

func (*PrivateLinkResourcesClient) Get 

func (client *PrivateLinkResourcesClient) Get(ctx context.Context, resourceGroupName string, resourceName string, groupName string, options *PrivateLinkResourcesClientGetOptions) (PrivateLinkResourcesClientGetResponse, error)

Get - Gets a private link resource that need to be created for a service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • groupName - The name of the private link resource group.
  • options - PrivateLinkResourcesClientGetOptions contains the optional parameters for the PrivateLinkResourcesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/PrivateLinkResourceGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateLinkResourcesClient().Get(ctx, "rgname", "service1", "fhir", 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.PrivateLinkResourceDescription = armhealthcareapis.PrivateLinkResourceDescription{
// 	Name: to.Ptr("fhir"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services/privateLinkResources"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1/privateLinkResources/fhir"),
// 	Properties: &armhealthcareapis.PrivateLinkResourceProperties{
// 		GroupID: to.Ptr("fhir"),
// 		RequiredMembers: []*string{
// 			to.Ptr("fhir")},
// 			RequiredZoneNames: []*string{
// 				to.Ptr("privatelink.azurehealthcareapis.com")},
// 			},
// 		}

Output:

func (*PrivateLinkResourcesClient) ListByService 

func (client *PrivateLinkResourcesClient) ListByService(ctx context.Context, resourceGroupName string, resourceName string, options *PrivateLinkResourcesClientListByServiceOptions) (PrivateLinkResourcesClientListByServiceResponse, error)

ListByService - Gets the private link resources that need to be created for a service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • options - PrivateLinkResourcesClientListByServiceOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByService method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/PrivateLinkResourcesListByService.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateLinkResourcesClient().ListByService(ctx, "rgname", "service1", 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.PrivateLinkResourceListResultDescription = armhealthcareapis.PrivateLinkResourceListResultDescription{
// 	Value: []*armhealthcareapis.PrivateLinkResourceDescription{
// 		{
// 			Name: to.Ptr("fhir"),
// 			Type: to.Ptr("Microsoft.HealthcareApis/services/privateLinkResources"),
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1/privateLinkResources/fhir"),
// 			Properties: &armhealthcareapis.PrivateLinkResourceProperties{
// 				GroupID: to.Ptr("fhir"),
// 				RequiredMembers: []*string{
// 					to.Ptr("fhir")},
// 					RequiredZoneNames: []*string{
// 						to.Ptr("privatelink.azurehealthcareapis.com")},
// 					},
// 			}},
// 		}

Output:

type PrivateLinkResourcesClientGetOptions 

type PrivateLinkResourcesClientGetOptions struct {
}

PrivateLinkResourcesClientGetOptions contains the optional parameters for the PrivateLinkResourcesClient.Get method.

type PrivateLinkResourcesClientGetResponse 

type PrivateLinkResourcesClientGetResponse struct {
	// The Private Endpoint Connection resource.
	PrivateLinkResourceDescription
}

PrivateLinkResourcesClientGetResponse contains the response from method PrivateLinkResourcesClient.Get.

type PrivateLinkResourcesClientListByServiceOptions 

type PrivateLinkResourcesClientListByServiceOptions struct {
}

PrivateLinkResourcesClientListByServiceOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByService method.

type PrivateLinkResourcesClientListByServiceResponse 

type PrivateLinkResourcesClientListByServiceResponse struct {
	// A list of private link resources
	PrivateLinkResourceListResultDescription
}

PrivateLinkResourcesClientListByServiceResponse contains the response from method PrivateLinkResourcesClient.ListByService.

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// A message indicating if changes on the service provider require any updates on the consumer.
	ActionsRequired *string

	// The reason for approval/rejection of the connection.
	Description *string

	// Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
	Status *PrivateEndpointServiceConnectionStatus
}

PrivateLinkServiceConnectionState - A collection of information about the state of the connection between service consumer and provider.

func (PrivateLinkServiceConnectionState) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkServiceConnectionState.

func (*PrivateLinkServiceConnectionState) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkServiceConnectionState.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The provisioning state. 

const (
	ProvisioningStateAccepted          ProvisioningState = "Accepted"
	ProvisioningStateCanceled          ProvisioningState = "Canceled"
	ProvisioningStateCreating          ProvisioningState = "Creating"
	ProvisioningStateDeleting          ProvisioningState = "Deleting"
	ProvisioningStateDeprovisioned     ProvisioningState = "Deprovisioned"
	ProvisioningStateFailed            ProvisioningState = "Failed"
	ProvisioningStateMoving            ProvisioningState = "Moving"
	ProvisioningStateSucceeded         ProvisioningState = "Succeeded"
	ProvisioningStateSuspended         ProvisioningState = "Suspended"
	ProvisioningStateSystemMaintenance ProvisioningState = "SystemMaintenance"
	ProvisioningStateUpdating          ProvisioningState = "Updating"
	ProvisioningStateVerifying         ProvisioningState = "Verifying"
	ProvisioningStateWarned            ProvisioningState = "Warned"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type PublicNetworkAccess 

type PublicNetworkAccess string

PublicNetworkAccess - Control permission for data plane traffic coming from public networks while private endpoint is enabled. 

const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

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 ResourceCore 

type ResourceCore struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

ResourceCore - The common properties for any resource, tracked or proxy.

func (ResourceCore) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ResourceCore.

func (*ResourceCore) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceCore.

type ResourceTags 

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

ResourceTags - List of key value pairs that describe the resource. This will overwrite the existing tags.

func (ResourceTags) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ResourceTags.

func (*ResourceTags) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceTags.

type ResourceVersionPolicyConfiguration 

type ResourceVersionPolicyConfiguration struct {
	// The default value for tracking history across all resources.
	Default *FhirResourceVersionPolicy

	// A list of FHIR Resources and their version policy overrides.
	ResourceTypeOverrides map[string]*FhirResourceVersionPolicy
}

ResourceVersionPolicyConfiguration - The settings for history tracking for FHIR resources.

func (ResourceVersionPolicyConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ResourceVersionPolicyConfiguration.

func (*ResourceVersionPolicyConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceVersionPolicyConfiguration.

type ServiceAccessPolicyEntry 

type ServiceAccessPolicyEntry struct {
	// REQUIRED; An Azure AD object ID (User or Apps) that is allowed access to the FHIR service.
	ObjectID *string
}

ServiceAccessPolicyEntry - An access policy entry.

func (ServiceAccessPolicyEntry) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceAccessPolicyEntry.

func (*ServiceAccessPolicyEntry) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceAccessPolicyEntry.

type ServiceAcrConfigurationInfo 

type ServiceAcrConfigurationInfo struct {
	// The list of the ACR login servers.
	LoginServers []*string

	// The list of Open Container Initiative (OCI) artifacts.
	OciArtifacts []*ServiceOciArtifactEntry
}

ServiceAcrConfigurationInfo - Azure container registry configuration information

func (ServiceAcrConfigurationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceAcrConfigurationInfo.

func (*ServiceAcrConfigurationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceAcrConfigurationInfo.

type ServiceAuthenticationConfigurationInfo 

type ServiceAuthenticationConfigurationInfo struct {
	// The audience url for the service
	Audience *string

	// The authority url for the service
	Authority *string

	// If the SMART on FHIR proxy is enabled
	SmartProxyEnabled *bool
}

ServiceAuthenticationConfigurationInfo - Authentication configuration information

func (ServiceAuthenticationConfigurationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceAuthenticationConfigurationInfo.

func (*ServiceAuthenticationConfigurationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceAuthenticationConfigurationInfo.

type ServiceCorsConfigurationInfo 

type ServiceCorsConfigurationInfo struct {
	// If credentials are allowed via CORS.
	AllowCredentials *bool

	// The headers to be allowed via CORS.
	Headers []*string

	// The max age to be allowed via CORS.
	MaxAge *int32

	// The methods to be allowed via CORS.
	Methods []*string

	// The origins to be allowed via CORS.
	Origins []*string
}

ServiceCorsConfigurationInfo - The settings for the CORS configuration of the service instance.

func (ServiceCorsConfigurationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceCorsConfigurationInfo.

func (*ServiceCorsConfigurationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceCorsConfigurationInfo.

type ServiceCosmosDbConfigurationInfo 

type ServiceCosmosDbConfigurationInfo struct {
	// The multi-tenant application id used to enable CMK access for services in a data sovereign region.
	CrossTenantCmkApplicationID *string

	// The URI of the customer-managed key for the backing database.
	KeyVaultKeyURI *string

	// The provisioned throughput for the backing database.
	OfferThroughput *int32
}

ServiceCosmosDbConfigurationInfo - The settings for the Cosmos DB database backing the service.

func (ServiceCosmosDbConfigurationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceCosmosDbConfigurationInfo.

func (*ServiceCosmosDbConfigurationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceCosmosDbConfigurationInfo.

type ServiceEventState 

type ServiceEventState string

ServiceEventState - Indicates the current status of event support for the resource. 

const (
	ServiceEventStateDisabled ServiceEventState = "Disabled"
	ServiceEventStateEnabled  ServiceEventState = "Enabled"
	ServiceEventStateUpdating ServiceEventState = "Updating"
)

func PossibleServiceEventStateValues 

func PossibleServiceEventStateValues() []ServiceEventState

PossibleServiceEventStateValues returns the possible values for the ServiceEventState const type.

type ServiceExportConfigurationInfo 

type ServiceExportConfigurationInfo struct {
	// The name of the default export storage account.
	StorageAccountName *string
}

ServiceExportConfigurationInfo - Export operation configuration information

func (ServiceExportConfigurationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceExportConfigurationInfo.

func (*ServiceExportConfigurationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceExportConfigurationInfo.

type ServiceImportConfigurationInfo 

type ServiceImportConfigurationInfo struct {
	// If the import operation is enabled.
	Enabled *bool

	// If the FHIR service is in InitialImportMode.
	InitialImportMode *bool

	// The name of the default integration storage account.
	IntegrationDataStore *string
}

ServiceImportConfigurationInfo - Import operation configuration information

func (ServiceImportConfigurationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceImportConfigurationInfo.

func (*ServiceImportConfigurationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceImportConfigurationInfo.

type ServiceManagedIdentity 

type ServiceManagedIdentity struct {
	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServiceManagedIdentityIdentity
}

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

func (ServiceManagedIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceManagedIdentity.

func (*ServiceManagedIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceManagedIdentity.

type ServiceManagedIdentityIdentity 

type ServiceManagedIdentityIdentity struct {
	// REQUIRED; Type of identity being specified, currently SystemAssigned and None are allowed.
	Type *ServiceManagedIdentityType

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

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

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

ServiceManagedIdentityIdentity - Setting indicating whether the service has a managed identity associated with it.

func (ServiceManagedIdentityIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceManagedIdentityIdentity.

func (*ServiceManagedIdentityIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceManagedIdentityIdentity.

type ServiceManagedIdentityType 

type ServiceManagedIdentityType string

ServiceManagedIdentityType - Type of identity being specified, currently SystemAssigned and None are allowed. 

const (
	ServiceManagedIdentityTypeNone                       ServiceManagedIdentityType = "None"
	ServiceManagedIdentityTypeSystemAssigned             ServiceManagedIdentityType = "SystemAssigned"
	ServiceManagedIdentityTypeSystemAssignedUserAssigned ServiceManagedIdentityType = "SystemAssigned,UserAssigned"
	ServiceManagedIdentityTypeUserAssigned               ServiceManagedIdentityType = "UserAssigned"
)

func PossibleServiceManagedIdentityTypeValues 

func PossibleServiceManagedIdentityTypeValues() []ServiceManagedIdentityType

PossibleServiceManagedIdentityTypeValues returns the possible values for the ServiceManagedIdentityType const type.

type ServiceNameUnavailabilityReason 

type ServiceNameUnavailabilityReason string

ServiceNameUnavailabilityReason - The reason for unavailability. 

const (
	ServiceNameUnavailabilityReasonAlreadyExists ServiceNameUnavailabilityReason = "AlreadyExists"
	ServiceNameUnavailabilityReasonInvalid       ServiceNameUnavailabilityReason = "Invalid"
)

func PossibleServiceNameUnavailabilityReasonValues 

func PossibleServiceNameUnavailabilityReasonValues() []ServiceNameUnavailabilityReason

PossibleServiceNameUnavailabilityReasonValues returns the possible values for the ServiceNameUnavailabilityReason const type.

type ServiceOciArtifactEntry 

type ServiceOciArtifactEntry struct {
	// The artifact digest.
	Digest *string

	// The artifact name.
	ImageName *string

	// The Azure Container Registry login server.
	LoginServer *string
}

ServiceOciArtifactEntry - An Open Container Initiative (OCI) artifact.

func (ServiceOciArtifactEntry) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceOciArtifactEntry.

func (*ServiceOciArtifactEntry) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceOciArtifactEntry.

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 ServicesClient 

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

ServicesClient contains the methods for the Services group. Don't use this type directly, use NewServicesClient() instead.

func NewServicesClient 

func NewServicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServicesClient, error)

NewServicesClient creates a new instance of ServicesClient with the specified values.

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

func (*ServicesClient) BeginCreateOrUpdate 

func (client *ServicesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, serviceDescription ServicesDescription, options *ServicesClientBeginCreateOrUpdateOptions) (*runtime.Poller[ServicesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the metadata of a service instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • serviceDescription - The service instance metadata.
  • options - ServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the ServicesClient.BeginCreateOrUpdate method.
Example (CreateOrUpdateAServiceWithAllParameters)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginCreateOrUpdate(ctx, "rg1", "service1", armhealthcareapis.ServicesDescription{
	Identity: &armhealthcareapis.ServicesResourceIdentity{
		Type: to.Ptr(armhealthcareapis.ManagedServiceIdentityTypeSystemAssigned),
	},
	Kind:     to.Ptr(armhealthcareapis.KindFhirR4),
	Location: to.Ptr("westus2"),
	Tags:     map[string]*string{},
	Properties: &armhealthcareapis.ServicesProperties{
		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
			{
				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
			},
			{
				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
			}},
		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
			Audience:          to.Ptr("https://azurehealthcareapis.com"),
			Authority:         to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
			SmartProxyEnabled: to.Ptr(true),
		},
		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
			AllowCredentials: to.Ptr(false),
			Headers: []*string{
				to.Ptr("*")},
			MaxAge: to.Ptr[int32](1440),
			Methods: []*string{
				to.Ptr("DELETE"),
				to.Ptr("GET"),
				to.Ptr("OPTIONS"),
				to.Ptr("PATCH"),
				to.Ptr("POST"),
				to.Ptr("PUT")},
			Origins: []*string{
				to.Ptr("*")},
		},
		CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
			KeyVaultKeyURI:  to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
			OfferThroughput: to.Ptr[int32](1000),
		},
		ExportConfiguration: &armhealthcareapis.ServiceExportConfigurationInfo{
			StorageAccountName: to.Ptr("existingStorageAccount"),
		},
		PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{},
		PublicNetworkAccess:        to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
	},
}, 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.ServicesDescription = armhealthcareapis.ServicesDescription{
// 	Name: to.Ptr("service1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1"),
// 	Identity: &armhealthcareapis.ServicesResourceIdentity{
// 		Type: to.Ptr(armhealthcareapis.ManagedServiceIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("03fe6ae0-952c-4e4b-954b-cc0364dd252e"),
// 		TenantID: to.Ptr("72f988bf-86f1-41af-91ab-2d8cd011db47"),
// 	},
// 	Kind: to.Ptr(armhealthcareapis.KindFhirR4),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armhealthcareapis.ServicesProperties{
// 		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
// 			{
// 				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
// 			},
// 			{
// 				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
// 		}},
// 		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartProxyEnabled: to.Ptr(true),
// 		},
// 		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
// 			AllowCredentials: to.Ptr(false),
// 			Headers: []*string{
// 				to.Ptr("*")},
// 				MaxAge: to.Ptr[int32](1440),
// 				Methods: []*string{
// 					to.Ptr("DELETE"),
// 					to.Ptr("GET"),
// 					to.Ptr("OPTIONS"),
// 					to.Ptr("PATCH"),
// 					to.Ptr("POST"),
// 					to.Ptr("PUT")},
// 					Origins: []*string{
// 						to.Ptr("*")},
// 					},
// 					CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
// 						KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
// 						OfferThroughput: to.Ptr[int32](1000),
// 					},
// 					ExportConfiguration: &armhealthcareapis.ServiceExportConfigurationInfo{
// 						StorageAccountName: to.Ptr("existingStorageAccount"),
// 					},
// 					PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
// 					},
// 					ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
// 				},
// 			}

Output:
Example (CreateOrUpdateAServiceWithAllParametersAndCmkEnabledInADataSovereignRegion)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceCreateInDataSovereignRegionWithCmkEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginCreateOrUpdate(ctx, "rg1", "service1", armhealthcareapis.ServicesDescription{
	Identity: &armhealthcareapis.ServicesResourceIdentity{
		Type: to.Ptr(armhealthcareapis.ManagedServiceIdentityTypeSystemAssigned),
	},
	Kind:     to.Ptr(armhealthcareapis.KindFhirR4),
	Location: to.Ptr("Southeast Asia"),
	Tags:     map[string]*string{},
	Properties: &armhealthcareapis.ServicesProperties{
		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
			{
				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
			},
			{
				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
			}},
		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
			Audience:          to.Ptr("https://azurehealthcareapis.com"),
			Authority:         to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
			SmartProxyEnabled: to.Ptr(true),
		},
		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
			AllowCredentials: to.Ptr(false),
			Headers: []*string{
				to.Ptr("*")},
			MaxAge: to.Ptr[int32](1440),
			Methods: []*string{
				to.Ptr("DELETE"),
				to.Ptr("GET"),
				to.Ptr("OPTIONS"),
				to.Ptr("PATCH"),
				to.Ptr("POST"),
				to.Ptr("PUT")},
			Origins: []*string{
				to.Ptr("*")},
		},
		CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
			CrossTenantCmkApplicationID: to.Ptr("de3fbeef-8c3a-428e-8b9f-4d229c8a85f4"),
			KeyVaultKeyURI:              to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
			OfferThroughput:             to.Ptr[int32](1000),
		},
		ExportConfiguration: &armhealthcareapis.ServiceExportConfigurationInfo{
			StorageAccountName: to.Ptr("existingStorageAccount"),
		},
		PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{},
		PublicNetworkAccess:        to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
	},
}, 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.ServicesDescription = armhealthcareapis.ServicesDescription{
// 	Name: to.Ptr("service1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1"),
// 	Identity: &armhealthcareapis.ServicesResourceIdentity{
// 		Type: to.Ptr(armhealthcareapis.ManagedServiceIdentityTypeSystemAssigned),
// 		PrincipalID: to.Ptr("03fe6ae0-952c-4e4b-954b-cc0364dd252e"),
// 		TenantID: to.Ptr("72f988bf-86f1-41af-91ab-2d8cd011db47"),
// 	},
// 	Kind: to.Ptr(armhealthcareapis.KindFhirR4),
// 	Location: to.Ptr("West US 2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armhealthcareapis.ServicesProperties{
// 		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
// 			{
// 				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
// 			},
// 			{
// 				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
// 		}},
// 		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartProxyEnabled: to.Ptr(true),
// 		},
// 		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
// 			AllowCredentials: to.Ptr(false),
// 			Headers: []*string{
// 				to.Ptr("*")},
// 				MaxAge: to.Ptr[int32](1440),
// 				Methods: []*string{
// 					to.Ptr("DELETE"),
// 					to.Ptr("GET"),
// 					to.Ptr("OPTIONS"),
// 					to.Ptr("PATCH"),
// 					to.Ptr("POST"),
// 					to.Ptr("PUT")},
// 					Origins: []*string{
// 						to.Ptr("*")},
// 					},
// 					CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
// 						CrossTenantCmkApplicationID: to.Ptr("de3fbeef-8c3a-428e-8b9f-4d229c8a85f4"),
// 						KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
// 						OfferThroughput: to.Ptr[int32](1000),
// 					},
// 					ExportConfiguration: &armhealthcareapis.ServiceExportConfigurationInfo{
// 						StorageAccountName: to.Ptr("existingStorageAccount"),
// 					},
// 					PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
// 					},
// 					ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
// 				},
// 			}

Output:
Example (CreateOrUpdateAServiceWithMinimumParameters)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceCreateMinimum.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginCreateOrUpdate(ctx, "rg1", "service2", armhealthcareapis.ServicesDescription{
	Kind:     to.Ptr(armhealthcareapis.KindFhirR4),
	Location: to.Ptr("westus2"),
	Tags:     map[string]*string{},
	Properties: &armhealthcareapis.ServicesProperties{
		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
			{
				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
			}},
	},
}, 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.ServicesDescription = armhealthcareapis.ServicesDescription{
// 	Name: to.Ptr("service2"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service2"),
// 	Kind: to.Ptr(armhealthcareapis.KindFhirR4),
// 	Location: to.Ptr("westus2"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armhealthcareapis.ServicesProperties{
// 		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
// 			{
// 				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
// 		}},
// 		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartProxyEnabled: to.Ptr(false),
// 		},
// 		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
// 			AllowCredentials: to.Ptr(false),
// 			Headers: []*string{
// 			},
// 			Methods: []*string{
// 			},
// 			Origins: []*string{
// 			},
// 		},
// 		CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
// 			OfferThroughput: to.Ptr[int32](1000),
// 		},
// 		PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
// 		},
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 		PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
// 	},
// }

Output:

func (*ServicesClient) BeginDelete 

func (client *ServicesClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, options *ServicesClientBeginDeleteOptions) (*runtime.Poller[ServicesClientDeleteResponse], error)

BeginDelete - Delete a service instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • options - ServicesClientBeginDeleteOptions contains the optional parameters for the ServicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginDelete(ctx, "rg1", "service1", 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 (*ServicesClient) BeginUpdate 

func (client *ServicesClient) BeginUpdate(ctx context.Context, resourceGroupName string, resourceName string, servicePatchDescription ServicesPatchDescription, options *ServicesClientBeginUpdateOptions) (*runtime.Poller[ServicesClientUpdateResponse], error)

BeginUpdate - Update the metadata of a service instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • servicePatchDescription - The service instance metadata and security metadata.
  • options - ServicesClientBeginUpdateOptions contains the optional parameters for the ServicesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServicePatch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginUpdate(ctx, "rg1", "service1", armhealthcareapis.ServicesPatchDescription{
	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)
}
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.ServicesDescription = armhealthcareapis.ServicesDescription{
// 	Name: to.Ptr("service1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1"),
// 	Kind: to.Ptr(armhealthcareapis.KindFhirR4),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armhealthcareapis.ServicesProperties{
// 		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
// 			{
// 				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
// 			},
// 			{
// 				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
// 		}},
// 		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartProxyEnabled: to.Ptr(true),
// 		},
// 		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
// 			AllowCredentials: to.Ptr(false),
// 			Headers: []*string{
// 				to.Ptr("*")},
// 				MaxAge: to.Ptr[int32](1440),
// 				Methods: []*string{
// 					to.Ptr("DELETE"),
// 					to.Ptr("GET"),
// 					to.Ptr("OPTIONS"),
// 					to.Ptr("PATCH"),
// 					to.Ptr("POST"),
// 					to.Ptr("PUT")},
// 					Origins: []*string{
// 						to.Ptr("*")},
// 					},
// 					CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
// 						KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
// 						OfferThroughput: to.Ptr[int32](1000),
// 					},
// 					PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
// 					},
// 					ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
// 				},
// 			}

Output:

func (*ServicesClient) CheckNameAvailability 

func (client *ServicesClient) CheckNameAvailability(ctx context.Context, checkNameAvailabilityInputs CheckNameAvailabilityParameters, options *ServicesClientCheckNameAvailabilityOptions) (ServicesClientCheckNameAvailabilityResponse, error)

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

Generated from API version 2024-03-31

  • checkNameAvailabilityInputs - Set the name parameter in the CheckNameAvailabilityParameters structure to the name of the service instance to check.
  • options - ServicesClientCheckNameAvailabilityOptions contains the optional parameters for the ServicesClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/CheckNameAvailabilityPost.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServicesClient().CheckNameAvailability(ctx, armhealthcareapis.CheckNameAvailabilityParameters{
	Name: to.Ptr("serviceName"),
	Type: to.Ptr("Microsoft.HealthcareApis/services"),
}, 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.ServicesNameAvailabilityInfo = armhealthcareapis.ServicesNameAvailabilityInfo{
// 	Message: to.Ptr("Service name is not available."),
// 	NameAvailable: to.Ptr(false),
// 	Reason: to.Ptr(armhealthcareapis.ServiceNameUnavailabilityReasonAlreadyExists),
// }

Output:

func (*ServicesClient) Get 

func (client *ServicesClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *ServicesClientGetOptions) (ServicesClientGetResponse, error)

Get - Get the metadata of a service instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • resourceName - The name of the service instance.
  • options - ServicesClientGetOptions contains the optional parameters for the ServicesClient.Get method.
Example (GetMetadata)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServicesClient().Get(ctx, "rg1", "service1", 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.ServicesDescription = armhealthcareapis.ServicesDescription{
// 	Name: to.Ptr("service1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1"),
// 	Kind: to.Ptr(armhealthcareapis.KindFhirR4),
// 	Location: to.Ptr("West US"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armhealthcareapis.ServicesProperties{
// 		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
// 			{
// 				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
// 			},
// 			{
// 				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
// 		}},
// 		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartProxyEnabled: to.Ptr(true),
// 		},
// 		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
// 			AllowCredentials: to.Ptr(false),
// 			Headers: []*string{
// 				to.Ptr("*")},
// 				MaxAge: to.Ptr[int32](1440),
// 				Methods: []*string{
// 					to.Ptr("DELETE"),
// 					to.Ptr("GET"),
// 					to.Ptr("OPTIONS"),
// 					to.Ptr("PATCH"),
// 					to.Ptr("POST"),
// 					to.Ptr("PUT")},
// 					Origins: []*string{
// 						to.Ptr("*")},
// 					},
// 					CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
// 						KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
// 						OfferThroughput: to.Ptr[int32](1000),
// 					},
// 					PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
// 					},
// 					ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
// 				},
// 			}

Output:
Example (GetMetadataForCmkEnabledServiceInDataSovereignRegion)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceGetInDataSovereignRegionWithCmkEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServicesClient().Get(ctx, "rg1", "service1", 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.ServicesDescription = armhealthcareapis.ServicesDescription{
// 	Name: to.Ptr("service1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/services"),
// 	Etag: to.Ptr("etagvalue"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1"),
// 	Kind: to.Ptr(armhealthcareapis.KindFhirR4),
// 	Location: to.Ptr("Southeast Asia"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armhealthcareapis.ServicesProperties{
// 		AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
// 			{
// 				ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
// 			},
// 			{
// 				ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
// 		}},
// 		AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
// 			Audience: to.Ptr("https://azurehealthcareapis.com"),
// 			Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
// 			SmartProxyEnabled: to.Ptr(true),
// 		},
// 		CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
// 			AllowCredentials: to.Ptr(false),
// 			Headers: []*string{
// 				to.Ptr("*")},
// 				MaxAge: to.Ptr[int32](1440),
// 				Methods: []*string{
// 					to.Ptr("DELETE"),
// 					to.Ptr("GET"),
// 					to.Ptr("OPTIONS"),
// 					to.Ptr("PATCH"),
// 					to.Ptr("POST"),
// 					to.Ptr("PUT")},
// 					Origins: []*string{
// 						to.Ptr("*")},
// 					},
// 					CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
// 						KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
// 						OfferThroughput: to.Ptr[int32](1000),
// 					},
// 					PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
// 					},
// 					ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 					PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
// 				},
// 			}

Output:

func (*ServicesClient) NewListByResourceGroupPager 

func (client *ServicesClient) NewListByResourceGroupPager(resourceGroupName string, options *ServicesClientListByResourceGroupOptions) *runtime.Pager[ServicesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Get all the service instances in a resource group.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • options - ServicesClientListByResourceGroupOptions contains the optional parameters for the ServicesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServicesClient().NewListByResourceGroupPager("rgname", 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.ServicesDescriptionListResult = armhealthcareapis.ServicesDescriptionListResult{
	// 	Value: []*armhealthcareapis.ServicesDescription{
	// 		{
	// 			Name: to.Ptr("service1"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/services"),
	// 			Etag: to.Ptr("etagvalue"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/dddb8dcb-effb-4290-bb47-ce1e8440c729"),
	// 			Kind: to.Ptr(armhealthcareapis.KindFhirR4),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armhealthcareapis.ServicesProperties{
	// 				AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
	// 					{
	// 						ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
	// 					},
	// 					{
	// 						ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
	// 				}},
	// 				AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
	// 					Audience: to.Ptr("https://azurehealthcareapis.com"),
	// 					Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
	// 					SmartProxyEnabled: to.Ptr(true),
	// 				},
	// 				CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
	// 					AllowCredentials: to.Ptr(false),
	// 					Headers: []*string{
	// 						to.Ptr("*")},
	// 						MaxAge: to.Ptr[int32](1440),
	// 						Methods: []*string{
	// 							to.Ptr("DELETE"),
	// 							to.Ptr("GET"),
	// 							to.Ptr("OPTIONS"),
	// 							to.Ptr("PATCH"),
	// 							to.Ptr("POST"),
	// 							to.Ptr("PUT")},
	// 							Origins: []*string{
	// 								to.Ptr("*")},
	// 							},
	// 							CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
	// 								KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
	// 								OfferThroughput: to.Ptr[int32](1000),
	// 							},
	// 							PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
	// 							},
	// 							ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 							PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
	// 						},
	// 				}},
	// 			}
}

Output:

func (*ServicesClient) NewListPager 

func (client *ServicesClient) NewListPager(options *ServicesClientListOptions) *runtime.Pager[ServicesClientListResponse]

NewListPager - Get all the service instances in a subscription.

Generated from API version 2024-03-31

  • options - ServicesClientListOptions contains the optional parameters for the ServicesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/legacy/ServiceList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServicesClient().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.ServicesDescriptionListResult = armhealthcareapis.ServicesDescriptionListResult{
	// 	Value: []*armhealthcareapis.ServicesDescription{
	// 		{
	// 			Name: to.Ptr("service1"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/services"),
	// 			Etag: to.Ptr("etag"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/services/service1"),
	// 			Kind: to.Ptr(armhealthcareapis.KindFhirR4),
	// 			Location: to.Ptr("West US"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armhealthcareapis.ServicesProperties{
	// 				AccessPolicies: []*armhealthcareapis.ServiceAccessPolicyEntry{
	// 					{
	// 						ObjectID: to.Ptr("c487e7d1-3210-41a3-8ccc-e9372b78da47"),
	// 					},
	// 					{
	// 						ObjectID: to.Ptr("5b307da8-43d4-492b-8b66-b0294ade872f"),
	// 				}},
	// 				AuthenticationConfiguration: &armhealthcareapis.ServiceAuthenticationConfigurationInfo{
	// 					Audience: to.Ptr("https://azurehealthcareapis.com"),
	// 					Authority: to.Ptr("https://login.microsoftonline.com/abfde7b2-df0f-47e6-aabf-2462b07508dc"),
	// 					SmartProxyEnabled: to.Ptr(true),
	// 				},
	// 				CorsConfiguration: &armhealthcareapis.ServiceCorsConfigurationInfo{
	// 					AllowCredentials: to.Ptr(false),
	// 					Headers: []*string{
	// 						to.Ptr("*")},
	// 						MaxAge: to.Ptr[int32](1440),
	// 						Methods: []*string{
	// 							to.Ptr("DELETE"),
	// 							to.Ptr("GET"),
	// 							to.Ptr("OPTIONS"),
	// 							to.Ptr("PATCH"),
	// 							to.Ptr("POST"),
	// 							to.Ptr("PUT")},
	// 							Origins: []*string{
	// 								to.Ptr("*")},
	// 							},
	// 							CosmosDbConfiguration: &armhealthcareapis.ServiceCosmosDbConfigurationInfo{
	// 								KeyVaultKeyURI: to.Ptr("https://my-vault.vault.azure.net/keys/my-key"),
	// 								OfferThroughput: to.Ptr[int32](1000),
	// 							},
	// 							PrivateEndpointConnections: []*armhealthcareapis.PrivateEndpointConnection{
	// 							},
	// 							ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 							PublicNetworkAccess: to.Ptr(armhealthcareapis.PublicNetworkAccessDisabled),
	// 						},
	// 				}},
	// 			}
}

Output:

type ServicesClientBeginCreateOrUpdateOptions 

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

ServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the ServicesClient.BeginCreateOrUpdate method.

type ServicesClientBeginDeleteOptions 

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

ServicesClientBeginDeleteOptions contains the optional parameters for the ServicesClient.BeginDelete method.

type ServicesClientBeginUpdateOptions 

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

ServicesClientBeginUpdateOptions contains the optional parameters for the ServicesClient.BeginUpdate method.

type ServicesClientCheckNameAvailabilityOptions 

type ServicesClientCheckNameAvailabilityOptions struct {
}

ServicesClientCheckNameAvailabilityOptions contains the optional parameters for the ServicesClient.CheckNameAvailability method.

type ServicesClientCheckNameAvailabilityResponse 

type ServicesClientCheckNameAvailabilityResponse struct {
	// The properties indicating whether a given service name is available.
	ServicesNameAvailabilityInfo
}

ServicesClientCheckNameAvailabilityResponse contains the response from method ServicesClient.CheckNameAvailability.

type ServicesClientCreateOrUpdateResponse 

type ServicesClientCreateOrUpdateResponse struct {
	// The description of the service.
	ServicesDescription
}

ServicesClientCreateOrUpdateResponse contains the response from method ServicesClient.BeginCreateOrUpdate.

type ServicesClientDeleteResponse 

type ServicesClientDeleteResponse struct {
}

ServicesClientDeleteResponse contains the response from method ServicesClient.BeginDelete.

type ServicesClientGetOptions 

type ServicesClientGetOptions struct {
}

ServicesClientGetOptions contains the optional parameters for the ServicesClient.Get method.

type ServicesClientGetResponse 

type ServicesClientGetResponse struct {
	// The description of the service.
	ServicesDescription
}

ServicesClientGetResponse contains the response from method ServicesClient.Get.

type ServicesClientListByResourceGroupOptions 

type ServicesClientListByResourceGroupOptions struct {
}

ServicesClientListByResourceGroupOptions contains the optional parameters for the ServicesClient.NewListByResourceGroupPager method.

type ServicesClientListByResourceGroupResponse 

type ServicesClientListByResourceGroupResponse struct {
	// A list of service description objects with a next link.
	ServicesDescriptionListResult
}

ServicesClientListByResourceGroupResponse contains the response from method ServicesClient.NewListByResourceGroupPager.

type ServicesClientListOptions 

type ServicesClientListOptions struct {
}

ServicesClientListOptions contains the optional parameters for the ServicesClient.NewListPager method.

type ServicesClientListResponse 

type ServicesClientListResponse struct {
	// A list of service description objects with a next link.
	ServicesDescriptionListResult
}

ServicesClientListResponse contains the response from method ServicesClient.NewListPager.

type ServicesClientUpdateResponse 

type ServicesClientUpdateResponse struct {
	// The description of the service.
	ServicesDescription
}

ServicesClientUpdateResponse contains the response from method ServicesClient.BeginUpdate.

type ServicesDescription 

type ServicesDescription struct {
	// REQUIRED; The kind of the service.
	Kind *Kind

	// REQUIRED; The resource location.
	Location *string

	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServicesResourceIdentity

	// The common properties of a service.
	Properties *ServicesProperties

	// The resource tags.
	Tags map[string]*string

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY; The resource type.
	Type *string
}

ServicesDescription - The description of the service.

func (ServicesDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesDescription.

func (*ServicesDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesDescription.

type ServicesDescriptionListResult 

type ServicesDescriptionListResult struct {
	// The link used to get the next page of service description objects.
	NextLink *string

	// A list of service description objects.
	Value []*ServicesDescription
}

ServicesDescriptionListResult - A list of service description objects with a next link.

func (ServicesDescriptionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesDescriptionListResult.

func (*ServicesDescriptionListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesDescriptionListResult.

type ServicesNameAvailabilityInfo 

type ServicesNameAvailabilityInfo struct {
	// The detailed reason message.
	Message *string

	// READ-ONLY; The value which indicates whether the provided name is available.
	NameAvailable *bool

	// READ-ONLY; The reason for unavailability.
	Reason *ServiceNameUnavailabilityReason
}

ServicesNameAvailabilityInfo - The properties indicating whether a given service name is available.

func (ServicesNameAvailabilityInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesNameAvailabilityInfo.

func (*ServicesNameAvailabilityInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesNameAvailabilityInfo.

type ServicesPatchDescription 

type ServicesPatchDescription struct {
	// The properties for updating a service instance.
	Properties *ServicesPropertiesUpdateParameters

	// Instance tags
	Tags map[string]*string
}

ServicesPatchDescription - The description of the service.

func (ServicesPatchDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesPatchDescription.

func (*ServicesPatchDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesPatchDescription.

type ServicesProperties 

type ServicesProperties struct {
	// The access policies of the service instance.
	AccessPolicies []*ServiceAccessPolicyEntry

	// The azure container registry settings used for convert data operation of the service instance.
	AcrConfiguration *ServiceAcrConfigurationInfo

	// The authentication configuration for the service instance.
	AuthenticationConfiguration *ServiceAuthenticationConfigurationInfo

	// The settings for the CORS configuration of the service instance.
	CorsConfiguration *ServiceCorsConfigurationInfo

	// The settings for the Cosmos DB database backing the service.
	CosmosDbConfiguration *ServiceCosmosDbConfigurationInfo

	// The settings for the export operation of the service instance.
	ExportConfiguration *ServiceExportConfigurationInfo

	// The settings for the import operation of the service instance.
	ImportConfiguration *ServiceImportConfigurationInfo

	// The list of private endpoint connections that are set up for this resource.
	PrivateEndpointConnections []*PrivateEndpointConnection

	// Control permission for data plane traffic coming from public networks while private endpoint is enabled.
	PublicNetworkAccess *PublicNetworkAccess

	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState
}

ServicesProperties - The properties of a service instance.

func (ServicesProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesProperties.

func (*ServicesProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesProperties.

type ServicesPropertiesUpdateParameters 

type ServicesPropertiesUpdateParameters struct {
	// Control permission for data plane traffic coming from public networks while private endpoint is enabled.
	PublicNetworkAccess *PublicNetworkAccess
}

ServicesPropertiesUpdateParameters - The properties for updating a service instance.

func (ServicesPropertiesUpdateParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesPropertiesUpdateParameters.

func (*ServicesPropertiesUpdateParameters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesPropertiesUpdateParameters.

type ServicesResource 

type ServicesResource struct {
	// REQUIRED; The kind of the service.
	Kind *Kind

	// REQUIRED; The resource location.
	Location *string

	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// Setting indicating whether the service has a managed identity associated with it.
	Identity *ServicesResourceIdentity

	// The resource tags.
	Tags map[string]*string

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

ServicesResource - The common properties of a service.

func (ServicesResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesResource.

func (*ServicesResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesResource.

type ServicesResourceIdentity 

type ServicesResourceIdentity struct {
	// Type of identity being specified, currently SystemAssigned and None are allowed.
	Type *ManagedServiceIdentityType

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

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

ServicesResourceIdentity - Setting indicating whether the service has a managed identity associated with it.

func (ServicesResourceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicesResourceIdentity.

func (*ServicesResourceIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicesResourceIdentity.

type SmartDataActions added in v2.1.0 

type SmartDataActions string

SmartDataActions - The Data Actions that can be enabled for a Smart Identity Provider Application. 

const (
	SmartDataActionsRead SmartDataActions = "Read"
)

func PossibleSmartDataActionsValues added in v2.1.0 

func PossibleSmartDataActionsValues() []SmartDataActions

PossibleSmartDataActionsValues returns the possible values for the SmartDataActions const type.

type SmartIdentityProviderApplication added in v2.1.0 

type SmartIdentityProviderApplication struct {
	// The actions that are permitted to be performed on FHIR resources for the application.
	AllowedDataActions []*SmartDataActions

	// The audience that will be used to validate bearer tokens against the given authority.
	Audience *string

	// The application client id defined in the identity provider. This value will be used to validate bearer tokens against the
	// given authority.
	ClientID *string
}

SmartIdentityProviderApplication - An Application configured in the Identity Provider used to access FHIR resources.

func (SmartIdentityProviderApplication) MarshalJSON added in v2.1.0 

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

MarshalJSON implements the json.Marshaller interface for type SmartIdentityProviderApplication.

func (*SmartIdentityProviderApplication) UnmarshalJSON added in v2.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SmartIdentityProviderApplication.

type SmartIdentityProviderConfiguration added in v2.1.0 

type SmartIdentityProviderConfiguration struct {
	// The array of identity provider applications for SMART on FHIR authentication.
	Applications []*SmartIdentityProviderApplication

	// The identity provider token authority also known as the token issuing authority.
	Authority *string
}

SmartIdentityProviderConfiguration - An object to configure an identity provider for use with SMART on FHIR authentication.

func (SmartIdentityProviderConfiguration) MarshalJSON added in v2.1.0 

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

MarshalJSON implements the json.Marshaller interface for type SmartIdentityProviderConfiguration.

func (*SmartIdentityProviderConfiguration) UnmarshalJSON added in v2.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SmartIdentityProviderConfiguration.

type StorageConfiguration added in v2.1.0 

type StorageConfiguration struct {
	// The filesystem name of connected storage account.
	FileSystemName *string

	// The resource id of connected storage account.
	StorageResourceID *string
}

StorageConfiguration - The configuration of connected storage

func (StorageConfiguration) MarshalJSON added in v2.1.0 

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

MarshalJSON implements the json.Marshaller interface for type StorageConfiguration.

func (*StorageConfiguration) UnmarshalJSON added in v2.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageConfiguration.

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 TaggedResource 

type TaggedResource struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// The resource location.
	Location *string

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

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

TaggedResource - The common properties of tracked resources in the service.

func (TaggedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TaggedResource.

func (*TaggedResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TaggedResource.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type Workspace 

type Workspace struct {
	// An etag associated with the resource, used for optimistic concurrency when editing it.
	Etag *string

	// The resource location.
	Location *string

	// Workspaces resource specific properties.
	Properties *WorkspaceProperties

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

	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData

	// READ-ONLY; The resource type.
	Type *string
}

Workspace resource.

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 WorkspaceList 

type WorkspaceList struct {
	// The link used to get the next page.
	NextLink *string

	// Collection of resources.
	Value []*Workspace
}

WorkspaceList - Collection of workspace object with a next link

func (WorkspaceList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type WorkspaceList.

func (*WorkspaceList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceList.

type WorkspacePatchResource 

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

WorkspacePatchResource - Workspace patch properties

func (WorkspacePatchResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type WorkspacePatchResource.

func (*WorkspacePatchResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspacePatchResource.

type WorkspacePrivateEndpointConnectionsClient 

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

WorkspacePrivateEndpointConnectionsClient contains the methods for the WorkspacePrivateEndpointConnections group. Don't use this type directly, use NewWorkspacePrivateEndpointConnectionsClient() instead.

func NewWorkspacePrivateEndpointConnectionsClient 

func NewWorkspacePrivateEndpointConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*WorkspacePrivateEndpointConnectionsClient, error)

NewWorkspacePrivateEndpointConnectionsClient creates a new instance of WorkspacePrivateEndpointConnectionsClient with the specified values.

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

func (*WorkspacePrivateEndpointConnectionsClient) BeginCreateOrUpdate 

func (client *WorkspacePrivateEndpointConnectionsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, workspaceName string, privateEndpointConnectionName string, properties PrivateEndpointConnectionDescription, options *WorkspacePrivateEndpointConnectionsClientBeginCreateOrUpdateOptions) (*runtime.Poller[WorkspacePrivateEndpointConnectionsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Update the state of the specified private endpoint connection associated with the workspace. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • properties - The private endpoint connection properties.
  • options - WorkspacePrivateEndpointConnectionsClientBeginCreateOrUpdateOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/privatelink/WorkspaceCreatePrivateEndpointConnection.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewWorkspacePrivateEndpointConnectionsClient().BeginCreateOrUpdate(ctx, "testRG", "workspace1", "myConnection", armhealthcareapis.PrivateEndpointConnectionDescription{
	Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
		PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
			Description: to.Ptr("Auto-Approved"),
			Status:      to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
		},
	},
}, 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.PrivateEndpointConnectionDescription = armhealthcareapis.PrivateEndpointConnectionDescription{
// 	Name: to.Ptr("myConnection"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/workspaces/workspace1/privateEndpointConnections/myConnection"),
// 	Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
// 		PrivateEndpoint: &armhealthcareapis.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/c80fb759-c965-4c6a-9110-9b2b2d038882/resourceGroups/myResourceGroup/providers/Microsoft.Network/privateEndpoints/peexample01"),
// 		},
// 		PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
// 			Description: to.Ptr("Auto-Approved"),
// 			ActionsRequired: to.Ptr("None"),
// 			Status: to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
// 		},
// 		ProvisioningState: to.Ptr(armhealthcareapis.PrivateEndpointConnectionProvisioningStateSucceeded),
// 	},
// }

Output:

func (*WorkspacePrivateEndpointConnectionsClient) BeginDelete 

func (client *WorkspacePrivateEndpointConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, workspaceName string, privateEndpointConnectionName string, options *WorkspacePrivateEndpointConnectionsClientBeginDeleteOptions) (*runtime.Poller[WorkspacePrivateEndpointConnectionsClientDeleteResponse], error)

BeginDelete - Deletes a private endpoint connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • options - WorkspacePrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/privatelink/WorkspaceDeletePrivateEndpointConnection.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewWorkspacePrivateEndpointConnectionsClient().BeginDelete(ctx, "testRG", "workspace1", "myConnection", 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 (*WorkspacePrivateEndpointConnectionsClient) Get 

func (client *WorkspacePrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, privateEndpointConnectionName string, options *WorkspacePrivateEndpointConnectionsClientGetOptions) (WorkspacePrivateEndpointConnectionsClientGetResponse, error)

Get - Gets the specified private endpoint connection associated with the workspace. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • options - WorkspacePrivateEndpointConnectionsClientGetOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/privatelink/WorkspaceGetPrivateEndpointConnection.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewWorkspacePrivateEndpointConnectionsClient().Get(ctx, "testRG", "workspace1", "myConnection", 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.PrivateEndpointConnectionDescription = armhealthcareapis.PrivateEndpointConnectionDescription{
// 	Name: to.Ptr("myConnection"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/workspaces/workspace1/privateEndpointConnections/myConnection"),
// 	Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
// 		PrivateEndpoint: &armhealthcareapis.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/peexample01"),
// 		},
// 		PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
// 			Description: to.Ptr("Auto-Approved"),
// 			ActionsRequired: to.Ptr("None"),
// 			Status: to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
// 		},
// 	},
// }

Output:

func (*WorkspacePrivateEndpointConnectionsClient) NewListByWorkspacePager 

func (client *WorkspacePrivateEndpointConnectionsClient) NewListByWorkspacePager(resourceGroupName string, workspaceName string, options *WorkspacePrivateEndpointConnectionsClientListByWorkspaceOptions) *runtime.Pager[WorkspacePrivateEndpointConnectionsClientListByWorkspaceResponse]

NewListByWorkspacePager - Lists all private endpoint connections for a workspace.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • options - WorkspacePrivateEndpointConnectionsClientListByWorkspaceOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.NewListByWorkspacePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/privatelink/WorkspaceListPrivateEndpointConnections.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewWorkspacePrivateEndpointConnectionsClient().NewListByWorkspacePager("testRG", "workspace1", 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.PrivateEndpointConnectionListResultDescription = armhealthcareapis.PrivateEndpointConnectionListResultDescription{
	// 	Value: []*armhealthcareapis.PrivateEndpointConnectionDescription{
	// 		{
	// 			Name: to.Ptr("myConnection"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/privateEndpointConnections"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/workspaces/workspace1/privateEndpointConnections/myConnection"),
	// 			Properties: &armhealthcareapis.PrivateEndpointConnectionProperties{
	// 				PrivateEndpoint: &armhealthcareapis.PrivateEndpoint{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/privateEndpoints/peexample01"),
	// 				},
	// 				PrivateLinkServiceConnectionState: &armhealthcareapis.PrivateLinkServiceConnectionState{
	// 					Description: to.Ptr("Auto-Approved"),
	// 					ActionsRequired: to.Ptr("None"),
	// 					Status: to.Ptr(armhealthcareapis.PrivateEndpointServiceConnectionStatusApproved),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type WorkspacePrivateEndpointConnectionsClientBeginCreateOrUpdateOptions 

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

WorkspacePrivateEndpointConnectionsClientBeginCreateOrUpdateOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.BeginCreateOrUpdate method.

type WorkspacePrivateEndpointConnectionsClientBeginDeleteOptions 

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

WorkspacePrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.BeginDelete method.

type WorkspacePrivateEndpointConnectionsClientCreateOrUpdateResponse 

type WorkspacePrivateEndpointConnectionsClientCreateOrUpdateResponse struct {
	// The Private Endpoint Connection resource.
	PrivateEndpointConnectionDescription
}

WorkspacePrivateEndpointConnectionsClientCreateOrUpdateResponse contains the response from method WorkspacePrivateEndpointConnectionsClient.BeginCreateOrUpdate.

type WorkspacePrivateEndpointConnectionsClientDeleteResponse 

type WorkspacePrivateEndpointConnectionsClientDeleteResponse struct {
}

WorkspacePrivateEndpointConnectionsClientDeleteResponse contains the response from method WorkspacePrivateEndpointConnectionsClient.BeginDelete.

type WorkspacePrivateEndpointConnectionsClientGetOptions 

type WorkspacePrivateEndpointConnectionsClientGetOptions struct {
}

WorkspacePrivateEndpointConnectionsClientGetOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.Get method.

type WorkspacePrivateEndpointConnectionsClientGetResponse 

type WorkspacePrivateEndpointConnectionsClientGetResponse struct {
	// The Private Endpoint Connection resource.
	PrivateEndpointConnectionDescription
}

WorkspacePrivateEndpointConnectionsClientGetResponse contains the response from method WorkspacePrivateEndpointConnectionsClient.Get.

type WorkspacePrivateEndpointConnectionsClientListByWorkspaceOptions 

type WorkspacePrivateEndpointConnectionsClientListByWorkspaceOptions struct {
}

WorkspacePrivateEndpointConnectionsClientListByWorkspaceOptions contains the optional parameters for the WorkspacePrivateEndpointConnectionsClient.NewListByWorkspacePager method.

type WorkspacePrivateEndpointConnectionsClientListByWorkspaceResponse 

type WorkspacePrivateEndpointConnectionsClientListByWorkspaceResponse struct {
	// List of private endpoint connection associated with the specified storage account
	PrivateEndpointConnectionListResultDescription
}

WorkspacePrivateEndpointConnectionsClientListByWorkspaceResponse contains the response from method WorkspacePrivateEndpointConnectionsClient.NewListByWorkspacePager.

type WorkspacePrivateLinkResourcesClient 

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

WorkspacePrivateLinkResourcesClient contains the methods for the WorkspacePrivateLinkResources group. Don't use this type directly, use NewWorkspacePrivateLinkResourcesClient() instead.

func NewWorkspacePrivateLinkResourcesClient 

func NewWorkspacePrivateLinkResourcesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*WorkspacePrivateLinkResourcesClient, error)

NewWorkspacePrivateLinkResourcesClient creates a new instance of WorkspacePrivateLinkResourcesClient with the specified values.

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

func (*WorkspacePrivateLinkResourcesClient) Get 

func (client *WorkspacePrivateLinkResourcesClient) Get(ctx context.Context, resourceGroupName string, workspaceName string, groupName string, options *WorkspacePrivateLinkResourcesClientGetOptions) (WorkspacePrivateLinkResourcesClientGetResponse, error)

Get - Gets a private link resource that need to be created for a workspace. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • groupName - The name of the private link resource group.
  • options - WorkspacePrivateLinkResourcesClientGetOptions contains the optional parameters for the WorkspacePrivateLinkResourcesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/privatelink/WorkspacePrivateLinkResourceGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewWorkspacePrivateLinkResourcesClient().Get(ctx, "testRG", "workspace1", "healthcareworkspace", 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.PrivateLinkResourceDescription = armhealthcareapis.PrivateLinkResourceDescription{
// 	Name: to.Ptr("fhir"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces/privateLinkResources"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/workspaces/workspace1/privateLinkResources/fhir"),
// 	Properties: &armhealthcareapis.PrivateLinkResourceProperties{
// 		GroupID: to.Ptr("healthcareworkspace"),
// 		RequiredMembers: []*string{
// 			to.Ptr("fhirservices"),
// 			to.Ptr("dicomservices")},
// 			RequiredZoneNames: []*string{
// 				to.Ptr("privatelink.fhir.azurehealthcareapis.com"),
// 				to.Ptr("privatelink.dicom.azurehealthcareapis.com")},
// 			},
// 		}

Output:

func (*WorkspacePrivateLinkResourcesClient) NewListByWorkspacePager 

func (client *WorkspacePrivateLinkResourcesClient) NewListByWorkspacePager(resourceGroupName string, workspaceName string, options *WorkspacePrivateLinkResourcesClientListByWorkspaceOptions) *runtime.Pager[WorkspacePrivateLinkResourcesClientListByWorkspaceResponse]

NewListByWorkspacePager - Gets the private link resources that need to be created for a workspace.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • options - WorkspacePrivateLinkResourcesClientListByWorkspaceOptions contains the optional parameters for the WorkspacePrivateLinkResourcesClient.NewListByWorkspacePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/privatelink/PrivateLinkResourcesListByWorkspace.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewWorkspacePrivateLinkResourcesClient().NewListByWorkspacePager("testRG", "workspace1", 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.PrivateLinkResourceListResultDescription = armhealthcareapis.PrivateLinkResourceListResultDescription{
	// 	Value: []*armhealthcareapis.PrivateLinkResourceDescription{
	// 		{
	// 			Name: to.Ptr("healthcareworkspace"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces/privateLinkResources"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HealthcareApis/workspaces/workspace1/privateLinkResources/healthcareworkspace"),
	// 			Properties: &armhealthcareapis.PrivateLinkResourceProperties{
	// 				GroupID: to.Ptr("healthcareworkspace"),
	// 				RequiredMembers: []*string{
	// 					to.Ptr("fhirservices"),
	// 					to.Ptr("dicomservices")},
	// 					RequiredZoneNames: []*string{
	// 						to.Ptr("privatelink.fhir.azurehealthcareapis.com"),
	// 						to.Ptr("privatelink.dicom.azurehealthcareapis.com")},
	// 					},
	// 			}},
	// 		}
}

Output:

type WorkspacePrivateLinkResourcesClientGetOptions 

type WorkspacePrivateLinkResourcesClientGetOptions struct {
}

WorkspacePrivateLinkResourcesClientGetOptions contains the optional parameters for the WorkspacePrivateLinkResourcesClient.Get method.

type WorkspacePrivateLinkResourcesClientGetResponse 

type WorkspacePrivateLinkResourcesClientGetResponse struct {
	// The Private Endpoint Connection resource.
	PrivateLinkResourceDescription
}

WorkspacePrivateLinkResourcesClientGetResponse contains the response from method WorkspacePrivateLinkResourcesClient.Get.

type WorkspacePrivateLinkResourcesClientListByWorkspaceOptions 

type WorkspacePrivateLinkResourcesClientListByWorkspaceOptions struct {
}

WorkspacePrivateLinkResourcesClientListByWorkspaceOptions contains the optional parameters for the WorkspacePrivateLinkResourcesClient.NewListByWorkspacePager method.

type WorkspacePrivateLinkResourcesClientListByWorkspaceResponse 

type WorkspacePrivateLinkResourcesClientListByWorkspaceResponse struct {
	// A list of private link resources
	PrivateLinkResourceListResultDescription
}

WorkspacePrivateLinkResourcesClientListByWorkspaceResponse contains the response from method WorkspacePrivateLinkResourcesClient.NewListByWorkspacePager.

type WorkspaceProperties 

type WorkspaceProperties struct {
	// Control permission for data plane traffic coming from public networks while private endpoint is enabled.
	PublicNetworkAccess *PublicNetworkAccess

	// READ-ONLY; The list of private endpoint connections that are set up for this resource.
	PrivateEndpointConnections []*PrivateEndpointConnection

	// READ-ONLY; The provisioning state.
	ProvisioningState *ProvisioningState
}

WorkspaceProperties - Workspaces resource specific properties.

func (WorkspaceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type WorkspaceProperties.

func (*WorkspaceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceProperties.

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.
  • 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, workspace Workspace, options *WorkspacesClientBeginCreateOrUpdateOptions) (*runtime.Poller[WorkspacesClientCreateOrUpdateResponse], error)

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

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • workspace - The parameters for creating or updating a healthcare workspace.
  • 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/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/workspaces/Workspaces_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewWorkspacesClient().BeginCreateOrUpdate(ctx, "testRG", "workspace1", armhealthcareapis.Workspace{
	Location:   to.Ptr("westus"),
	Properties: &armhealthcareapis.WorkspaceProperties{},
}, 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 = armhealthcareapis.Workspace{
// 	Name: to.Ptr("workspace1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armhealthcareapis.WorkspaceProperties{
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*WorkspacesClient) BeginDelete 

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

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

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of 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/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/workspaces/Workspaces_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewWorkspacesClient().BeginDelete(ctx, "testRG", "workspace1", 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) BeginUpdate 

func (client *WorkspacesClient) BeginUpdate(ctx context.Context, resourceGroupName string, workspaceName string, workspacePatchResource WorkspacePatchResource, options *WorkspacesClientBeginUpdateOptions) (*runtime.Poller[WorkspacesClientUpdateResponse], error)

BeginUpdate - Patch workspace details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of workspace resource.
  • workspacePatchResource - The parameters for updating a specified workspace.
  • options - WorkspacesClientBeginUpdateOptions contains the optional parameters for the WorkspacesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/workspaces/Workspaces_Patch.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewWorkspacesClient().BeginUpdate(ctx, "testRG", "workspace1", armhealthcareapis.WorkspacePatchResource{
	Tags: map[string]*string{
		"tagKey": to.Ptr("tagValue"),
	},
}, 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 = armhealthcareapis.Workspace{
// 	Name: to.Ptr("workspace1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"tagKey": to.Ptr("tagValue"),
// 	},
// 	Properties: &armhealthcareapis.WorkspaceProperties{
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*WorkspacesClient) Get 

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

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

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • workspaceName - The name of 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/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/workspaces/Workspaces_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewWorkspacesClient().Get(ctx, "testRG", "workspace1", 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 = armhealthcareapis.Workspace{
// 	Name: to.Ptr("workspace1"),
// 	Type: to.Ptr("Microsoft.HealthcareApis/workspaces"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armhealthcareapis.WorkspaceProperties{
// 		ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*WorkspacesClient) NewListByResourceGroupPager 

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

NewListByResourceGroupPager - Lists all the available workspaces under the specified resource group.

Generated from API version 2024-03-31

  • resourceGroupName - The name of the resource group that contains the service instance.
  • 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/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/workspaces/Workspaces_ListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewWorkspacesClient().NewListByResourceGroupPager("testRG", 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.WorkspaceList = armhealthcareapis.WorkspaceList{
	// 	Value: []*armhealthcareapis.Workspace{
	// 		{
	// 			Name: to.Ptr("workspace1"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armhealthcareapis.WorkspaceProperties{
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*WorkspacesClient) NewListBySubscriptionPager 

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

NewListBySubscriptionPager - Lists all the available workspaces under the specified subscription.

Generated from API version 2024-03-31

  • 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/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/healthcareapis/resource-manager/Microsoft.HealthcareApis/stable/2024-03-31/examples/workspaces/Workspaces_ListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhealthcareapis.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.WorkspaceList = armhealthcareapis.WorkspaceList{
	// 	Value: []*armhealthcareapis.Workspace{
	// 		{
	// 			Name: to.Ptr("workspace1"),
	// 			Type: to.Ptr("Microsoft.HealthcareApis/workspaces"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/testRG/providers/Microsoft.HealthcareApis/workspaces/workspace1"),
	// 			Location: to.Ptr("eastus"),
	// 			Properties: &armhealthcareapis.WorkspaceProperties{
	// 				ProvisioningState: to.Ptr(armhealthcareapis.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

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 WorkspacesClientBeginUpdateOptions 

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

WorkspacesClientBeginUpdateOptions contains the optional parameters for the WorkspacesClient.BeginUpdate method.

type WorkspacesClientCreateOrUpdateResponse 

type WorkspacesClientCreateOrUpdateResponse struct {
	// Workspace resource.
	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 {
	// Workspace resource.
	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 {
	// Collection of workspace object with a next link
	WorkspaceList
}

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 {
	// Collection of workspace object with a next link
	WorkspaceList
}

WorkspacesClientListBySubscriptionResponse contains the response from method WorkspacesClient.NewListBySubscriptionPager.

type WorkspacesClientUpdateResponse 

type WorkspacesClientUpdateResponse struct {
	// Workspace resource.
	Workspace
}

WorkspacesClientUpdateResponse contains the response from method WorkspacesClient.BeginUpdate.

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.