armhealthbot

package module
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Nov 24, 2023 License: MIT Imports: 14 Imported by: 2

README

Azure Health Bot Module for Go

PkgGoDev

The armhealthbot module provides operations for working with Azure Health Bot.

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 Health Bot module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthbot/armhealthbot

Authorization

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

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 Health Bot 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 AvailableOperations 

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

	// Collection of available operation details
	Value []*OperationDetail
}

AvailableOperations - Available operations of the service

func (AvailableOperations) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvailableOperations.

func (*AvailableOperations) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvailableOperations.

type BotResponseList 

type BotResponseList struct {
	// READ-ONLY; The link used to get the next page of bot service resources.
	NextLink *string

	// READ-ONLY; Gets the list of Azure Health Bot results and their properties.
	Value []*HealthBot
}

BotResponseList - The list of Azure Health Bot operation response.

func (BotResponseList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BotResponseList.

func (*BotResponseList) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BotResponseList.

type BotsClient 

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

BotsClient contains the methods for the Bots group. Don't use this type directly, use NewBotsClient() instead.

func NewBotsClient 

func NewBotsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BotsClient, error)

NewBotsClient creates a new instance of BotsClient with the specified values.

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

func (*BotsClient) BeginCreate 

func (client *BotsClient) BeginCreate(ctx context.Context, resourceGroupName string, botName string, parameters HealthBot, options *BotsClientBeginCreateOptions) (*runtime.Poller[BotsClientCreateResponse], error)

BeginCreate - Create a new Azure Health Bot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-10

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • botName - The name of the Bot resource.
  • parameters - The parameters to provide for the created Azure Health Bot.
  • options - BotsClientBeginCreateOptions contains the optional parameters for the BotsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/ResourceCreationPut.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthbot.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBotsClient().BeginCreate(ctx, "healthbotClient", "samplebotname", armhealthbot.HealthBot{
		Location: to.Ptr("East US"),
		Identity: &armhealthbot.Identity{
			Type: to.Ptr(armhealthbot.ResourceIdentityTypeSystemAssignedUserAssigned),
			UserAssignedIdentities: map[string]*armhealthbot.UserAssignedIdentity{
				"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi":  {},
				"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi2": {},
			},
		},
		SKU: &armhealthbot.SKU{
			Name: to.Ptr(armhealthbot.SKUNameF0),
		},
	}, 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.HealthBot = armhealthbot.HealthBot{
	// 	Name: to.Ptr("samplebotname"),
	// 	Type: to.Ptr("Microsoft.HealthBot/healthBots"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.HealthBot/healthBots/samplebotname"),
	// 	SystemData: &armhealthbot.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-05T17:18:19.123Z"); return t}()),
	// 		CreatedBy: to.Ptr("jack@outlook.com"),
	// 		CreatedByType: to.Ptr(armhealthbot.IdentityTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-06T17:18:19.123Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("ryan@outlook.com"),
	// 		LastModifiedByType: to.Ptr(armhealthbot.IdentityTypeUser),
	// 	},
	// 	Location: to.Ptr("East US"),
	// 	Identity: &armhealthbot.Identity{
	// 		Type: to.Ptr(armhealthbot.ResourceIdentityTypeSystemAssignedUserAssigned),
	// 		PrincipalID: to.Ptr("principalId"),
	// 		TenantID: to.Ptr("tenantId"),
	// 		UserAssignedIdentities: map[string]*armhealthbot.UserAssignedIdentity{
	// 			"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi": &armhealthbot.UserAssignedIdentity{
	// 			},
	// 			"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi2": &armhealthbot.UserAssignedIdentity{
	// 			},
	// 		},
	// 	},
	// 	Properties: &armhealthbot.Properties{
	// 		BotManagementPortalLink: to.Ptr("https://us.healthbot.microsoft.com/account/contoso"),
	// 	},
	// 	SKU: &armhealthbot.SKU{
	// 		Name: to.Ptr(armhealthbot.SKUNameF0),
	// 	},
	// }
}

Output:

func (*BotsClient) BeginDelete 

func (client *BotsClient) BeginDelete(ctx context.Context, resourceGroupName string, botName string, options *BotsClientBeginDeleteOptions) (*runtime.Poller[BotsClientDeleteResponse], error)

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

Generated from API version 2021-06-10

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • botName - The name of the Bot resource.
  • options - BotsClientBeginDeleteOptions contains the optional parameters for the BotsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/ResourceDeletionDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthbot/armhealthbot"
)

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

func (client *BotsClient) Get(ctx context.Context, resourceGroupName string, botName string, options *BotsClientGetOptions) (BotsClientGetResponse, error)

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

Generated from API version 2021-06-10

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • botName - The name of the Bot resource.
  • options - BotsClientGetOptions contains the optional parameters for the BotsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/ResourceInfoGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthbot/armhealthbot"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthbot.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotsClient().Get(ctx, "healthbotClient", "samplebotname", 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.HealthBot = armhealthbot.HealthBot{
	// 	Name: to.Ptr("samplebotname"),
	// 	Type: to.Ptr("Microsoft.HealthBot/healthBots"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.HealthBot/healthBots/samplebotname"),
	// 	SystemData: &armhealthbot.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-05T17:18:19.123Z"); return t}()),
	// 		CreatedBy: to.Ptr("jack@outlook.com"),
	// 		CreatedByType: to.Ptr(armhealthbot.IdentityTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-06T17:18:19.123Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("ryan@outlook.com"),
	// 		LastModifiedByType: to.Ptr(armhealthbot.IdentityTypeUser),
	// 	},
	// 	Location: to.Ptr("East US"),
	// 	Identity: &armhealthbot.Identity{
	// 		Type: to.Ptr(armhealthbot.ResourceIdentityTypeSystemAssignedUserAssigned),
	// 		PrincipalID: to.Ptr("principalId"),
	// 		TenantID: to.Ptr("tenantId"),
	// 		UserAssignedIdentities: map[string]*armhealthbot.UserAssignedIdentity{
	// 			"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi": &armhealthbot.UserAssignedIdentity{
	// 			},
	// 			"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi2": &armhealthbot.UserAssignedIdentity{
	// 			},
	// 		},
	// 	},
	// 	Properties: &armhealthbot.Properties{
	// 		BotManagementPortalLink: to.Ptr("https://us.healthbot.microsoft.com/account/contoso"),
	// 	},
	// 	SKU: &armhealthbot.SKU{
	// 		Name: to.Ptr(armhealthbot.SKUNameF0),
	// 	},
	// }
}

Output:

func (*BotsClient) NewListByResourceGroupPager added in v0.4.0 

func (client *BotsClient) NewListByResourceGroupPager(resourceGroupName string, options *BotsClientListByResourceGroupOptions) *runtime.Pager[BotsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Returns all the resources of a particular type belonging to a resource group

Generated from API version 2021-06-10

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • options - BotsClientListByResourceGroupOptions contains the optional parameters for the BotsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/ListBotsByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthbot/armhealthbot"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthbot.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBotsClient().NewListByResourceGroupPager("OneResourceGroupName", 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.BotResponseList = armhealthbot.BotResponseList{
		// 	Value: []*armhealthbot.HealthBot{
		// 		{
		// 			Name: to.Ptr("samplebotname"),
		// 			Type: to.Ptr("Microsoft.HealthBot/healthBots"),
		// 			ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.HealthBot/healthBots/samplebotname"),
		// 			SystemData: &armhealthbot.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-05T17:18:19.123Z"); return t}()),
		// 				CreatedBy: to.Ptr("jack@outlook.com"),
		// 				CreatedByType: to.Ptr(armhealthbot.IdentityTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-06T17:18:19.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("ryan@outlook.com"),
		// 				LastModifiedByType: to.Ptr(armhealthbot.IdentityTypeUser),
		// 			},
		// 			Location: to.Ptr("East US"),
		// 			Properties: &armhealthbot.Properties{
		// 				BotManagementPortalLink: to.Ptr("https://us.healthbot.microsoft.com/account/samplebotname-1yhd91k"),
		// 			},
		// 			SKU: &armhealthbot.SKU{
		// 				Name: to.Ptr(armhealthbot.SKUNameF0),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("samplebotname2"),
		// 			Type: to.Ptr("Microsoft.HealthBot/healthBots"),
		// 			ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.HealthBot/healthBots/samplebotname2"),
		// 			SystemData: &armhealthbot.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-05T17:18:19.123Z"); return t}()),
		// 				CreatedBy: to.Ptr("jack@outlook.com"),
		// 				CreatedByType: to.Ptr(armhealthbot.IdentityTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-06T17:18:19.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("ryan@outlook.com"),
		// 				LastModifiedByType: to.Ptr(armhealthbot.IdentityTypeUser),
		// 			},
		// 			Location: to.Ptr("East US"),
		// 			Identity: &armhealthbot.Identity{
		// 				Type: to.Ptr(armhealthbot.ResourceIdentityTypeSystemAssignedUserAssigned),
		// 				PrincipalID: to.Ptr("principalId"),
		// 				TenantID: to.Ptr("tenantId"),
		// 				UserAssignedIdentities: map[string]*armhealthbot.UserAssignedIdentity{
		// 					"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi": &armhealthbot.UserAssignedIdentity{
		// 					},
		// 					"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi2": &armhealthbot.UserAssignedIdentity{
		// 					},
		// 				},
		// 			},
		// 			Properties: &armhealthbot.Properties{
		// 				BotManagementPortalLink: to.Ptr("https://us.healthbot.microsoft.com/account/samplebotname2-hdi1osc"),
		// 			},
		// 			SKU: &armhealthbot.SKU{
		// 				Name: to.Ptr(armhealthbot.SKUNameS1),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*BotsClient) NewListPager added in v0.4.0 

func (client *BotsClient) NewListPager(options *BotsClientListOptions) *runtime.Pager[BotsClientListResponse]

NewListPager - Returns all the resources of a particular type belonging to a subscription.

Generated from API version 2021-06-10

  • options - BotsClientListOptions contains the optional parameters for the BotsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/ListBotsBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthbot/armhealthbot"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthbot.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBotsClient().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.BotResponseList = armhealthbot.BotResponseList{
		// 	Value: []*armhealthbot.HealthBot{
		// 		{
		// 			Name: to.Ptr("samplebotname2"),
		// 			Type: to.Ptr("Microsoft.HealthBot/healthBots"),
		// 			ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.HealthBot/healthBots/samplebotname2"),
		// 			SystemData: &armhealthbot.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-05T17:18:19.123Z"); return t}()),
		// 				CreatedBy: to.Ptr("jack@outlook.com"),
		// 				CreatedByType: to.Ptr(armhealthbot.IdentityTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-06T17:18:19.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("ryan@outlook.com"),
		// 				LastModifiedByType: to.Ptr(armhealthbot.IdentityTypeUser),
		// 			},
		// 			Location: to.Ptr("East US"),
		// 			Identity: &armhealthbot.Identity{
		// 				Type: to.Ptr(armhealthbot.ResourceIdentityTypeSystemAssignedUserAssigned),
		// 				PrincipalID: to.Ptr("principalId"),
		// 				TenantID: to.Ptr("tenantId"),
		// 				UserAssignedIdentities: map[string]*armhealthbot.UserAssignedIdentity{
		// 					"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi": &armhealthbot.UserAssignedIdentity{
		// 					},
		// 					"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi2": &armhealthbot.UserAssignedIdentity{
		// 					},
		// 				},
		// 			},
		// 			Properties: &armhealthbot.Properties{
		// 				BotManagementPortalLink: to.Ptr("https://us.healthbot.microsoft.com/account/samplebotname2-hdi1osc"),
		// 			},
		// 			SKU: &armhealthbot.SKU{
		// 				Name: to.Ptr(armhealthbot.SKUNameS1),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*BotsClient) Update 

func (client *BotsClient) Update(ctx context.Context, resourceGroupName string, botName string, parameters UpdateParameters, options *BotsClientUpdateOptions) (BotsClientUpdateResponse, error)

Update - Patch a HealthBot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-10

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • botName - The name of the Bot resource.
  • parameters - The parameters to provide for the required Azure Health Bot.
  • options - BotsClientUpdateOptions contains the optional parameters for the BotsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/ResourceUpdatePatch.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthbot.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotsClient().Update(ctx, "healthbotClient", "samplebotname", armhealthbot.UpdateParameters{
		SKU: &armhealthbot.SKU{
			Name: to.Ptr(armhealthbot.SKUNameF0),
		},
	}, 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.HealthBot = armhealthbot.HealthBot{
	// 	Name: to.Ptr("samplebotname"),
	// 	Type: to.Ptr("Microsoft.HealthBot/healthBots"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.HealthBot/healthBots/samplebotname"),
	// 	SystemData: &armhealthbot.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-05T17:18:19.123Z"); return t}()),
	// 		CreatedBy: to.Ptr("jack@outlook.com"),
	// 		CreatedByType: to.Ptr(armhealthbot.IdentityTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-06T17:18:19.123Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("ryan@outlook.com"),
	// 		LastModifiedByType: to.Ptr(armhealthbot.IdentityTypeUser),
	// 	},
	// 	Location: to.Ptr("East US"),
	// 	Identity: &armhealthbot.Identity{
	// 		Type: to.Ptr(armhealthbot.ResourceIdentityTypeSystemAssignedUserAssigned),
	// 		PrincipalID: to.Ptr("principalId"),
	// 		TenantID: to.Ptr("tenantId"),
	// 		UserAssignedIdentities: map[string]*armhealthbot.UserAssignedIdentity{
	// 			"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi": &armhealthbot.UserAssignedIdentity{
	// 			},
	// 			"/subscriptions/subscription-id/resourcegroups/myrg/providers/microsoft.managedidentity/userassignedidentities/my-mi2": &armhealthbot.UserAssignedIdentity{
	// 			},
	// 		},
	// 	},
	// 	Properties: &armhealthbot.Properties{
	// 		BotManagementPortalLink: to.Ptr("https://us.healthbot.microsoft.com/account/contoso"),
	// 	},
	// 	SKU: &armhealthbot.SKU{
	// 		Name: to.Ptr(armhealthbot.SKUNameF0),
	// 	},
	// }
}

Output:

type BotsClientBeginCreateOptions added in v0.2.0 

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

BotsClientBeginCreateOptions contains the optional parameters for the BotsClient.BeginCreate method.

type BotsClientBeginDeleteOptions added in v0.2.0 

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

BotsClientBeginDeleteOptions contains the optional parameters for the BotsClient.BeginDelete method.

type BotsClientCreateResponse added in v0.2.0 

type BotsClientCreateResponse struct {
	// Azure Health Bot resource definition
	HealthBot
}

BotsClientCreateResponse contains the response from method BotsClient.BeginCreate.

type BotsClientDeleteResponse added in v0.2.0 

type BotsClientDeleteResponse struct {
}

BotsClientDeleteResponse contains the response from method BotsClient.BeginDelete.

type BotsClientGetOptions added in v0.2.0 

type BotsClientGetOptions struct {
}

BotsClientGetOptions contains the optional parameters for the BotsClient.Get method.

type BotsClientGetResponse added in v0.2.0 

type BotsClientGetResponse struct {
	// Azure Health Bot resource definition
	HealthBot
}

BotsClientGetResponse contains the response from method BotsClient.Get.

type BotsClientListByResourceGroupOptions added in v0.2.0 

type BotsClientListByResourceGroupOptions struct {
}

BotsClientListByResourceGroupOptions contains the optional parameters for the BotsClient.NewListByResourceGroupPager method.

type BotsClientListByResourceGroupResponse added in v0.2.0 

type BotsClientListByResourceGroupResponse struct {
	// The list of Azure Health Bot operation response.
	BotResponseList
}

BotsClientListByResourceGroupResponse contains the response from method BotsClient.NewListByResourceGroupPager.

type BotsClientListOptions added in v0.2.0 

type BotsClientListOptions struct {
}

BotsClientListOptions contains the optional parameters for the BotsClient.NewListPager method.

type BotsClientListResponse added in v0.2.0 

type BotsClientListResponse struct {
	// The list of Azure Health Bot operation response.
	BotResponseList
}

BotsClientListResponse contains the response from method BotsClient.NewListPager.

type BotsClientUpdateOptions added in v0.2.0 

type BotsClientUpdateOptions struct {
}

BotsClientUpdateOptions contains the optional parameters for the BotsClient.Update method.

type BotsClientUpdateResponse added in v0.2.0 

type BotsClientUpdateResponse struct {
	// Azure Health Bot resource definition
	HealthBot
}

BotsClientUpdateResponse contains the response from method BotsClient.Update.

type ClientFactory added in v1.1.0 

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 added in v1.1.0 

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

func (*ClientFactory) NewBotsClient added in v1.1.0 

func (c *ClientFactory) NewBotsClient() *BotsClient

NewBotsClient creates a new instance of BotsClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type Error 

type Error struct {
	// The error object.
	Error *ErrorError
}

Error - The resource management error response.

func (Error) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type Error.

func (*Error) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Error.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any

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

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorError 

type ErrorError struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo

	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error details.
	Details []*Error

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

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

ErrorError - The error object.

func (ErrorError) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorError.

func (*ErrorError) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorError.

type HealthBot 

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

	// REQUIRED; SKU of the Azure Health Bot.
	SKU *SKU

	// The identity of the Azure Health Bot.
	Identity *Identity

	// The set of properties specific to Azure Health Bot resource.
	Properties *Properties

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

	// READ-ONLY; Fully qualified resource Id for the resource.
	ID *string

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

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

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

HealthBot - Azure Health Bot resource definition

func (HealthBot) MarshalJSON 

func (h HealthBot) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HealthBot.

func (*HealthBot) UnmarshalJSON added in v1.1.0 

func (h *HealthBot) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HealthBot.

type Identity 

type Identity struct {
	// The identity type. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user
	// assigned identities. The type 'None' will remove any identities from the Azure
	// Health Bot
	Type *ResourceIdentityType

	// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource
	// ids in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
	UserAssignedIdentities map[string]*UserAssignedIdentity

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

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

Identity for the resource.

func (Identity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Identity.

func (*Identity) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Identity.

type IdentityType 

type IdentityType string

IdentityType - The type of identity that creates/modifies resources 

const (
	IdentityTypeApplication     IdentityType = "Application"
	IdentityTypeKey             IdentityType = "Key"
	IdentityTypeManagedIdentity IdentityType = "ManagedIdentity"
	IdentityTypeUser            IdentityType = "User"
)

func PossibleIdentityTypeValues 

func PossibleIdentityTypeValues() []IdentityType

PossibleIdentityTypeValues returns the possible values for the IdentityType const type.

type OperationDetail 

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

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

	// Name of the operation
	Name *string

	// Origin of the operation
	Origin *string

	// Additional properties.
	Properties any
}

OperationDetail - Operation detail payload

func (OperationDetail) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDetail.

func (*OperationDetail) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDetail.

type OperationDisplay 

type OperationDisplay struct {
	// Localized friendly description for the operation
	Description *string

	// Localized friendly name for the operation
	Operation *string

	// Resource provider of the operation
	Provider *string

	// Resource of the operation
	Resource *string
}

OperationDisplay - Operation display payload

func (OperationDisplay) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager added in v0.4.0 

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

NewListPager - Lists all the available Azure Health Bot operations.

Generated from API version 2021-06-10

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/healthbot/resource-manager/Microsoft.HealthBot/stable/2021-06-10/examples/GetOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/healthbot/armhealthbot"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armhealthbot.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AvailableOperations = armhealthbot.AvailableOperations{
		// 	Value: []*armhealthbot.OperationDetail{
		// 		{
		// 			Name: to.Ptr("Microsoft.Healthbot/healthbots/read"),
		// 			Display: &armhealthbot.OperationDisplay{
		// 				Description: to.Ptr("Read Azure Health Bot"),
		// 				Operation: to.Ptr("Read Azure Health Bot"),
		// 				Provider: to.Ptr("Azure Health Bot"),
		// 				Resource: to.Ptr("Azure Health Bot"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.Healthbot/healthbots/write"),
		// 			Display: &armhealthbot.OperationDisplay{
		// 				Description: to.Ptr("Writes Azure Health Bot"),
		// 				Operation: to.Ptr("Write Azure Health Bot"),
		// 				Provider: to.Ptr("Azure Health Bot"),
		// 				Resource: to.Ptr("Azure Health Bot"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.Healthbot/healthbots/delete"),
		// 			Display: &armhealthbot.OperationDisplay{
		// 				Description: to.Ptr("Deletes Azure Health Bot"),
		// 				Operation: to.Ptr("Delete Azure Health Bot"),
		// 				Provider: to.Ptr("Azure Health Bot"),
		// 				Resource: to.Ptr("Azure Health Bot"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions added in v0.2.0 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse added in v0.2.0 

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

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Properties added in v0.2.0 

type Properties struct {
	// READ-ONLY; The link.
	BotManagementPortalLink *string

	// READ-ONLY; The provisioning state of the Azure Health Bot resource.
	ProvisioningState *string
}

Properties - The properties of a Azure Health Bot. The Health Bot Service is a cloud platform that empowers developers in Healthcare organizations to build and deploy their compliant, AI-powered virtual health assistants and health bots, that help them improve processes and reduce costs.

func (Properties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type Properties.

func (*Properties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Properties.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource Id for the resource.
	ID *string

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

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

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

Resource - The resource model definition for a ARM tracked top level resource

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type ResourceIdentityType 

type ResourceIdentityType string

ResourceIdentityType - The identity type. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the Azure Health Bot 

const (
	ResourceIdentityTypeNone                       ResourceIdentityType = "None"
	ResourceIdentityTypeSystemAssigned             ResourceIdentityType = "SystemAssigned"
	ResourceIdentityTypeSystemAssignedUserAssigned ResourceIdentityType = "SystemAssigned, UserAssigned"
	ResourceIdentityTypeUserAssigned               ResourceIdentityType = "UserAssigned"
)

func PossibleResourceIdentityTypeValues 

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type SKU 

type SKU struct {
	// REQUIRED; The name of the Azure Health Bot SKU
	Name *SKUName
}

SKU - The resource model definition representing SKU

func (SKU) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SKUName 

type SKUName string

SKUName - The name of the Azure Health Bot SKU 

const (
	SKUNameC0 SKUName = "C0"
	SKUNameF0 SKUName = "F0"
	SKUNameS1 SKUName = "S1"
)

func PossibleSKUNameValues 

func PossibleSKUNameValues() []SKUName

PossibleSKUNameValues returns the possible values for the SKUName 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 *IdentityType

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

SystemData - Read only system data

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TrackedResource 

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

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

	// READ-ONLY; Fully qualified resource Id for the resource.
	ID *string

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

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

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

TrackedResource - The resource model definition for a ARM tracked top level resource

func (TrackedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

type UpdateParameters added in v0.2.0 

type UpdateParameters struct {
	// The identity of the Azure Health Bot.
	Identity *Identity
	Location *string

	// SKU of the Azure Health Bot.
	SKU *SKU

	// Tags for a Azure Health Bot.
	Tags map[string]*string
}

UpdateParameters - Parameters for updating a Azure Health Bot.

func (UpdateParameters) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateParameters.

func (*UpdateParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateParameters.

type UserAssignedIdentity 

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

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

UserAssignedIdentity - The details of the user assigned managed identity used by the Video Analyzer resource.

func (UserAssignedIdentity) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type ValidationResult 

type ValidationResult struct {
	// The status code of the response validation.
	Status *string
}

ValidationResult - The response returned from validation process

func (ValidationResult) MarshalJSON added in v1.1.0 

func (v ValidationResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidationResult.

func (*ValidationResult) UnmarshalJSON added in v1.1.0 

func (v *ValidationResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidationResult.

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.