armhealthdataaiservices

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Aug 15, 2024 License: MIT Imports: 14 Imported by: 0

README

Azure HealthDataAIServices Module for Go

PkgGoDev

The armhealthdataaiservices module provides operations for working with Azure HealthDataAIServices.

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

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices

Authorization

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

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 HealthDataAIServices 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 - Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	// ActionTypeInternal - Actions are for internal-only APIs.
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type ClientFactory 

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

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

func NewClientFactory 

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

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

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

func (*ClientFactory) NewDeidServicesClient 

func (c *ClientFactory) NewDeidServicesClient() *DeidServicesClient

NewDeidServicesClient creates a new instance of DeidServicesClient.

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) NewPrivateLinksClient 

func (c *ClientFactory) NewPrivateLinksClient() *PrivateLinksClient

NewPrivateLinksClient creates a new instance of PrivateLinksClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

const (
	// CreatedByTypeApplication - The entity was created by an application.
	CreatedByTypeApplication CreatedByType = "Application"
	// CreatedByTypeKey - The entity was created by a key.
	CreatedByTypeKey CreatedByType = "Key"
	// CreatedByTypeManagedIdentity - The entity was created by a managed identity.
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	// CreatedByTypeUser - The entity was created by a user.
	CreatedByTypeUser CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DeidPropertiesUpdate 

type DeidPropertiesUpdate struct {
	// Gets or sets allow or disallow public network access to resource
	PublicNetworkAccess *PublicNetworkAccess
}

DeidPropertiesUpdate - The template for adding optional properties.

func (DeidPropertiesUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeidPropertiesUpdate.

func (*DeidPropertiesUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeidPropertiesUpdate.

type DeidService 

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

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

	// The managed service identities assigned to this resource.
	Identity *ManagedServiceIdentity

	// The resource-specific properties for this resource.
	Properties *DeidServiceProperties

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

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

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

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

DeidService - A HealthDataAIServicesProviderHub resource

func (DeidService) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeidService.

func (*DeidService) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeidService.

type DeidServiceListResult 

type DeidServiceListResult struct {
	// REQUIRED; The DeidService items on this page
	Value []*DeidService

	// The link to the next page of items
	NextLink *string
}

DeidServiceListResult - The response of a DeidService list operation.

func (DeidServiceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeidServiceListResult.

func (*DeidServiceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeidServiceListResult.

type DeidServiceProperties 

type DeidServiceProperties struct {
	// Gets or sets allow or disallow public network access to resource
	PublicNetworkAccess *PublicNetworkAccess

	// READ-ONLY; List of private endpoint connections.
	PrivateEndpointConnections []*PrivateEndpointConnection

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Deid service url.
	ServiceURL *string
}

DeidServiceProperties - Details of the HealthDataAIServices DeidService.

func (DeidServiceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeidServiceProperties.

func (*DeidServiceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeidServiceProperties.

type DeidServicesClient 

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

DeidServicesClient contains the methods for the DeidServices group. Don't use this type directly, use NewDeidServicesClient() instead.

func NewDeidServicesClient 

func NewDeidServicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DeidServicesClient, error)

NewDeidServicesClient creates a new instance of DeidServicesClient with the specified values.

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

func (*DeidServicesClient) BeginCreate 

func (client *DeidServicesClient) BeginCreate(ctx context.Context, resourceGroupName string, deidServiceName string, resource DeidService, options *DeidServicesClientBeginCreateOptions) (*runtime.Poller[DeidServicesClientCreateResponse], error)

BeginCreate - Create a DeidService If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • resource - Resource create parameters.
  • options - DeidServicesClientBeginCreateOptions contains the optional parameters for the DeidServicesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/DeidServices_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeidServicesClient().BeginCreate(ctx, "rgopenapi", "deidTest", armhealthdataaiservices.DeidService{
		Properties: &armhealthdataaiservices.DeidServiceProperties{
			PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
		},
		Identity: &armhealthdataaiservices.ManagedServiceIdentity{
			Type:                   to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
			UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{},
		},
		Tags:     map[string]*string{},
		Location: to.Ptr("qwyhvdwcsjulggagdqxlmazcl"),
	}, 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 = armhealthdataaiservices.DeidServicesClientCreateResponse{
	// 	DeidService: &armhealthdataaiservices.DeidService{
	// 		Properties: &armhealthdataaiservices.DeidServiceProperties{
	// 			ProvisioningState: to.Ptr(armhealthdataaiservices.ProvisioningStateSucceeded),
	// 			PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
	// 			PrivateEndpointConnections: []*armhealthdataaiservices.PrivateEndpointConnection{
	// 				{
	// 					Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
	// 						PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
	// 							ID: to.Ptr("gpnxxbbtsysdhhclm"),
	// 						},
	// 						PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
	// 							Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
	// 							ActionsRequired: to.Ptr("ulb"),
	// 							Description: to.Ptr("ddxuoved"),
	// 						},
	// 						GroupIDs: []*string{
	// 							to.Ptr("xbdyjqg"),
	// 						},
	// 						ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 					},
	// 					ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih/privateEndpointConnections/mdwvqjtwcjcvrh"),
	// 					Name: to.Ptr("mdwvqjtwcjcvrh"),
	// 					Type: to.Ptr("bzxabjlpbwreez"),
	// 					SystemData: &armhealthdataaiservices.SystemData{
	// 						CreatedBy: to.Ptr("p"),
	// 						CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 						CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 						LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 						LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 						LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 					},
	// 				},
	// 			},
	// 			ServiceURL: to.Ptr("woponotsxaippkvhwmibffywnqcfru"),
	// 		},
	// 		Identity: &armhealthdataaiservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("a82361f4-5320-4a26-8d1b-45832d2164dd"),
	// 			TenantID: to.Ptr("53a6a686-ae15-4a1d-badf-3e7947918893"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("qwyhvdwcsjulggagdqxlmazcl"),
	// 		ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih"),
	// 		Name: to.Ptr("nlrthrxaukih"),
	// 		Type: to.Ptr("slyfiibvwlhfdpzjynsywhbfauexk"),
	// 		SystemData: &armhealthdataaiservices.SystemData{
	// 			CreatedBy: to.Ptr("p"),
	// 			CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 			LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DeidServicesClient) BeginDelete 

func (client *DeidServicesClient) BeginDelete(ctx context.Context, resourceGroupName string, deidServiceName string, options *DeidServicesClientBeginDeleteOptions) (*runtime.Poller[DeidServicesClientDeleteResponse], error)

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

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • options - DeidServicesClientBeginDeleteOptions contains the optional parameters for the DeidServicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/DeidServices_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeidServicesClient().BeginDelete(ctx, "rgopenapi", "deidTest", 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 (*DeidServicesClient) BeginUpdate 

func (client *DeidServicesClient) BeginUpdate(ctx context.Context, resourceGroupName string, deidServiceName string, properties DeidUpdate, options *DeidServicesClientBeginUpdateOptions) (*runtime.Poller[DeidServicesClientUpdateResponse], error)

BeginUpdate - Update a DeidService If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • properties - The resource properties to be updated.
  • options - DeidServicesClientBeginUpdateOptions contains the optional parameters for the DeidServicesClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/DeidServices_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDeidServicesClient().BeginUpdate(ctx, "rgopenapi", "deidTest", armhealthdataaiservices.DeidUpdate{
		Identity: &armhealthdataaiservices.ManagedServiceIdentityUpdate{
			Type:                   to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
			UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{},
		},
		Tags: map[string]*string{},
		Properties: &armhealthdataaiservices.DeidPropertiesUpdate{
			PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
		},
	}, 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 = armhealthdataaiservices.DeidServicesClientUpdateResponse{
	// 	DeidService: &armhealthdataaiservices.DeidService{
	// 		Properties: &armhealthdataaiservices.DeidServiceProperties{
	// 			ProvisioningState: to.Ptr(armhealthdataaiservices.ProvisioningStateSucceeded),
	// 			PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
	// 			PrivateEndpointConnections: []*armhealthdataaiservices.PrivateEndpointConnection{
	// 				{
	// 					Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
	// 						PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
	// 							ID: to.Ptr("gpnxxbbtsysdhhclm"),
	// 						},
	// 						PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
	// 							Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
	// 							ActionsRequired: to.Ptr("ulb"),
	// 							Description: to.Ptr("ddxuoved"),
	// 						},
	// 						GroupIDs: []*string{
	// 							to.Ptr("xbdyjqg"),
	// 						},
	// 						ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 					},
	// 					ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih/privateEndpointConnections/mdwvqjtwcjcvrh"),
	// 					Name: to.Ptr("mdwvqjtwcjcvrh"),
	// 					Type: to.Ptr("bzxabjlpbwreez"),
	// 					SystemData: &armhealthdataaiservices.SystemData{
	// 						CreatedBy: to.Ptr("p"),
	// 						CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 						CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 						LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 						LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 						LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 					},
	// 				},
	// 			},
	// 			ServiceURL: to.Ptr("woponotsxaippkvhwmibffywnqcfru"),
	// 		},
	// 		Identity: &armhealthdataaiservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("a82361f4-5320-4a26-8d1b-45832d2164dd"),
	// 			TenantID: to.Ptr("53a6a686-ae15-4a1d-badf-3e7947918893"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("qwyhvdwcsjulggagdqxlmazcl"),
	// 		ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih"),
	// 		Name: to.Ptr("nlrthrxaukih"),
	// 		Type: to.Ptr("slyfiibvwlhfdpzjynsywhbfauexk"),
	// 		SystemData: &armhealthdataaiservices.SystemData{
	// 			CreatedBy: to.Ptr("p"),
	// 			CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 			LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DeidServicesClient) Get 

func (client *DeidServicesClient) Get(ctx context.Context, resourceGroupName string, deidServiceName string, options *DeidServicesClientGetOptions) (DeidServicesClientGetResponse, error)

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

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • options - DeidServicesClientGetOptions contains the optional parameters for the DeidServicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/DeidServices_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDeidServicesClient().Get(ctx, "rgopenapi", "deidTest", 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 = armhealthdataaiservices.DeidServicesClientGetResponse{
	// 	DeidService: &armhealthdataaiservices.DeidService{
	// 		Properties: &armhealthdataaiservices.DeidServiceProperties{
	// 			ProvisioningState: to.Ptr(armhealthdataaiservices.ProvisioningStateSucceeded),
	// 			PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
	// 			PrivateEndpointConnections: []*armhealthdataaiservices.PrivateEndpointConnection{
	// 				{
	// 					Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
	// 						PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
	// 							ID: to.Ptr("gpnxxbbtsysdhhclm"),
	// 						},
	// 						PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
	// 							Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
	// 							ActionsRequired: to.Ptr("ulb"),
	// 							Description: to.Ptr("ddxuoved"),
	// 						},
	// 						GroupIDs: []*string{
	// 							to.Ptr("xbdyjqg"),
	// 						},
	// 						ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 					},
	// 					ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih/privateEndpointConnections/mdwvqjtwcjcvrh"),
	// 					Name: to.Ptr("mdwvqjtwcjcvrh"),
	// 					Type: to.Ptr("bzxabjlpbwreez"),
	// 					SystemData: &armhealthdataaiservices.SystemData{
	// 						CreatedBy: to.Ptr("p"),
	// 						CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 						CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 						LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 						LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 						LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 					},
	// 				},
	// 			},
	// 			ServiceURL: to.Ptr("woponotsxaippkvhwmibffywnqcfru"),
	// 		},
	// 		Identity: &armhealthdataaiservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("a82361f4-5320-4a26-8d1b-45832d2164dd"),
	// 			TenantID: to.Ptr("53a6a686-ae15-4a1d-badf-3e7947918893"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("qwyhvdwcsjulggagdqxlmazcl"),
	// 		ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih"),
	// 		Name: to.Ptr("nlrthrxaukih"),
	// 		Type: to.Ptr("slyfiibvwlhfdpzjynsywhbfauexk"),
	// 		SystemData: &armhealthdataaiservices.SystemData{
	// 			CreatedBy: to.Ptr("p"),
	// 			CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 			LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DeidServicesClient) NewListByResourceGroupPager 

func (client *DeidServicesClient) NewListByResourceGroupPager(resourceGroupName string, options *DeidServicesClientListByResourceGroupOptions) *runtime.Pager[DeidServicesClientListByResourceGroupResponse]

NewListByResourceGroupPager - List DeidService resources by resource group

Generated from API version 2024-02-28-preview

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/DeidServices_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDeidServicesClient().NewListByResourceGroupPager("rgopenapi", 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 = armhealthdataaiservices.DeidServicesClientListByResourceGroupResponse{
		// 	DeidServiceListResult: armhealthdataaiservices.DeidServiceListResult{
		// 		Value: []*armhealthdataaiservices.DeidService{
		// 			{
		// 				Properties: &armhealthdataaiservices.DeidServiceProperties{
		// 					ProvisioningState: to.Ptr(armhealthdataaiservices.ProvisioningStateSucceeded),
		// 					ServiceURL: to.Ptr("woponotsxaippkvhwmibffywnqcfru"),
		// 					PrivateEndpointConnections: []*armhealthdataaiservices.PrivateEndpointConnection{
		// 						{
		// 							Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
		// 								GroupIDs: []*string{
		// 									to.Ptr("xbdyjqg"),
		// 								},
		// 								PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
		// 									ID: to.Ptr("gpnxxbbtsysdhhclm"),
		// 								},
		// 								PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
		// 									Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
		// 									ActionsRequired: to.Ptr("ulb"),
		// 									Description: to.Ptr("ro"),
		// 								},
		// 								ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
		// 							},
		// 							ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih/privateEndpointConnections/mdwvqjtwcjcvrh"),
		// 							Name: to.Ptr("mdwvqjtwcjcvrh"),
		// 							Type: to.Ptr("bzxabjlpbwreez"),
		// 							SystemData: &armhealthdataaiservices.SystemData{
		// 								CreatedBy: to.Ptr("p"),
		// 								CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 								CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
		// 								LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
		// 								LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 								LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
		// 							},
		// 						},
		// 					},
		// 					PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
		// 				},
		// 				Identity: &armhealthdataaiservices.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("a82361f4-5320-4a26-8d1b-45832d2164dd"),
		// 					TenantID: to.Ptr("53a6a686-ae15-4a1d-badf-3e7947918893"),
		// 					Type: to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
		// 					UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Location: to.Ptr("qwyhvdwcsjulggagdqxlmazcl"),
		// 				ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih"),
		// 				Name: to.Ptr("nlrthrxaukih"),
		// 				Type: to.Ptr("slyfiibvwlhfdpzjynsywhbfauexk"),
		// 				SystemData: &armhealthdataaiservices.SystemData{
		// 					CreatedBy: to.Ptr("p"),
		// 					CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
		// 					LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

func (*DeidServicesClient) NewListBySubscriptionPager 

func (client *DeidServicesClient) NewListBySubscriptionPager(options *DeidServicesClientListBySubscriptionOptions) *runtime.Pager[DeidServicesClientListBySubscriptionResponse]

NewListBySubscriptionPager - List DeidService resources by subscription ID

Generated from API version 2024-02-28-preview

  • options - DeidServicesClientListBySubscriptionOptions contains the optional parameters for the DeidServicesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/DeidServices_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDeidServicesClient().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 = armhealthdataaiservices.DeidServicesClientListBySubscriptionResponse{
		// 	DeidServiceListResult: armhealthdataaiservices.DeidServiceListResult{
		// 		Value: []*armhealthdataaiservices.DeidService{
		// 			{
		// 				Properties: &armhealthdataaiservices.DeidServiceProperties{
		// 					ProvisioningState: to.Ptr(armhealthdataaiservices.ProvisioningStateSucceeded),
		// 					ServiceURL: to.Ptr("woponotsxaippkvhwmibffywnqcfru"),
		// 					PrivateEndpointConnections: []*armhealthdataaiservices.PrivateEndpointConnection{
		// 						{
		// 							Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
		// 								GroupIDs: []*string{
		// 									to.Ptr("xbdyjqg"),
		// 								},
		// 								PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
		// 									ID: to.Ptr("gpnxxbbtsysdhhclm"),
		// 								},
		// 								PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
		// 									Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
		// 									ActionsRequired: to.Ptr("ulb"),
		// 									Description: to.Ptr("ro"),
		// 								},
		// 								ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
		// 							},
		// 							ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih/privateEndpointConnections/mdwvqjtwcjcvrh"),
		// 							Name: to.Ptr("mdwvqjtwcjcvrh"),
		// 							Type: to.Ptr("bzxabjlpbwreez"),
		// 							SystemData: &armhealthdataaiservices.SystemData{
		// 								CreatedBy: to.Ptr("p"),
		// 								CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 								CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
		// 								LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
		// 								LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 								LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
		// 							},
		// 						},
		// 					},
		// 					PublicNetworkAccess: to.Ptr(armhealthdataaiservices.PublicNetworkAccessEnabled),
		// 				},
		// 				Identity: &armhealthdataaiservices.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("a82361f4-5320-4a26-8d1b-45832d2164dd"),
		// 					TenantID: to.Ptr("53a6a686-ae15-4a1d-badf-3e7947918893"),
		// 					Type: to.Ptr(armhealthdataaiservices.ManagedServiceIdentityTypeNone),
		// 					UserAssignedIdentities: map[string]*armhealthdataaiservices.UserAssignedIdentity{
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Location: to.Ptr("qwyhvdwcsjulggagdqxlmazcl"),
		// 				ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/nlrthrxaukih"),
		// 				Name: to.Ptr("nlrthrxaukih"),
		// 				Type: to.Ptr("slyfiibvwlhfdpzjynsywhbfauexk"),
		// 				SystemData: &armhealthdataaiservices.SystemData{
		// 					CreatedBy: to.Ptr("p"),
		// 					CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
		// 					LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type DeidServicesClientBeginCreateOptions 

type DeidServicesClientBeginCreateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DeidServicesClientBeginCreateOptions contains the optional parameters for the DeidServicesClient.BeginCreate method.

type DeidServicesClientBeginDeleteOptions 

type DeidServicesClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DeidServicesClientBeginDeleteOptions contains the optional parameters for the DeidServicesClient.BeginDelete method.

type DeidServicesClientBeginUpdateOptions 

type DeidServicesClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DeidServicesClientBeginUpdateOptions contains the optional parameters for the DeidServicesClient.BeginUpdate method.

type DeidServicesClientCreateResponse 

type DeidServicesClientCreateResponse struct {
	// A HealthDataAIServicesProviderHub resource
	DeidService
}

DeidServicesClientCreateResponse contains the response from method DeidServicesClient.BeginCreate.

type DeidServicesClientDeleteResponse 

type DeidServicesClientDeleteResponse struct {
}

DeidServicesClientDeleteResponse contains the response from method DeidServicesClient.BeginDelete.

type DeidServicesClientGetOptions 

type DeidServicesClientGetOptions struct {
}

DeidServicesClientGetOptions contains the optional parameters for the DeidServicesClient.Get method.

type DeidServicesClientGetResponse 

type DeidServicesClientGetResponse struct {
	// A HealthDataAIServicesProviderHub resource
	DeidService
}

DeidServicesClientGetResponse contains the response from method DeidServicesClient.Get.

type DeidServicesClientListByResourceGroupOptions 

type DeidServicesClientListByResourceGroupOptions struct {
}

DeidServicesClientListByResourceGroupOptions contains the optional parameters for the DeidServicesClient.NewListByResourceGroupPager method.

type DeidServicesClientListByResourceGroupResponse 

type DeidServicesClientListByResourceGroupResponse struct {
	// The response of a DeidService list operation.
	DeidServiceListResult
}

DeidServicesClientListByResourceGroupResponse contains the response from method DeidServicesClient.NewListByResourceGroupPager.

type DeidServicesClientListBySubscriptionOptions 

type DeidServicesClientListBySubscriptionOptions struct {
}

DeidServicesClientListBySubscriptionOptions contains the optional parameters for the DeidServicesClient.NewListBySubscriptionPager method.

type DeidServicesClientListBySubscriptionResponse 

type DeidServicesClientListBySubscriptionResponse struct {
	// The response of a DeidService list operation.
	DeidServiceListResult
}

DeidServicesClientListBySubscriptionResponse contains the response from method DeidServicesClient.NewListBySubscriptionPager.

type DeidServicesClientUpdateResponse 

type DeidServicesClientUpdateResponse struct {
	// A HealthDataAIServicesProviderHub resource
	DeidService
}

DeidServicesClientUpdateResponse contains the response from method DeidServicesClient.BeginUpdate.

type DeidUpdate 

type DeidUpdate struct {
	// Updatable managed service identity
	Identity *ManagedServiceIdentityUpdate

	// RP-specific properties
	Properties *DeidPropertiesUpdate

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

DeidUpdate - Patch request body for DeidService

func (DeidUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DeidUpdate.

func (*DeidUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DeidUpdate.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; The type of managed identity assigned to this resource.
	Type *ManagedServiceIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity

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

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

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

func (ManagedServiceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

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

const (
	// ManagedServiceIdentityTypeNone - No managed identity.
	ManagedServiceIdentityTypeNone ManagedServiceIdentityType = "None"
	// ManagedServiceIdentityTypeSystemAndUserAssigned - System and user assigned managed identity.
	ManagedServiceIdentityTypeSystemAndUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	// ManagedServiceIdentityTypeSystemAssigned - System assigned managed identity.
	ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned"
	// ManagedServiceIdentityTypeUserAssigned - User assigned managed identity.
	ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type ManagedServiceIdentityUpdate 

type ManagedServiceIdentityUpdate struct {
	// The type of managed identity assigned to this resource.
	Type *ManagedServiceIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity
}

ManagedServiceIdentityUpdate - The template for adding optional properties.

func (ManagedServiceIdentityUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentityUpdate.

func (*ManagedServiceIdentityUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentityUpdate.

type Operation 

type Operation struct {
	// Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Localized display information for this particular operation.
	Display *OperationDisplay

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

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for and operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// REQUIRED; The Operation items on this page
	Value []*Operation

	// The link to the next page of items
	NextLink *string
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type 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 - List the operations for the provider

Generated from API version 2024-02-28-preview

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/Operations_List_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("<subscriptionID>", 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 = armhealthdataaiservices.OperationsClientListResponse{
		// 	OperationListResult: armhealthdataaiservices.OperationListResult{
		// 		Value: []*armhealthdataaiservices.Operation{
		// 			{
		// 				Name: to.Ptr("vlozcqymdxttexvmhouwzob"),
		// 				IsDataAction: to.Ptr(true),
		// 				Display: &armhealthdataaiservices.OperationDisplay{
		// 					Provider: to.Ptr("hwy"),
		// 					Resource: to.Ptr("yxabgnzjshmqldqthxonpam"),
		// 					Operation: to.Ptr("quwaawjasjgpqhskxoxzx"),
		// 					Description: to.Ptr("ayqiodducsbwvzcgno"),
		// 				},
		// 				Origin: to.Ptr(armhealthdataaiservices.OriginUser),
		// 				ActionType: to.Ptr(armhealthdataaiservices.ActionTypeInternal),
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:
Example (OperationsListMaximumSetGeneratedByMaximumSetRuleGeneratedByMinimumSetRule)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/Operations_List_MinimumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("<subscriptionID>", 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 = armhealthdataaiservices.OperationsClientListResponse{
		// 	OperationListResult: armhealthdataaiservices.OperationListResult{
		// 	},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	// OriginSystem - Indicates the operation is initiated by a system.
	OriginSystem Origin = "system"
	// OriginUser - Indicates the operation is initiated by a user.
	OriginUser Origin = "user"
	// OriginUserSystem - Indicates the operation is initiated by a user or system.
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// READ-ONLY; The resource 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 {
	// The private endpoint connection 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; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

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 PrivateEndpointConnectionProperties 

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

	// The private endpoint resource.
	PrivateEndpoint *PrivateEndpoint

	// READ-ONLY; The group ids for the private endpoint resource.
	GroupIDs []*string

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

PrivateEndpointConnectionProperties - Properties of the private endpoint connection.

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 - Connection is being created
	PrivateEndpointConnectionProvisioningStateCreating PrivateEndpointConnectionProvisioningState = "Creating"
	// PrivateEndpointConnectionProvisioningStateDeleting - Connection is being deleted
	PrivateEndpointConnectionProvisioningStateDeleting PrivateEndpointConnectionProvisioningState = "Deleting"
	// PrivateEndpointConnectionProvisioningStateFailed - Connection provisioning has failed
	PrivateEndpointConnectionProvisioningStateFailed PrivateEndpointConnectionProvisioningState = "Failed"
	// PrivateEndpointConnectionProvisioningStateSucceeded - Connection has been provisioned
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionResource 

type PrivateEndpointConnectionResource struct {
	// The resource-specific properties for this resource.
	Properties *PrivateEndpointConnectionProperties

	// READ-ONLY; The name of the private endpoint connection associated with the Azure resource.
	Name *string

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

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

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

PrivateEndpointConnectionResource - Holder for private endpoint connections

func (PrivateEndpointConnectionResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionResource.

func (*PrivateEndpointConnectionResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionResource.

type PrivateEndpointConnectionResourceListResult 

type PrivateEndpointConnectionResourceListResult struct {
	// REQUIRED; The PrivateEndpointConnectionResource items on this page
	Value []*PrivateEndpointConnectionResource

	// The link to the next page of items
	NextLink *string
}

PrivateEndpointConnectionResourceListResult - The response of a PrivateEndpointConnectionResource list operation.

func (PrivateEndpointConnectionResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionResourceListResult.

func (*PrivateEndpointConnectionResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionResourceListResult.

type PrivateEndpointConnectionsClient 

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

PrivateEndpointConnectionsClient - Private connection operations 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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PrivateEndpointConnectionsClient) BeginCreate 

func (client *PrivateEndpointConnectionsClient) BeginCreate(ctx context.Context, resourceGroupName string, deidServiceName string, privateEndpointConnectionName string, resource PrivateEndpointConnectionResource, options *PrivateEndpointConnectionsClientBeginCreateOptions) (*runtime.Poller[PrivateEndpointConnectionsClientCreateResponse], error)

BeginCreate - Create a Private endpoint connection If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource.
  • resource - Resource create parameters.
  • options - PrivateEndpointConnectionsClientBeginCreateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/PrivateEndpointConnections_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginCreate(ctx, "rgopenapi", "deidTest", "kgwgrrpabvrsrrvpcgcnfmyfgyrl", armhealthdataaiservices.PrivateEndpointConnectionResource{
		Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
			PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{},
			PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
				Status:          to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
				ActionsRequired: to.Ptr("ulb"),
				Description:     to.Ptr("xr"),
			},
		},
	}, 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 = armhealthdataaiservices.PrivateEndpointConnectionsClientCreateResponse{
	// 	PrivateEndpointConnectionResource: &armhealthdataaiservices.PrivateEndpointConnectionResource{
	// 		Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
	// 				ID: to.Ptr("gpnxxbbtsysdhhclm"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
	// 				Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
	// 				ActionsRequired: to.Ptr("ulb"),
	// 				Description: to.Ptr("xr"),
	// 			},
	// 			GroupIDs: []*string{
	// 				to.Ptr("xbdyjqg"),
	// 			},
	// 			ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/deidTest/privateEndpointConnections/aduyb"),
	// 		Name: to.Ptr("aduyb"),
	// 		Type: to.Ptr("umjjkodjuhccrngl"),
	// 		SystemData: &armhealthdataaiservices.SystemData{
	// 			CreatedBy: to.Ptr("p"),
	// 			CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 			LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*PrivateEndpointConnectionsClient) BeginDelete 

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

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

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • 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/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/PrivateEndpointConnections_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginDelete(ctx, "rgopenapi", "deidTest", "kgwgrrpabvrsrrvpcgcnfmyfgyrl", 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, deidServiceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientGetOptions) (PrivateEndpointConnectionsClientGetResponse, error)

Get - Get a specific private connection If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • 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/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/PrivateEndpointConnections_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "rgopenapi", "deidTest", "kgwgrrpabvrsrrvpcgcnfmyfgyrl", 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 = armhealthdataaiservices.PrivateEndpointConnectionsClientGetResponse{
	// 	PrivateEndpointConnectionResource: &armhealthdataaiservices.PrivateEndpointConnectionResource{
	// 		Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
	// 				ID: to.Ptr("gpnxxbbtsysdhhclm"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
	// 				Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
	// 				ActionsRequired: to.Ptr("ulb"),
	// 				Description: to.Ptr("xr"),
	// 			},
	// 			GroupIDs: []*string{
	// 				to.Ptr("xbdyjqg"),
	// 			},
	// 			ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/deidTest/privateEndpointConnections/aduyb"),
	// 		Name: to.Ptr("aduyb"),
	// 		Type: to.Ptr("umjjkodjuhccrngl"),
	// 		SystemData: &armhealthdataaiservices.SystemData{
	// 			CreatedBy: to.Ptr("p"),
	// 			CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
	// 			LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*PrivateEndpointConnectionsClient) NewListByDeidServicePager 

func (client *PrivateEndpointConnectionsClient) NewListByDeidServicePager(resourceGroupName string, deidServiceName string, options *PrivateEndpointConnectionsClientListByDeidServiceOptions) *runtime.Pager[PrivateEndpointConnectionsClientListByDeidServiceResponse]

NewListByDeidServicePager - List private endpoint connections on the given resource

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • options - PrivateEndpointConnectionsClientListByDeidServiceOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByDeidServicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/PrivateEndpointConnections_ListByDeidService_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateEndpointConnectionsClient().NewListByDeidServicePager("rgopenapi", "deidTest", 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 = armhealthdataaiservices.PrivateEndpointConnectionsClientListByDeidServiceResponse{
		// 	PrivateEndpointConnectionResourceListResult: armhealthdataaiservices.PrivateEndpointConnectionResourceListResult{
		// 		Value: []*armhealthdataaiservices.PrivateEndpointConnectionResource{
		// 			{
		// 				Properties: &armhealthdataaiservices.PrivateEndpointConnectionProperties{
		// 					PrivateEndpoint: &armhealthdataaiservices.PrivateEndpoint{
		// 						ID: to.Ptr("gpnxxbbtsysdhhclm"),
		// 					},
		// 					PrivateLinkServiceConnectionState: &armhealthdataaiservices.PrivateLinkServiceConnectionState{
		// 						Status: to.Ptr(armhealthdataaiservices.PrivateEndpointServiceConnectionStatusPending),
		// 						ActionsRequired: to.Ptr("ulb"),
		// 						Description: to.Ptr("mmvcleuufspfrojjveuith"),
		// 					},
		// 					GroupIDs: []*string{
		// 						to.Ptr("xbdyjqg"),
		// 					},
		// 					ProvisioningState: to.Ptr(armhealthdataaiservices.PrivateEndpointConnectionProvisioningStateSucceeded),
		// 				},
		// 				ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/deidTest/privateEndpointConnections/aduyb"),
		// 				Name: to.Ptr("aduyb"),
		// 				Type: to.Ptr("umjjkodjuhccrngl"),
		// 				SystemData: &armhealthdataaiservices.SystemData{
		// 					CreatedBy: to.Ptr("p"),
		// 					CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
		// 					LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type PrivateEndpointConnectionsClientBeginCreateOptions 

type PrivateEndpointConnectionsClientBeginCreateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

PrivateEndpointConnectionsClientBeginCreateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginCreate method.

type PrivateEndpointConnectionsClientBeginDeleteOptions 

type PrivateEndpointConnectionsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

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

type PrivateEndpointConnectionsClientCreateResponse 

type PrivateEndpointConnectionsClientCreateResponse struct {
	// Holder for private endpoint connections
	PrivateEndpointConnectionResource
}

PrivateEndpointConnectionsClientCreateResponse contains the response from method PrivateEndpointConnectionsClient.BeginCreate.

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 {
	// Holder for private endpoint connections
	PrivateEndpointConnectionResource
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListByDeidServiceOptions 

type PrivateEndpointConnectionsClientListByDeidServiceOptions struct {
}

PrivateEndpointConnectionsClientListByDeidServiceOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByDeidServicePager method.

type PrivateEndpointConnectionsClientListByDeidServiceResponse 

type PrivateEndpointConnectionsClientListByDeidServiceResponse struct {
	// The response of a PrivateEndpointConnectionResource list operation.
	PrivateEndpointConnectionResourceListResult
}

PrivateEndpointConnectionsClientListByDeidServiceResponse contains the response from method PrivateEndpointConnectionsClient.NewListByDeidServicePager.

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string

PrivateEndpointServiceConnectionStatus - The private endpoint connection status. 

const (
	// PrivateEndpointServiceConnectionStatusApproved - Connection approved
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
	// PrivateEndpointServiceConnectionStatusPending - Connectionaiting for approval or rejection
	PrivateEndpointServiceConnectionStatusPending PrivateEndpointServiceConnectionStatus = "Pending"
	// PrivateEndpointServiceConnectionStatusRejected - Connection Rejected
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
)

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// The resource-specific properties for this resource.
	Properties *PrivateLinkResourceProperties

	// READ-ONLY; The name of the private link associated with the Azure resource.
	Name *string

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

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

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

PrivateLinkResource - Private Links for DeidService 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 PrivateLinkResourceListResult 

type PrivateLinkResourceListResult struct {
	// REQUIRED; The PrivateLinkResource items on this page
	Value []*PrivateLinkResource

	// The link to the next page of items
	NextLink *string
}

PrivateLinkResourceListResult - The response of a PrivateLinkResource list operation.

func (PrivateLinkResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceListResult.

func (*PrivateLinkResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceListResult.

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 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 PrivateLinksClient 

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

PrivateLinksClient - Operations for private links on DeidService resource Don't use this type directly, use NewPrivateLinksClient() instead.

func NewPrivateLinksClient 

func NewPrivateLinksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateLinksClient, error)

NewPrivateLinksClient creates a new instance of PrivateLinksClient with the specified values.

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

func (*PrivateLinksClient) NewListByDeidServicePager 

func (client *PrivateLinksClient) NewListByDeidServicePager(resourceGroupName string, deidServiceName string, options *PrivateLinksClientListByDeidServiceOptions) *runtime.Pager[PrivateLinksClientListByDeidServiceResponse]

NewListByDeidServicePager - List private links on the given resource

Generated from API version 2024-02-28-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • deidServiceName - The name of the deid service
  • options - PrivateLinksClientListByDeidServiceOptions contains the optional parameters for the PrivateLinksClient.NewListByDeidServicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/925b1febaaebc3e1d602c765168e8ddabc7153a5/specification/healthdataaiservices/HealthDataAIServices.Management/examples/2024-02-28-preview/PrivateLinks_ListByDeidService_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthdataaiservices/armhealthdataaiservices"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthdataaiservices.NewClientFactory("F21BB31B-C214-42C0-ACF0-DACCA05D3011", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateLinksClient().NewListByDeidServicePager("rgopenapi", "deidTest", 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 = armhealthdataaiservices.PrivateLinksClientListByDeidServiceResponse{
		// 	PrivateLinkResourceListResult: armhealthdataaiservices.PrivateLinkResourceListResult{
		// 		Value: []*armhealthdataaiservices.PrivateLinkResource{
		// 			{
		// 				Properties: &armhealthdataaiservices.PrivateLinkResourceProperties{
		// 					GroupID: to.Ptr("flaloakbdcqjisfhfnkrxmt"),
		// 					RequiredMembers: []*string{
		// 						to.Ptr("wbraaugftjqa"),
		// 					},
		// 					RequiredZoneNames: []*string{
		// 						to.Ptr("ndsmc"),
		// 					},
		// 				},
		// 				ID: to.Ptr("/subscriptions/F21BB31B-C214-42C0-ACF0-DACCA05D3011/resourceGroups/rgopenapi/providers/Microsoft.HealthDataAIServices/deidServices/deidTest/privateLinkResources/rmptbzejhgxhlfpdizsekhsq"),
		// 				Name: to.Ptr("rmptbzejhgxhlfpdizsekhsq"),
		// 				Type: to.Ptr("lplbvyjkvsujegzqr"),
		// 				SystemData: &armhealthdataaiservices.SystemData{
		// 					CreatedBy: to.Ptr("p"),
		// 					CreatedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.985Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("pmbozfvwrblbknedeb"),
		// 					LastModifiedByType: to.Ptr(armhealthdataaiservices.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-13T19:47:24.986Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/arzijt"),
		// 	},
		// }
	}
}

Output:

type PrivateLinksClientListByDeidServiceOptions 

type PrivateLinksClientListByDeidServiceOptions struct {
}

PrivateLinksClientListByDeidServiceOptions contains the optional parameters for the PrivateLinksClient.NewListByDeidServicePager method.

type PrivateLinksClientListByDeidServiceResponse 

type PrivateLinksClientListByDeidServiceResponse struct {
	// The response of a PrivateLinkResource list operation.
	PrivateLinkResourceListResult
}

PrivateLinksClientListByDeidServiceResponse contains the response from method PrivateLinksClient.NewListByDeidServicePager.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The status of the current operation. 

const (
	// ProvisioningStateAccepted - The resource provisioning request has been accepted.
	ProvisioningStateAccepted ProvisioningState = "Accepted"
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateDeleting - The resource is being deleted.
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateProvisioning - The resource is being provisioned.
	ProvisioningStateProvisioning ProvisioningState = "Provisioning"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - The resource is being updated.
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type PublicNetworkAccess 

type PublicNetworkAccess string

PublicNetworkAccess - State of the public network access. 

const (
	// PublicNetworkAccessDisabled - The public network access is disabled
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	// PublicNetworkAccessEnabled - The public network access is enabled
	PublicNetworkAccessEnabled PublicNetworkAccess = "Enabled"
)

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type 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.

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.