armbotservice

package module
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 14 Imported by: 8

README

Azure Bot Service Module for Go

PkgGoDev

The armbotservice module provides operations for working with Azure Bot Service.

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

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Bot Service. 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 Bot Service 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 := armbotservice.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 := armbotservice.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 Bot Service 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 AcsChatChannel added in v1.0.0 

type AcsChatChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

AcsChatChannel - AcsChat channel definition

func (*AcsChatChannel) GetChannel added in v1.0.0 

func (a *AcsChatChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type AcsChatChannel.

func (AcsChatChannel) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type AcsChatChannel.

func (*AcsChatChannel) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AcsChatChannel.

type AlexaChannel 

type AlexaChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Alexa channel resource
	Properties *AlexaChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

AlexaChannel - Alexa channel definition

func (*AlexaChannel) GetChannel added in v0.2.0 

func (a *AlexaChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type AlexaChannel.

func (AlexaChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AlexaChannel.

func (*AlexaChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlexaChannel.

type AlexaChannelProperties 

type AlexaChannelProperties struct {
	// REQUIRED; The Alexa skill Id
	AlexaSkillID *string

	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// READ-ONLY; Full Uri used to configured the skill in Alexa
	ServiceEndpointURI *string

	// READ-ONLY; Url fragment used in part of the Uri configured in Alexa
	URLFragment *string
}

AlexaChannelProperties - The parameters to provide for the Alexa channel.

func (AlexaChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type AlexaChannelProperties.

func (*AlexaChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AlexaChannelProperties.

type Bot 

type Bot struct {
	// Entity Tag
	Etag *string

	// Required. Gets or sets the Kind of the resource.
	Kind *Kind

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to bot resource
	Properties *BotProperties

	// Gets or sets the SKU of the resource.
	SKU *SKU

	// Contains resource tags defined as key/value pairs.
	Tags map[string]*string

	// READ-ONLY; Specifies the resource ID.
	ID *string

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

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

	// READ-ONLY; Entity zones
	Zones []*string
}

Bot resource definition

func (Bot) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Bot.

func (*Bot) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Bot.

type BotChannel 

type BotChannel struct {
	// Entity Tag
	Etag *string

	// Required. Gets or sets the Kind of the resource.
	Kind *Kind

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to bot channel resource
	Properties ChannelClassification

	// Gets or sets the SKU of the resource.
	SKU *SKU

	// Contains resource tags defined as key/value pairs.
	Tags map[string]*string

	// READ-ONLY; Specifies the resource ID.
	ID *string

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

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

	// READ-ONLY; Entity zones
	Zones []*string
}

BotChannel - Bot channel resource definition

func (BotChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BotChannel.

func (*BotChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BotChannel.

type BotConnectionClient 

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

BotConnectionClient contains the methods for the BotConnection group. Don't use this type directly, use NewBotConnectionClient() instead.

func NewBotConnectionClient 

func NewBotConnectionClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BotConnectionClient, error)

NewBotConnectionClient creates a new instance of BotConnectionClient 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 (*BotConnectionClient) Create 

func (client *BotConnectionClient) Create(ctx context.Context, resourceGroupName string, resourceName string, connectionName string, parameters ConnectionSetting, options *BotConnectionClientCreateOptions) (BotConnectionClientCreateResponse, error)

Create - Register a new Auth Connection for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • connectionName - The name of the Bot Service Connection Setting resource.
  • parameters - The parameters to provide for creating the Connection Setting.
  • options - BotConnectionClientCreateOptions contains the optional parameters for the BotConnectionClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutConnection.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotConnectionClient().Create(ctx, "OneResourceGroupName", "samplebotname", "sampleConnection", armbotservice.ConnectionSetting{
		Etag:     to.Ptr("etag1"),
		Location: to.Ptr("West US"),
		Properties: &armbotservice.ConnectionSettingProperties{
			ClientID:     to.Ptr("sampleclientid"),
			ClientSecret: to.Ptr("samplesecret"),
			Parameters: []*armbotservice.ConnectionSettingParameter{
				{
					Key:   to.Ptr("key1"),
					Value: to.Ptr("value1"),
				},
				{
					Key:   to.Ptr("key2"),
					Value: to.Ptr("value2"),
				}},
			Scopes:            to.Ptr("samplescope"),
			ServiceProviderID: to.Ptr("serviceproviderid"),
		},
	}, 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.ConnectionSetting = armbotservice.ConnectionSetting{
	// 	Name: to.Ptr("sampleConnection"),
	// 	Etag: to.Ptr("etag1"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname/connections/sampleConnection"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.ConnectionSettingProperties{
	// 		ClientID: to.Ptr("sampleclientid"),
	// 		Parameters: []*armbotservice.ConnectionSettingParameter{
	// 			{
	// 				Key: to.Ptr("key1"),
	// 				Value: to.Ptr("value1"),
	// 			},
	// 			{
	// 				Key: to.Ptr("key2"),
	// 				Value: to.Ptr("value2"),
	// 		}},
	// 		Scopes: to.Ptr("samplescope"),
	// 		ServiceProviderDisplayName: to.Ptr("serviceProviderDisplayName"),
	// 		ServiceProviderID: to.Ptr("serviceproviderid"),
	// 	},
	// }
}

Output:

func (*BotConnectionClient) Delete 

func (client *BotConnectionClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, connectionName string, options *BotConnectionClientDeleteOptions) (BotConnectionClientDeleteResponse, error)

Delete - Deletes a Connection Setting registration for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • connectionName - The name of the Bot Service Connection Setting resource.
  • options - BotConnectionClientDeleteOptions contains the optional parameters for the BotConnectionClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/DeleteConnection.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

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

Output:

func (*BotConnectionClient) Get 

func (client *BotConnectionClient) Get(ctx context.Context, resourceGroupName string, resourceName string, connectionName string, options *BotConnectionClientGetOptions) (BotConnectionClientGetResponse, error)

Get - Get a Connection Setting registration for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • connectionName - The name of the Bot Service Connection Setting resource.
  • options - BotConnectionClientGetOptions contains the optional parameters for the BotConnectionClient.Get method.

func (*BotConnectionClient) ListServiceProviders 

func (client *BotConnectionClient) ListServiceProviders(ctx context.Context, options *BotConnectionClientListServiceProvidersOptions) (BotConnectionClientListServiceProvidersResponse, error)

ListServiceProviders - Lists the available Service Providers for creating Connection Settings If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • options - BotConnectionClientListServiceProvidersOptions contains the optional parameters for the BotConnectionClient.ListServiceProviders method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListServiceProviders.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotConnectionClient().ListServiceProviders(ctx, 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.ServiceProviderResponseList = armbotservice.ServiceProviderResponseList{
	// 	Value: []*armbotservice.ServiceProvider{
	// 		{
	// 			Properties: &armbotservice.ServiceProviderProperties{
	// 				DevPortalURL: to.Ptr("sampleDevPortalUrl"),
	// 				DisplayName: to.Ptr("sample service provider display name"),
	// 				IconURL: to.Ptr("sampleIconUrl"),
	// 				ID: to.Ptr("sampleServiceProviderId"),
	// 				Parameters: []*armbotservice.ServiceProviderParameter{
	// 					{
	// 						Name: to.Ptr("sampleParameterName"),
	// 						Type: to.Ptr("sampleParameterType"),
	// 						Description: to.Ptr("sampleDescription"),
	// 						Default: to.Ptr("sampleDefaultValue"),
	// 						DisplayName: to.Ptr("sampleDisplayName"),
	// 						HelpURL: to.Ptr("sampleHelpUrl"),
	// 				}},
	// 				ServiceProviderName: to.Ptr("sampleServiceProvider"),
	// 			},
	// 	}},
	// }
}

Output:

func (*BotConnectionClient) ListWithSecrets 

func (client *BotConnectionClient) ListWithSecrets(ctx context.Context, resourceGroupName string, resourceName string, connectionName string, options *BotConnectionClientListWithSecretsOptions) (BotConnectionClientListWithSecretsResponse, error)

ListWithSecrets - Get a Connection Setting registration for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • connectionName - The name of the Bot Service Connection Setting resource.
  • options - BotConnectionClientListWithSecretsOptions contains the optional parameters for the BotConnectionClient.ListWithSecrets method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetConnection.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotConnectionClient().ListWithSecrets(ctx, "OneResourceGroupName", "samplebotname", "sampleConnection", 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.ConnectionSetting = armbotservice.ConnectionSetting{
	// 	Name: to.Ptr("sampleConnection"),
	// 	Etag: to.Ptr("etag1"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname/connections/sampleConnection"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.ConnectionSettingProperties{
	// 		ClientID: to.Ptr("sampleclientid"),
	// 		Parameters: []*armbotservice.ConnectionSettingParameter{
	// 			{
	// 				Key: to.Ptr("key1"),
	// 				Value: to.Ptr("value1"),
	// 			},
	// 			{
	// 				Key: to.Ptr("key2"),
	// 				Value: to.Ptr("value2"),
	// 		}},
	// 		Scopes: to.Ptr("samplescope"),
	// 		ServiceProviderDisplayName: to.Ptr("serviceProviderDisplayName"),
	// 		ServiceProviderID: to.Ptr("serviceproviderid"),
	// 	},
	// }
}

Output:

func (*BotConnectionClient) NewListByBotServicePager added in v0.4.0 

func (client *BotConnectionClient) NewListByBotServicePager(resourceGroupName string, resourceName string, options *BotConnectionClientListByBotServiceOptions) *runtime.Pager[BotConnectionClientListByBotServiceResponse]

NewListByBotServicePager - Returns all the Connection Settings registered to a particular BotService resource

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • options - BotConnectionClientListByBotServiceOptions contains the optional parameters for the BotConnectionClient.NewListByBotServicePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListConnectionsByBotService.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBotConnectionClient().NewListByBotServicePager("OneResourceGroupName", "samplebotname", 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.ConnectionSettingResponseList = armbotservice.ConnectionSettingResponseList{
		// 	Value: []*armbotservice.ConnectionSetting{
		// 		{
		// 			Name: to.Ptr("sampleConnection"),
		// 			ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
		// 			Properties: &armbotservice.ConnectionSettingProperties{
		// 				ClientID: to.Ptr("sampleclientid"),
		// 				Parameters: []*armbotservice.ConnectionSettingParameter{
		// 					{
		// 						Key: to.Ptr("key1"),
		// 						Value: to.Ptr("value1"),
		// 					},
		// 					{
		// 						Key: to.Ptr("key2"),
		// 						Value: to.Ptr("value2"),
		// 				}},
		// 				Scopes: to.Ptr("samplescope"),
		// 				ServiceProviderID: to.Ptr("serviceproviderid"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*BotConnectionClient) Update 

func (client *BotConnectionClient) Update(ctx context.Context, resourceGroupName string, resourceName string, connectionName string, parameters ConnectionSetting, options *BotConnectionClientUpdateOptions) (BotConnectionClientUpdateResponse, error)

Update - Updates a Connection Setting registration for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • connectionName - The name of the Bot Service Connection Setting resource.
  • parameters - The parameters to provide for updating the Connection Setting.
  • options - BotConnectionClientUpdateOptions contains the optional parameters for the BotConnectionClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/UpdateConnection.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotConnectionClient().Update(ctx, "OneResourceGroupName", "samplebotname", "sampleConnection", armbotservice.ConnectionSetting{
		Etag:     to.Ptr("etag1"),
		Location: to.Ptr("global"),
		Properties: &armbotservice.ConnectionSettingProperties{
			ClientID:     to.Ptr("sampleclientid"),
			ClientSecret: to.Ptr("samplesecret"),
			Parameters: []*armbotservice.ConnectionSettingParameter{
				{
					Key:   to.Ptr("key1"),
					Value: to.Ptr("value1"),
				},
				{
					Key:   to.Ptr("key2"),
					Value: to.Ptr("value2"),
				}},
			Scopes:                     to.Ptr("samplescope"),
			ServiceProviderDisplayName: to.Ptr("serviceProviderDisplayName"),
			ServiceProviderID:          to.Ptr("serviceproviderid"),
		},
	}, 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.ConnectionSetting = armbotservice.ConnectionSetting{
	// 	Name: to.Ptr("sampleConnection"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname/connections/sampleConnection"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.ConnectionSettingProperties{
	// 		ClientID: to.Ptr("sampleclientid"),
	// 		Parameters: []*armbotservice.ConnectionSettingParameter{
	// 			{
	// 				Key: to.Ptr("key1"),
	// 				Value: to.Ptr("value1"),
	// 			},
	// 			{
	// 				Key: to.Ptr("key2"),
	// 				Value: to.Ptr("value2"),
	// 		}},
	// 		Scopes: to.Ptr("samplescope"),
	// 		ServiceProviderDisplayName: to.Ptr("serviceProviderDisplayName"),
	// 		ServiceProviderID: to.Ptr("serviceproviderid"),
	// 	},
	// }
}

Output:

type BotConnectionClientCreateOptions added in v0.2.0 

type BotConnectionClientCreateOptions struct {
}

BotConnectionClientCreateOptions contains the optional parameters for the BotConnectionClient.Create method.

type BotConnectionClientCreateResponse added in v0.2.0 

type BotConnectionClientCreateResponse struct {
	// Bot channel resource definition
	ConnectionSetting
}

BotConnectionClientCreateResponse contains the response from method BotConnectionClient.Create.

type BotConnectionClientDeleteOptions added in v0.2.0 

type BotConnectionClientDeleteOptions struct {
}

BotConnectionClientDeleteOptions contains the optional parameters for the BotConnectionClient.Delete method.

type BotConnectionClientDeleteResponse added in v0.2.0 

type BotConnectionClientDeleteResponse struct {
}

BotConnectionClientDeleteResponse contains the response from method BotConnectionClient.Delete.

type BotConnectionClientGetOptions added in v0.2.0 

type BotConnectionClientGetOptions struct {
}

BotConnectionClientGetOptions contains the optional parameters for the BotConnectionClient.Get method.

type BotConnectionClientGetResponse added in v0.2.0 

type BotConnectionClientGetResponse struct {
	// Bot channel resource definition
	ConnectionSetting
}

BotConnectionClientGetResponse contains the response from method BotConnectionClient.Get.

type BotConnectionClientListByBotServiceOptions added in v0.2.0 

type BotConnectionClientListByBotServiceOptions struct {
}

BotConnectionClientListByBotServiceOptions contains the optional parameters for the BotConnectionClient.NewListByBotServicePager method.

type BotConnectionClientListByBotServiceResponse added in v0.2.0 

type BotConnectionClientListByBotServiceResponse struct {
	// The list of bot service connection settings response.
	ConnectionSettingResponseList
}

BotConnectionClientListByBotServiceResponse contains the response from method BotConnectionClient.NewListByBotServicePager.

type BotConnectionClientListServiceProvidersOptions added in v0.2.0 

type BotConnectionClientListServiceProvidersOptions struct {
}

BotConnectionClientListServiceProvidersOptions contains the optional parameters for the BotConnectionClient.ListServiceProviders method.

type BotConnectionClientListServiceProvidersResponse added in v0.2.0 

type BotConnectionClientListServiceProvidersResponse struct {
	// The list of bot service providers response.
	ServiceProviderResponseList
}

BotConnectionClientListServiceProvidersResponse contains the response from method BotConnectionClient.ListServiceProviders.

type BotConnectionClientListWithSecretsOptions added in v0.2.0 

type BotConnectionClientListWithSecretsOptions struct {
}

BotConnectionClientListWithSecretsOptions contains the optional parameters for the BotConnectionClient.ListWithSecrets method.

type BotConnectionClientListWithSecretsResponse added in v0.2.0 

type BotConnectionClientListWithSecretsResponse struct {
	// Bot channel resource definition
	ConnectionSetting
}

BotConnectionClientListWithSecretsResponse contains the response from method BotConnectionClient.ListWithSecrets.

type BotConnectionClientUpdateOptions added in v0.2.0 

type BotConnectionClientUpdateOptions struct {
}

BotConnectionClientUpdateOptions contains the optional parameters for the BotConnectionClient.Update method.

type BotConnectionClientUpdateResponse added in v0.2.0 

type BotConnectionClientUpdateResponse struct {
	// Bot channel resource definition
	ConnectionSetting
}

BotConnectionClientUpdateResponse contains the response from method BotConnectionClient.Update.

type BotProperties 

type BotProperties struct {
	// REQUIRED; The Name of the bot
	DisplayName *string

	// REQUIRED; The bot's endpoint
	Endpoint *string

	// REQUIRED; Microsoft App Id for the bot
	MsaAppID *string

	// Contains resource all settings defined as key/value pairs.
	AllSettings map[string]*string

	// The hint (e.g. keyVault secret resourceId) on how to fetch the app secret
	AppPasswordHint *string

	// The CMK Url
	CmekKeyVaultURL *string

	// The description of the bot
	Description *string

	// The Application Insights key
	DeveloperAppInsightKey *string

	// The Application Insights Api Key
	DeveloperAppInsightsAPIKey *string

	// The Application Insights App Id
	DeveloperAppInsightsApplicationID *string

	// Opt-out of local authentication and ensure only MSI and AAD can be used exclusively for authentication.
	DisableLocalAuth *bool

	// The Icon Url of the bot
	IconURL *string

	// Whether Cmek is enabled
	IsCmekEnabled *bool

	// Whether the bot is streaming supported
	IsStreamingSupported *bool

	// Collection of LUIS App Ids
	LuisAppIDs []*string

	// The LUIS Key
	LuisKey *string

	// The bot's manifest url
	ManifestURL *string

	// Microsoft App Managed Identity Resource Id for the bot
	MsaAppMSIResourceID *string

	// Microsoft App Tenant Id for the bot
	MsaAppTenantID *string

	// Microsoft App Type for the bot
	MsaAppType *MsaAppType

	// The hint to browser (e.g. protocol handler) on how to open the bot for authoring
	OpenWithHint *string

	// Contains resource parameters defined as key/value pairs.
	Parameters map[string]*string

	// Whether the bot is in an isolated network
	PublicNetworkAccess *PublicNetworkAccess

	// Publishing credentials of the resource
	PublishingCredentials *string

	// The channel schema transformation version for the bot
	SchemaTransformationVersion *string

	// The storage resourceId for the bot
	StorageResourceID *string

	// The Tenant Id for the bot
	TenantID *string

	// READ-ONLY; The CMK encryption status
	CmekEncryptionStatus *string

	// READ-ONLY; Collection of channels for which the bot is configured
	ConfiguredChannels []*string

	// READ-ONLY; Collection of channels for which the bot is enabled
	EnabledChannels []*string

	// READ-ONLY; The bot's endpoint version
	EndpointVersion *string

	// READ-ONLY; Whether the bot is developerAppInsightsApiKey set
	IsDeveloperAppInsightsAPIKeySet *bool

	// READ-ONLY; Token used to migrate non Azure bot to azure subscription
	MigrationToken *string

	// READ-ONLY; List of Private Endpoint Connections configured for the bot
	PrivateEndpointConnections []*PrivateEndpointConnection

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

BotProperties - The parameters to provide for the Bot.

func (BotProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BotProperties.

func (*BotProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BotProperties.

type BotResponseList 

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

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

BotResponseList - The list of bot service 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.0.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) Create 

func (client *BotsClient) Create(ctx context.Context, resourceGroupName string, resourceName string, parameters Bot, options *BotsClientCreateOptions) (BotsClientCreateResponse, error)

Create - Creates a Bot Service. Bot Service is a resource group wide resource type. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • parameters - The parameters to provide for the created bot.
  • options - BotsClientCreateOptions contains the optional parameters for the BotsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/CreateBot.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotsClient().Create(ctx, "OneResourceGroupName", "samplebotname", armbotservice.Bot{
		Etag:     to.Ptr("etag1"),
		Kind:     to.Ptr(armbotservice.KindSdk),
		Location: to.Ptr("West US"),
		SKU: &armbotservice.SKU{
			Name: to.Ptr(armbotservice.SKUNameS1),
		},
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
			"tag2": to.Ptr("value2"),
		},
		Properties: &armbotservice.BotProperties{
			Description:                       to.Ptr("The description of the bot"),
			CmekKeyVaultURL:                   to.Ptr("https://myCmekKey"),
			DeveloperAppInsightKey:            to.Ptr("appinsightskey"),
			DeveloperAppInsightsAPIKey:        to.Ptr("appinsightsapikey"),
			DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
			DisableLocalAuth:                  to.Ptr(true),
			DisplayName:                       to.Ptr("The Name of the bot"),
			Endpoint:                          to.Ptr("http://mybot.coffee"),
			IconURL:                           to.Ptr("http://myicon"),
			IsCmekEnabled:                     to.Ptr(true),
			LuisAppIDs: []*string{
				to.Ptr("luisappid1"),
				to.Ptr("luisappid2")},
			LuisKey:                     to.Ptr("luiskey"),
			MsaAppID:                    to.Ptr("exampleappid"),
			MsaAppMSIResourceID:         to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
			MsaAppTenantID:              to.Ptr("exampleapptenantid"),
			MsaAppType:                  to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
			PublicNetworkAccess:         to.Ptr(armbotservice.PublicNetworkAccessEnabled),
			SchemaTransformationVersion: to.Ptr("1.0"),
		},
	}, 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.Bot = armbotservice.Bot{
	// 	Name: to.Ptr("samplebotname"),
	// 	Type: to.Ptr("Microsoft.BotService/botServices"),
	// 	Etag: to.Ptr("etag1"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname"),
	// 	Kind: to.Ptr(armbotservice.KindSdk),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"tag1": to.Ptr("value1"),
	// 		"tag2": to.Ptr("value2"),
	// 	},
	// 	Properties: &armbotservice.BotProperties{
	// 		Description: to.Ptr("The description of the bot"),
	// 		CmekKeyVaultURL: to.Ptr("https://myCmekKey"),
	// 		ConfiguredChannels: []*string{
	// 			to.Ptr("facebook"),
	// 			to.Ptr("groupme")},
	// 			DeveloperAppInsightKey: to.Ptr("appinsightskey"),
	// 			DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
	// 			DisableLocalAuth: to.Ptr(true),
	// 			DisplayName: to.Ptr("The Name of the bot"),
	// 			EnabledChannels: []*string{
	// 				to.Ptr("facebook")},
	// 				Endpoint: to.Ptr("http://mybot.coffee"),
	// 				EndpointVersion: to.Ptr("version"),
	// 				IconURL: to.Ptr("http://myicon"),
	// 				IsCmekEnabled: to.Ptr(true),
	// 				LuisAppIDs: []*string{
	// 					to.Ptr("luisappid1"),
	// 					to.Ptr("luisappid2")},
	// 					MsaAppID: to.Ptr("msaappid"),
	// 					MsaAppMSIResourceID: to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
	// 					MsaAppTenantID: to.Ptr("msaapptenantid"),
	// 					MsaAppType: to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
	// 					PublicNetworkAccess: to.Ptr(armbotservice.PublicNetworkAccessEnabled),
	// 					SchemaTransformationVersion: to.Ptr("1.0"),
	// 				},
	// 			}
}

Output:

func (*BotsClient) Delete 

func (client *BotsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, options *BotsClientDeleteOptions) (BotsClientDeleteResponse, error)

Delete - Deletes a Bot Service from the resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/DeleteBot.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

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

Output:

func (*BotsClient) Get 

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

Get - Returns a BotService specified by the parameters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - 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/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetBot.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotsClient().Get(ctx, "OneResourceGroupName", "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.Bot = armbotservice.Bot{
	// 	Name: to.Ptr("samplebotname"),
	// 	Type: to.Ptr("Microsoft.BotService/botServices"),
	// 	Etag: to.Ptr("etag1"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname"),
	// 	Kind: to.Ptr(armbotservice.KindSdk),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"tag1": to.Ptr("value1"),
	// 		"tag2": to.Ptr("value2"),
	// 	},
	// 	Properties: &armbotservice.BotProperties{
	// 		Description: to.Ptr("The description of the bot"),
	// 		CmekKeyVaultURL: to.Ptr("https://myCmekKey"),
	// 		ConfiguredChannels: []*string{
	// 			to.Ptr("facebook"),
	// 			to.Ptr("groupme")},
	// 			DeveloperAppInsightKey: to.Ptr("appinsightskey"),
	// 			DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
	// 			DisableLocalAuth: to.Ptr(true),
	// 			DisplayName: to.Ptr("The Name of the bot"),
	// 			EnabledChannels: []*string{
	// 				to.Ptr("facebook")},
	// 				Endpoint: to.Ptr("http://mybot.coffee"),
	// 				EndpointVersion: to.Ptr("version"),
	// 				IconURL: to.Ptr("http://myicon"),
	// 				IsCmekEnabled: to.Ptr(true),
	// 				LuisAppIDs: []*string{
	// 					to.Ptr("luisappid1"),
	// 					to.Ptr("luisappid2")},
	// 					MsaAppID: to.Ptr("msaappid"),
	// 					MsaAppMSIResourceID: to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
	// 					MsaAppTenantID: to.Ptr("msaapptenantid"),
	// 					MsaAppType: to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
	// 					PrivateEndpointConnections: []*armbotservice.PrivateEndpointConnection{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname/privateEndpointConnections/privatelink"),
	// 							Properties: &armbotservice.PrivateEndpointConnectionProperties{
	// 								PrivateEndpoint: &armbotservice.PrivateEndpoint{
	// 									ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.Network/privateEndpoints/privatelink"),
	// 								},
	// 								PrivateLinkServiceConnectionState: &armbotservice.PrivateLinkServiceConnectionState{
	// 									Description: to.Ptr("Auto-Approved"),
	// 									ActionsRequired: to.Ptr("None"),
	// 									Status: to.Ptr(armbotservice.PrivateEndpointServiceConnectionStatusApproved),
	// 								},
	// 								ProvisioningState: to.Ptr(armbotservice.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 							},
	// 					}},
	// 					PublicNetworkAccess: to.Ptr(armbotservice.PublicNetworkAccessEnabled),
	// 					SchemaTransformationVersion: to.Ptr("1.0"),
	// 				},
	// 			}
}

Output:

func (*BotsClient) GetCheckNameAvailability 

func (client *BotsClient) GetCheckNameAvailability(ctx context.Context, parameters CheckNameAvailabilityRequestBody, options *BotsClientGetCheckNameAvailabilityOptions) (BotsClientGetCheckNameAvailabilityResponse, error)

GetCheckNameAvailability - Check whether a bot name is available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • parameters - The request body parameters to provide for the check name availability request
  • options - BotsClientGetCheckNameAvailabilityOptions contains the optional parameters for the BotsClient.GetCheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/CheckNameAvailability.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotsClient().GetCheckNameAvailability(ctx, armbotservice.CheckNameAvailabilityRequestBody{
		Name: to.Ptr("testbotname"),
		Type: to.Ptr("string"),
	}, 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.CheckNameAvailabilityResponseBody = armbotservice.CheckNameAvailabilityResponseBody{
	// 	Message: to.Ptr("custom message from server"),
	// 	Valid: to.Ptr(true),
	// }
}

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 2022-09-15

  • 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/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.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 = armbotservice.BotResponseList{
		// 	Value: []*armbotservice.Bot{
		// 		{
		// 			Name: to.Ptr("samplebotname"),
		// 			Type: to.Ptr("Microsoft.BotService/botServices"),
		// 			Etag: to.Ptr("etag1"),
		// 			ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices"),
		// 			Kind: to.Ptr(armbotservice.KindSdk),
		// 			Location: to.Ptr("West US"),
		// 			Tags: map[string]*string{
		// 				"tag1": to.Ptr("value1"),
		// 				"tag2": to.Ptr("value2"),
		// 			},
		// 			Properties: &armbotservice.BotProperties{
		// 				Description: to.Ptr("The description of the bot"),
		// 				CmekKeyVaultURL: to.Ptr("https://myCmekKey"),
		// 				ConfiguredChannels: []*string{
		// 					to.Ptr("facebook"),
		// 					to.Ptr("groupme")},
		// 					DeveloperAppInsightKey: to.Ptr("appinsightskey"),
		// 					DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
		// 					DisableLocalAuth: to.Ptr(true),
		// 					DisplayName: to.Ptr("The Name of the bot"),
		// 					EnabledChannels: []*string{
		// 						to.Ptr("facebook")},
		// 						Endpoint: to.Ptr("http://mybot.coffee"),
		// 						EndpointVersion: to.Ptr("version"),
		// 						IconURL: to.Ptr("http://myicon"),
		// 						IsCmekEnabled: to.Ptr(true),
		// 						LuisAppIDs: []*string{
		// 							to.Ptr("luisappid1"),
		// 							to.Ptr("luisappid2")},
		// 							MsaAppID: to.Ptr("msaappid"),
		// 							MsaAppMSIResourceID: to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
		// 							MsaAppTenantID: to.Ptr("msaapptenantid"),
		// 							MsaAppType: to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
		// 							PublicNetworkAccess: to.Ptr(armbotservice.PublicNetworkAccessEnabled),
		// 							SchemaTransformationVersion: to.Ptr("1.0"),
		// 						},
		// 				}},
		// 			}
	}
}

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 2022-09-15

  • 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/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.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 = armbotservice.BotResponseList{
		// 	Value: []*armbotservice.Bot{
		// 		{
		// 			Name: to.Ptr("samplebotname"),
		// 			Type: to.Ptr("Microsoft.BotService/botServices"),
		// 			Etag: to.Ptr("etag1"),
		// 			ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
		// 			Kind: to.Ptr(armbotservice.KindSdk),
		// 			Location: to.Ptr("West US"),
		// 			Tags: map[string]*string{
		// 				"tag1": to.Ptr("value1"),
		// 				"tag2": to.Ptr("value2"),
		// 			},
		// 			Properties: &armbotservice.BotProperties{
		// 				Description: to.Ptr("The description of the bot"),
		// 				CmekKeyVaultURL: to.Ptr("https://myCmekKey"),
		// 				ConfiguredChannels: []*string{
		// 					to.Ptr("facebook"),
		// 					to.Ptr("groupme")},
		// 					DeveloperAppInsightKey: to.Ptr("appinsightskey"),
		// 					DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
		// 					DisableLocalAuth: to.Ptr(true),
		// 					DisplayName: to.Ptr("The Name of the bot"),
		// 					EnabledChannels: []*string{
		// 						to.Ptr("facebook")},
		// 						Endpoint: to.Ptr("http://mybot.coffee"),
		// 						EndpointVersion: to.Ptr("version"),
		// 						IconURL: to.Ptr("http://myicon"),
		// 						IsCmekEnabled: to.Ptr(true),
		// 						LuisAppIDs: []*string{
		// 							to.Ptr("luisappid1"),
		// 							to.Ptr("luisappid2")},
		// 							MsaAppID: to.Ptr("msaappid"),
		// 							MsaAppMSIResourceID: to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
		// 							MsaAppTenantID: to.Ptr("msaapptenantid"),
		// 							MsaAppType: to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
		// 							PublicNetworkAccess: to.Ptr(armbotservice.PublicNetworkAccessEnabled),
		// 							SchemaTransformationVersion: to.Ptr("1.0"),
		// 						},
		// 				}},
		// 			}
	}
}

Output:

func (*BotsClient) Update 

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

Update - Updates a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • parameters - The parameters to provide for the created 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/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/UpdateBot.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBotsClient().Update(ctx, "OneResourceGroupName", "samplebotname", armbotservice.Bot{
		Etag:     to.Ptr("etag1"),
		Kind:     to.Ptr(armbotservice.KindSdk),
		Location: to.Ptr("West US"),
		SKU: &armbotservice.SKU{
			Name: to.Ptr(armbotservice.SKUNameS1),
		},
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
			"tag2": to.Ptr("value2"),
		},
		Properties: &armbotservice.BotProperties{
			Description:                       to.Ptr("The description of the bot"),
			CmekKeyVaultURL:                   to.Ptr("https://myCmekKey"),
			DeveloperAppInsightKey:            to.Ptr("appinsightskey"),
			DeveloperAppInsightsAPIKey:        to.Ptr("appinsightsapikey"),
			DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
			DisableLocalAuth:                  to.Ptr(true),
			DisplayName:                       to.Ptr("The Name of the bot"),
			Endpoint:                          to.Ptr("http://mybot.coffee"),
			IconURL:                           to.Ptr("http://myicon"),
			IsCmekEnabled:                     to.Ptr(true),
			LuisAppIDs: []*string{
				to.Ptr("luisappid1"),
				to.Ptr("luisappid2")},
			LuisKey:                     to.Ptr("luiskey"),
			MsaAppID:                    to.Ptr("msaappid"),
			MsaAppMSIResourceID:         to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
			MsaAppTenantID:              to.Ptr("msaapptenantid"),
			MsaAppType:                  to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
			PublicNetworkAccess:         to.Ptr(armbotservice.PublicNetworkAccessEnabled),
			SchemaTransformationVersion: to.Ptr("1.0"),
		},
	}, 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.Bot = armbotservice.Bot{
	// 	Name: to.Ptr("samplebotname"),
	// 	Type: to.Ptr("Microsoft.BotService/botServices"),
	// 	Etag: to.Ptr("etag1"),
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname"),
	// 	Kind: to.Ptr(armbotservice.KindSdk),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"tag1": to.Ptr("value1"),
	// 		"tag2": to.Ptr("value2"),
	// 	},
	// 	Properties: &armbotservice.BotProperties{
	// 		Description: to.Ptr("The description of the bot"),
	// 		CmekKeyVaultURL: to.Ptr("https://myCmekKey"),
	// 		ConfiguredChannels: []*string{
	// 			to.Ptr("facebook"),
	// 			to.Ptr("groupme")},
	// 			DeveloperAppInsightKey: to.Ptr("appinsightskey"),
	// 			DeveloperAppInsightsApplicationID: to.Ptr("appinsightsappid"),
	// 			DisableLocalAuth: to.Ptr(true),
	// 			DisplayName: to.Ptr("The Name of the bot"),
	// 			EnabledChannels: []*string{
	// 				to.Ptr("facebook")},
	// 				Endpoint: to.Ptr("http://mybot.coffee"),
	// 				EndpointVersion: to.Ptr("version"),
	// 				IconURL: to.Ptr("http://myicon"),
	// 				IsCmekEnabled: to.Ptr(true),
	// 				LuisAppIDs: []*string{
	// 					to.Ptr("luisappid1"),
	// 					to.Ptr("luisappid2")},
	// 					MsaAppID: to.Ptr("msaappid"),
	// 					MsaAppMSIResourceID: to.Ptr("/subscriptions/foo/resourcegroups/bar/providers/microsoft.managedidentity/userassignedidentities/sampleId"),
	// 					MsaAppTenantID: to.Ptr("msaapptenantid"),
	// 					MsaAppType: to.Ptr(armbotservice.MsaAppTypeUserAssignedMSI),
	// 					PublicNetworkAccess: to.Ptr(armbotservice.PublicNetworkAccessEnabled),
	// 					SchemaTransformationVersion: to.Ptr("1.0"),
	// 				},
	// 			}
}

Output:

type BotsClientCreateOptions added in v0.2.0 

type BotsClientCreateOptions struct {
}

BotsClientCreateOptions contains the optional parameters for the BotsClient.Create method.

type BotsClientCreateResponse added in v0.2.0 

type BotsClientCreateResponse struct {
	// Bot resource definition
	Bot
}

BotsClientCreateResponse contains the response from method BotsClient.Create.

type BotsClientDeleteOptions added in v0.2.0 

type BotsClientDeleteOptions struct {
}

BotsClientDeleteOptions contains the optional parameters for the BotsClient.Delete method.

type BotsClientDeleteResponse added in v0.2.0 

type BotsClientDeleteResponse struct {
}

BotsClientDeleteResponse contains the response from method BotsClient.Delete.

type BotsClientGetCheckNameAvailabilityOptions added in v0.2.0 

type BotsClientGetCheckNameAvailabilityOptions struct {
}

BotsClientGetCheckNameAvailabilityOptions contains the optional parameters for the BotsClient.GetCheckNameAvailability method.

type BotsClientGetCheckNameAvailabilityResponse added in v0.2.0 

type BotsClientGetCheckNameAvailabilityResponse struct {
	// The response body returned for a request to Bot Service Management to check availability of a bot name.
	CheckNameAvailabilityResponseBody
}

BotsClientGetCheckNameAvailabilityResponse contains the response from method BotsClient.GetCheckNameAvailability.

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 {
	// Bot resource definition
	Bot
}

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 bot service 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 bot service 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 {
	// Bot resource definition
	Bot
}

BotsClientUpdateResponse contains the response from method BotsClient.Update.

type Channel 

type Channel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

Channel definition

func (*Channel) GetChannel 

func (c *Channel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type Channel.

func (Channel) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type Channel.

func (*Channel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Channel.

type ChannelClassification 

type ChannelClassification interface {
	// GetChannel returns the Channel content of the underlying type.
	GetChannel() *Channel
}

ChannelClassification provides polymorphic access to related types. Call the interface's GetChannel() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AcsChatChannel, *AlexaChannel, *Channel, *DirectLineChannel, *DirectLineSpeechChannel, *EmailChannel, *FacebookChannel, - *KikChannel, *LineChannel, *M365Extensions, *MsTeamsChannel, *Omnichannel, *OutlookChannel, *SearchAssistant, *SkypeChannel, - *SlackChannel, *SmsChannel, *TelegramChannel, *TelephonyChannel, *WebChatChannel

type ChannelName 

type ChannelName string
const (
	ChannelNameAcsChatChannel          ChannelName = "AcsChatChannel"
	ChannelNameAlexaChannel            ChannelName = "AlexaChannel"
	ChannelNameDirectLineChannel       ChannelName = "DirectLineChannel"
	ChannelNameDirectLineSpeechChannel ChannelName = "DirectLineSpeechChannel"
	ChannelNameEmailChannel            ChannelName = "EmailChannel"
	ChannelNameFacebookChannel         ChannelName = "FacebookChannel"
	ChannelNameKikChannel              ChannelName = "KikChannel"
	ChannelNameLineChannel             ChannelName = "LineChannel"
	ChannelNameM365Extensions          ChannelName = "M365Extensions"
	ChannelNameMsTeamsChannel          ChannelName = "MsTeamsChannel"
	ChannelNameOmnichannel             ChannelName = "Omnichannel"
	ChannelNameOutlookChannel          ChannelName = "OutlookChannel"
	ChannelNameSearchAssistant         ChannelName = "SearchAssistant"
	ChannelNameSkypeChannel            ChannelName = "SkypeChannel"
	ChannelNameSlackChannel            ChannelName = "SlackChannel"
	ChannelNameSmsChannel              ChannelName = "SmsChannel"
	ChannelNameTelegramChannel         ChannelName = "TelegramChannel"
	ChannelNameTelephonyChannel        ChannelName = "TelephonyChannel"
	ChannelNameWebChatChannel          ChannelName = "WebChatChannel"
)

func PossibleChannelNameValues 

func PossibleChannelNameValues() []ChannelName

PossibleChannelNameValues returns the possible values for the ChannelName const type.

type ChannelResponseList 

type ChannelResponseList struct {
	// The link used to get the next page of bot service channel resources.
	NextLink *string

	// READ-ONLY; Gets the list of bot service channel results and their properties.
	Value []*BotChannel
}

ChannelResponseList - The list of bot service channel operation response.

func (ChannelResponseList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ChannelResponseList.

func (*ChannelResponseList) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChannelResponseList.

type ChannelSettings added in v0.2.0 

type ChannelSettings struct {
	// The bot id
	BotID *string

	// The bot icon url
	BotIconURL *string

	// The channel display name
	ChannelDisplayName *string

	// The channel id
	ChannelID *string

	// Opt-out of local authentication and ensure only MSI and AAD can be used exclusively for authentication.
	DisableLocalAuth *bool

	// The extensionKey1
	ExtensionKey1 *string

	// The extensionKey2
	ExtensionKey2 *string

	// Whether this channel is enabled for the bot
	IsEnabled *bool

	// Whether customer needs to agree to new terms.
	RequireTermsAgreement *bool

	// The list of sites
	Sites []*Site
}

ChannelSettings - Channel settings definition

func (ChannelSettings) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ChannelSettings.

func (*ChannelSettings) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChannelSettings.

type ChannelsClient 

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

ChannelsClient contains the methods for the Channels group. Don't use this type directly, use NewChannelsClient() instead.

func NewChannelsClient 

func NewChannelsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ChannelsClient, error)

NewChannelsClient creates a new instance of ChannelsClient 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 (*ChannelsClient) Create 

func (client *ChannelsClient) Create(ctx context.Context, resourceGroupName string, resourceName string, channelName ChannelName, parameters BotChannel, options *ChannelsClientCreateOptions) (ChannelsClientCreateResponse, error)

Create - Creates a Channel registration for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • channelName - The name of the Channel resource.
  • parameters - The parameters to provide for the created bot.
  • options - ChannelsClientCreateOptions contains the optional parameters for the ChannelsClient.Create method.
Example (CreateAlexaChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutAlexaChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Create(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameAlexaChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.AlexaChannel{
			ChannelName: to.Ptr("AlexaChannel"),
			Properties: &armbotservice.AlexaChannelProperties{
				AlexaSkillID: to.Ptr("XAlexaSkillIdX"),
				IsEnabled:    to.Ptr(true),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.AlexaChannel{
	// 		ChannelName: to.Ptr("AlexaChannel"),
	// 		Properties: &armbotservice.AlexaChannelProperties{
	// 			AlexaSkillID: to.Ptr("alexa skill id"),
	// 			IsEnabled: to.Ptr(true),
	// 			ServiceEndpointURI: to.Ptr("https://domain/XUrlFragmentX/botId"),
	// 			URLFragment: to.Ptr("XUrlFragmentX"),
	// 		},
	// 	},
	// }
}

Output:
Example (CreateChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Create(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameEmailChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.EmailChannel{
			ChannelName: to.Ptr("EmailChannel"),
			Properties: &armbotservice.EmailChannelProperties{
				EmailAddress: to.Ptr("a@b.com"),
				IsEnabled:    to.Ptr(true),
				Password:     to.Ptr("pwd"),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.EmailChannel{
	// 		ChannelName: to.Ptr("EmailChannel"),
	// 		Properties: &armbotservice.EmailChannelProperties{
	// 			EmailAddress: to.Ptr("a@b.com"),
	// 			IsEnabled: to.Ptr(true),
	// 			Password: to.Ptr("pwd"),
	// 		},
	// 	},
	// }
}

Output:
Example (CreateDirectLineSpeechChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutDirectLineSpeechChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Create(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameDirectLineSpeechChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.DirectLineSpeechChannel{
			ChannelName: to.Ptr("DirectLineSpeechChannel"),
			Properties: &armbotservice.DirectLineSpeechChannelProperties{
				CognitiveServiceRegion:          to.Ptr("XcognitiveServiceRegionX"),
				CognitiveServiceSubscriptionKey: to.Ptr("XcognitiveServiceSubscriptionKeyX"),
				IsEnabled:                       to.Ptr(true),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.DirectLineSpeechChannel{
	// 		ChannelName: to.Ptr("DirectLineSpeechChannel"),
	// 		Properties: &armbotservice.DirectLineSpeechChannelProperties{
	// 			CognitiveServiceRegion: to.Ptr("XcognitiveServiceRegionX"),
	// 			IsEnabled: to.Ptr(true),
	// 		},
	// 	},
	// }
}

Output:
Example (CreateEmailChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutEmailChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Create(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameEmailChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.EmailChannel{
			ChannelName: to.Ptr("EmailChannel"),
			Properties: &armbotservice.EmailChannelProperties{
				AuthMethod:   to.Ptr(armbotservice.EmailChannelAuthMethodGraph),
				EmailAddress: to.Ptr("a@b.com"),
				IsEnabled:    to.Ptr(true),
				MagicCode:    to.Ptr("000000"),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.EmailChannel{
	// 		ChannelName: to.Ptr("EmailChannel"),
	// 		Properties: &armbotservice.EmailChannelProperties{
	// 			AuthMethod: to.Ptr(armbotservice.EmailChannelAuthMethodGraph),
	// 			EmailAddress: to.Ptr("a@b.com"),
	// 			IsEnabled: to.Ptr(true),
	// 		},
	// 	},
	// }
}

Output:
Example (CreateLineChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutLineChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Create(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameLineChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.LineChannel{
			ChannelName: to.Ptr("LineChannel"),
			Properties: &armbotservice.LineChannelProperties{
				LineRegistrations: []*armbotservice.LineRegistration{
					{
						ChannelAccessToken: to.Ptr("channelAccessToken"),
						ChannelSecret:      to.Ptr("channelSecret"),
					}},
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.LineChannel{
	// 		ChannelName: to.Ptr("LineChannel"),
	// 		Properties: &armbotservice.LineChannelProperties{
	// 			CallbackURL: to.Ptr("http://callbackUrl"),
	// 			IsValidated: to.Ptr(true),
	// 			LineRegistrations: []*armbotservice.LineRegistration{
	// 				{
	// 					GeneratedID: to.Ptr("id"),
	// 			}},
	// 		},
	// 	},
	// }
}

Output:

func (*ChannelsClient) Delete 

func (client *ChannelsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, channelName string, options *ChannelsClientDeleteOptions) (ChannelsClientDeleteResponse, error)

Delete - Deletes a Channel registration from a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • channelName - The name of the Bot resource.
  • options - ChannelsClientDeleteOptions contains the optional parameters for the ChannelsClient.Delete method.
Example (DeleteChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/DeleteChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

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

Output:
Example (DeleteDirectLineSpeechChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/DeleteDirectLineSpeechChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

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

Output:

func (*ChannelsClient) Get 

func (client *ChannelsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, channelName string, options *ChannelsClientGetOptions) (ChannelsClientGetResponse, error)

Get - Returns a BotService Channel registration specified by the parameters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • channelName - The name of the Bot resource.
  • options - ChannelsClientGetOptions contains the optional parameters for the ChannelsClient.Get method.
Example (GetAlexaChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetAlexaChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Get(ctx, "OneResourceGroupName", "samplebotname", "AlexaChannel", 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.AlexaChannel{
	// 		ChannelName: to.Ptr("AlexaChannel"),
	// 		Properties: &armbotservice.AlexaChannelProperties{
	// 			AlexaSkillID: to.Ptr("alexa skill id"),
	// 			IsEnabled: to.Ptr(true),
	// 			ServiceEndpointURI: to.Ptr("https://domain/XUrlFragmentX/botId"),
	// 			URLFragment: to.Ptr("XUrlFragmentX"),
	// 		},
	// 	},
	// }
}

Output:
Example (GetChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Get(ctx, "OneResourceGroupName", "samplebotname", "EmailChannel", 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.EmailChannel{
	// 		ChannelName: to.Ptr("EmailChannel"),
	// 		Properties: &armbotservice.EmailChannelProperties{
	// 			EmailAddress: to.Ptr("a@b.com"),
	// 			IsEnabled: to.Ptr(true),
	// 			Password: to.Ptr("pwd"),
	// 		},
	// 	},
	// }
}

Output:
Example (GetDirectLineSpeechChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetDirectLineSpeechChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Get(ctx, "OneResourceGroupName", "samplebotname", "DirectLineSpeechChannel", 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.DirectLineSpeechChannel{
	// 		ChannelName: to.Ptr("DirectLineSpeechChannel"),
	// 		Properties: &armbotservice.DirectLineSpeechChannelProperties{
	// 			CognitiveServiceRegion: to.Ptr("Cognitive service region"),
	// 			CustomSpeechModelID: to.Ptr("Custom speech model ID"),
	// 			CustomVoiceDeploymentID: to.Ptr("Custom voice deployment ID"),
	// 			IsDefaultBotForCogSvcAccount: to.Ptr(true),
	// 			IsEnabled: to.Ptr(true),
	// 		},
	// 	},
	// }
}

Output:
Example (GetLineChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetLineChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Get(ctx, "OneResourceGroupName", "samplebotname", "LineChannel", 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.LineChannel{
	// 		ChannelName: to.Ptr("LineChannel"),
	// 		Properties: &armbotservice.LineChannelProperties{
	// 			CallbackURL: to.Ptr("http://callbackUrl"),
	// 			IsValidated: to.Ptr(true),
	// 			LineRegistrations: []*armbotservice.LineRegistration{
	// 				{
	// 					GeneratedID: to.Ptr("id"),
	// 			}},
	// 		},
	// 	},
	// }
}

Output:

func (*ChannelsClient) ListWithKeys 

func (client *ChannelsClient) ListWithKeys(ctx context.Context, resourceGroupName string, resourceName string, channelName ChannelName, options *ChannelsClientListWithKeysOptions) (ChannelsClientListWithKeysResponse, error)

ListWithKeys - Lists a Channel registration for a Bot Service including secrets If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • channelName - The name of the Channel resource.
  • options - ChannelsClientListWithKeysOptions contains the optional parameters for the ChannelsClient.ListWithKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListChannel.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().ListWithKeys(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameEmailChannel, 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.ListChannelWithKeysResponse = armbotservice.ListChannelWithKeysResponse{
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.EmailChannel{
	// 		ChannelName: to.Ptr("EmailChannel"),
	// 		Properties: &armbotservice.EmailChannelProperties{
	// 			EmailAddress: to.Ptr("a@b.com"),
	// 			IsEnabled: to.Ptr(true),
	// 			Password: to.Ptr("pwd"),
	// 		},
	// 	},
	// 	Resource: &armbotservice.DirectLineChannel{
	// 		ChannelName: to.Ptr("DirectLineChannel"),
	// 		Etag: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 		Location: to.Ptr("aaaaaa"),
	// 		Properties: &armbotservice.DirectLineChannelProperties{
	// 			Sites: []*armbotservice.DirectLineSite{
	// 				{
	// 					IsBlockUserUploadEnabled: to.Ptr(false),
	// 					IsEnabled: to.Ptr(true),
	// 					IsSecureSiteEnabled: to.Ptr(false),
	// 					IsV1Enabled: to.Ptr(true),
	// 					IsV3Enabled: to.Ptr(true),
	// 					Key: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 					Key2: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 					SiteID: to.Ptr("aaaaaaaaaaa"),
	// 					SiteName: to.Ptr("aaaaaaaaaaaa"),
	// 					TrustedOrigins: []*string{
	// 						to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")},
	// 				}},
	// 			},
	// 		},
	// 		Setting: &armbotservice.ChannelSettings{
	// 			BotIconURL: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 			BotID: to.Ptr("aaaaaaaaaaaaaaaaaaaa"),
	// 			ChannelDisplayName: to.Ptr("aaaaaaaaaaa"),
	// 			ChannelID: to.Ptr("aaaaaaaaaa"),
	// 			DisableLocalAuth: to.Ptr(false),
	// 			ExtensionKey1: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 			ExtensionKey2: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 			IsEnabled: to.Ptr(true),
	// 			Sites: []*armbotservice.Site{
	// 				{
	// 					ETag: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 					IsBlockUserUploadEnabled: to.Ptr(false),
	// 					IsEnabled: to.Ptr(true),
	// 					IsSecureSiteEnabled: to.Ptr(false),
	// 					IsTokenEnabled: to.Ptr(false),
	// 					IsV1Enabled: to.Ptr(true),
	// 					IsV3Enabled: to.Ptr(true),
	// 					IsWebchatPreviewEnabled: to.Ptr(false),
	// 					Key: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 					Key2: to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
	// 					SiteID: to.Ptr("aaaaaaaaaaa"),
	// 					SiteName: to.Ptr("aaaaaaaaaaaa"),
	// 					TrustedOrigins: []*string{
	// 						to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")},
	// 				}},
	// 			},
	// 		}
}

Output:

func (*ChannelsClient) NewListByResourceGroupPager added in v0.4.0 

func (client *ChannelsClient) NewListByResourceGroupPager(resourceGroupName string, resourceName string, options *ChannelsClientListByResourceGroupOptions) *runtime.Pager[ChannelsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Returns all the Channel registrations of a particular BotService resource

Generated from API version 2022-09-15

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListChannelsByBotService.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewChannelsClient().NewListByResourceGroupPager("OneResourceGroupName", "samplebotname", 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.ChannelResponseList = armbotservice.ChannelResponseList{
		// 	Value: []*armbotservice.BotChannel{
		// 		{
		// 			ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
		// 			Location: to.Ptr("global"),
		// 			Properties: &armbotservice.EmailChannel{
		// 				ChannelName: to.Ptr("EmailChannel"),
		// 				Properties: &armbotservice.EmailChannelProperties{
		// 					EmailAddress: to.Ptr("a@b.com"),
		// 					IsEnabled: to.Ptr(true),
		// 					Password: to.Ptr("pwd"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
		// 			Location: to.Ptr("global"),
		// 			Properties: &armbotservice.FacebookChannel{
		// 				ChannelName: to.Ptr("FacebookChannel"),
		// 				Properties: &armbotservice.FacebookChannelProperties{
		// 					AppID: to.Ptr("id"),
		// 					CallbackURL: to.Ptr("appid"),
		// 					IsEnabled: to.Ptr(true),
		// 					Pages: []*armbotservice.FacebookPage{
		// 						{
		// 							ID: to.Ptr("id"),
		// 					}},
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ChannelsClient) Update 

func (client *ChannelsClient) Update(ctx context.Context, resourceGroupName string, resourceName string, channelName ChannelName, parameters BotChannel, options *ChannelsClientUpdateOptions) (ChannelsClientUpdateResponse, error)

Update - Updates a Channel registration for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • channelName - The name of the Channel resource.
  • parameters - The parameters to provide for the created bot.
  • options - ChannelsClientUpdateOptions contains the optional parameters for the ChannelsClient.Update method.
Example (UpdateAlexaChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/UpdateAlexaChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Update(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameAlexaChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.AlexaChannel{
			ChannelName: to.Ptr("AlexaChannel"),
			Properties: &armbotservice.AlexaChannelProperties{
				AlexaSkillID: to.Ptr("XAlexaSkillIdX"),
				IsEnabled:    to.Ptr(true),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.AlexaChannel{
	// 		ChannelName: to.Ptr("AlexaChannel"),
	// 		Properties: &armbotservice.AlexaChannelProperties{
	// 			AlexaSkillID: to.Ptr("XAlexaSkillIdX"),
	// 			IsEnabled: to.Ptr(true),
	// 			ServiceEndpointURI: to.Ptr("https://domain/XUrlFragmentX/botId"),
	// 			URLFragment: to.Ptr("XUrlFragmentX"),
	// 		},
	// 	},
	// }
}

Output:
Example (UpdateChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/UpdateChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Update(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameEmailChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.EmailChannel{
			ChannelName: to.Ptr("EmailChannel"),
			Properties: &armbotservice.EmailChannelProperties{
				EmailAddress: to.Ptr("a@b.com"),
				IsEnabled:    to.Ptr(true),
				Password:     to.Ptr("pwd"),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.EmailChannel{
	// 		ChannelName: to.Ptr("EmailChannel"),
	// 		Properties: &armbotservice.EmailChannelProperties{
	// 			EmailAddress: to.Ptr("a@b.com"),
	// 			IsEnabled: to.Ptr(true),
	// 			Password: to.Ptr("pwd"),
	// 		},
	// 	},
	// }
}

Output:
Example (UpdateDirectLineSpeechChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/UpdateDirectLineSpeechChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Update(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameDirectLineSpeechChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.DirectLineSpeechChannel{
			ChannelName: to.Ptr("DirectLineSpeechChannel"),
			Properties: &armbotservice.DirectLineSpeechChannelProperties{
				CognitiveServiceRegion:          to.Ptr("XcognitiveServiceRegionX"),
				CognitiveServiceSubscriptionKey: to.Ptr("XcognitiveServiceSubscriptionKeyX"),
				IsEnabled:                       to.Ptr(true),
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.DirectLineSpeechChannel{
	// 		ChannelName: to.Ptr("DirectLineSpeechChannel"),
	// 		Properties: &armbotservice.DirectLineSpeechChannelProperties{
	// 			CognitiveServiceRegion: to.Ptr("XcognitiveServiceRegionX"),
	// 			IsEnabled: to.Ptr(true),
	// 		},
	// 	},
	// }
}

Output:
Example (UpdateLineChannel)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/UpdateLineChannel.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Update(ctx, "OneResourceGroupName", "samplebotname", armbotservice.ChannelNameLineChannel, armbotservice.BotChannel{
		Location: to.Ptr("global"),
		Properties: &armbotservice.LineChannel{
			ChannelName: to.Ptr("LineChannel"),
			Properties: &armbotservice.LineChannelProperties{
				LineRegistrations: []*armbotservice.LineRegistration{
					{
						ChannelAccessToken: to.Ptr("channelAccessToken"),
						ChannelSecret:      to.Ptr("channelSecret"),
					}},
			},
		},
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	ID: to.Ptr("/subscriptions/subscription-id/providers/Microsoft.BotService/botServices"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.LineChannel{
	// 		ChannelName: to.Ptr("LineChannel"),
	// 		Properties: &armbotservice.LineChannelProperties{
	// 			CallbackURL: to.Ptr("http://callbackUrl"),
	// 			IsValidated: to.Ptr(true),
	// 			LineRegistrations: []*armbotservice.LineRegistration{
	// 				{
	// 					GeneratedID: to.Ptr("id"),
	// 			}},
	// 		},
	// 	},
	// }
}

Output:

type ChannelsClientCreateOptions added in v0.2.0 

type ChannelsClientCreateOptions struct {
}

ChannelsClientCreateOptions contains the optional parameters for the ChannelsClient.Create method.

type ChannelsClientCreateResponse added in v0.2.0 

type ChannelsClientCreateResponse struct {
	// Bot channel resource definition
	BotChannel
}

ChannelsClientCreateResponse contains the response from method ChannelsClient.Create.

type ChannelsClientDeleteOptions added in v0.2.0 

type ChannelsClientDeleteOptions struct {
}

ChannelsClientDeleteOptions contains the optional parameters for the ChannelsClient.Delete method.

type ChannelsClientDeleteResponse added in v0.2.0 

type ChannelsClientDeleteResponse struct {
}

ChannelsClientDeleteResponse contains the response from method ChannelsClient.Delete.

type ChannelsClientGetOptions added in v0.2.0 

type ChannelsClientGetOptions struct {
}

ChannelsClientGetOptions contains the optional parameters for the ChannelsClient.Get method.

type ChannelsClientGetResponse added in v0.2.0 

type ChannelsClientGetResponse struct {
	// Bot channel resource definition
	BotChannel
}

ChannelsClientGetResponse contains the response from method ChannelsClient.Get.

type ChannelsClientListByResourceGroupOptions added in v0.2.0 

type ChannelsClientListByResourceGroupOptions struct {
}

ChannelsClientListByResourceGroupOptions contains the optional parameters for the ChannelsClient.NewListByResourceGroupPager method.

type ChannelsClientListByResourceGroupResponse added in v0.2.0 

type ChannelsClientListByResourceGroupResponse struct {
	// The list of bot service channel operation response.
	ChannelResponseList
}

ChannelsClientListByResourceGroupResponse contains the response from method ChannelsClient.NewListByResourceGroupPager.

type ChannelsClientListWithKeysOptions added in v0.2.0 

type ChannelsClientListWithKeysOptions struct {
}

ChannelsClientListWithKeysOptions contains the optional parameters for the ChannelsClient.ListWithKeys method.

type ChannelsClientListWithKeysResponse added in v0.2.0 

type ChannelsClientListWithKeysResponse struct {
	// The ARM channel of list channel with keys operation response.
	ListChannelWithKeysResponse
}

ChannelsClientListWithKeysResponse contains the response from method ChannelsClient.ListWithKeys.

type ChannelsClientUpdateOptions added in v0.2.0 

type ChannelsClientUpdateOptions struct {
}

ChannelsClientUpdateOptions contains the optional parameters for the ChannelsClient.Update method.

type ChannelsClientUpdateResponse added in v0.2.0 

type ChannelsClientUpdateResponse struct {
	// Bot channel resource definition
	BotChannel
}

ChannelsClientUpdateResponse contains the response from method ChannelsClient.Update.

type CheckNameAvailabilityRequestBody 

type CheckNameAvailabilityRequestBody struct {
	// the name of the bot for which availability needs to be checked.
	Name *string

	// the type of the bot for which availability needs to be checked
	Type *string
}

CheckNameAvailabilityRequestBody - The request body for a request to Bot Service Management to check availability of a bot name.

func (CheckNameAvailabilityRequestBody) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityRequestBody.

func (*CheckNameAvailabilityRequestBody) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityRequestBody.

type CheckNameAvailabilityResponseBody 

type CheckNameAvailabilityResponseBody struct {
	// response code from ABS
	AbsCode *string

	// additional message from the bot management api showing why a bot name is not available
	Message *string

	// indicates if the bot name is valid.
	Valid *bool
}

CheckNameAvailabilityResponseBody - The response body returned for a request to Bot Service Management to check availability of a bot name.

func (CheckNameAvailabilityResponseBody) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResponseBody.

func (*CheckNameAvailabilityResponseBody) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityResponseBody.

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

func (c *ClientFactory) NewBotConnectionClient() *BotConnectionClient

NewBotConnectionClient creates a new instance of BotConnectionClient.

func (*ClientFactory) NewBotsClient added in v1.1.0 

func (c *ClientFactory) NewBotsClient() *BotsClient

NewBotsClient creates a new instance of BotsClient.

func (*ClientFactory) NewChannelsClient added in v1.1.0 

func (c *ClientFactory) NewChannelsClient() *ChannelsClient

NewChannelsClient creates a new instance of ChannelsClient.

func (*ClientFactory) NewDirectLineClient added in v1.1.0 

func (c *ClientFactory) NewDirectLineClient() *DirectLineClient

NewDirectLineClient creates a new instance of DirectLineClient.

func (*ClientFactory) NewEmailClient added in v1.1.0 

func (c *ClientFactory) NewEmailClient() *EmailClient

NewEmailClient creates a new instance of EmailClient.

func (*ClientFactory) NewHostSettingsClient added in v1.1.0 

func (c *ClientFactory) NewHostSettingsClient() *HostSettingsClient

NewHostSettingsClient creates a new instance of HostSettingsClient.

func (*ClientFactory) NewOperationResultsClient added in v1.1.0 

func (c *ClientFactory) NewOperationResultsClient() *OperationResultsClient

NewOperationResultsClient creates a new instance of OperationResultsClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPrivateEndpointConnectionsClient added in v1.1.0 

func (c *ClientFactory) NewPrivateEndpointConnectionsClient() *PrivateEndpointConnectionsClient

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient.

func (*ClientFactory) NewPrivateLinkResourcesClient added in v1.1.0 

func (c *ClientFactory) NewPrivateLinkResourcesClient() *PrivateLinkResourcesClient

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient.

func (*ClientFactory) NewQnAMakerEndpointKeysClient added in v1.1.0 

func (c *ClientFactory) NewQnAMakerEndpointKeysClient() *QnAMakerEndpointKeysClient

NewQnAMakerEndpointKeysClient creates a new instance of QnAMakerEndpointKeysClient.

type ConnectionItemName 

type ConnectionItemName struct {
	// READ-ONLY; Connection Item name that has been added in the API
	Name *string
}

ConnectionItemName - The display name of a connection Item Setting registered with the Bot

func (ConnectionItemName) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ConnectionItemName.

func (*ConnectionItemName) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionItemName.

type ConnectionSetting 

type ConnectionSetting struct {
	// Entity Tag
	Etag *string

	// Required. Gets or sets the Kind of the resource.
	Kind *Kind

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to bot channel resource
	Properties *ConnectionSettingProperties

	// Gets or sets the SKU of the resource.
	SKU *SKU

	// Contains resource tags defined as key/value pairs.
	Tags map[string]*string

	// READ-ONLY; Specifies the resource ID.
	ID *string

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

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

	// READ-ONLY; Entity zones
	Zones []*string
}

ConnectionSetting - Bot channel resource definition

func (ConnectionSetting) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConnectionSetting.

func (*ConnectionSetting) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionSetting.

type ConnectionSettingParameter 

type ConnectionSettingParameter struct {
	// Key for the Connection Setting Parameter.
	Key *string

	// Value associated with the Connection Setting Parameter.
	Value *string
}

ConnectionSettingParameter - Extra Parameter in a Connection Setting Properties to indicate service provider specific properties

func (ConnectionSettingParameter) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ConnectionSettingParameter.

func (*ConnectionSettingParameter) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionSettingParameter.

type ConnectionSettingProperties 

type ConnectionSettingProperties struct {
	// Client Id associated with the Connection Setting.
	ClientID *string

	// Client Secret associated with the Connection Setting
	ClientSecret *string

	// Service Provider Parameters associated with the Connection Setting
	Parameters []*ConnectionSettingParameter

	// Provisioning state of the resource
	ProvisioningState *string

	// Scopes associated with the Connection Setting
	Scopes *string

	// Service Provider Display Name associated with the Connection Setting
	ServiceProviderDisplayName *string

	// Service Provider Id associated with the Connection Setting
	ServiceProviderID *string

	// READ-ONLY; Setting Id set by the service for the Connection Setting.
	SettingID *string
}

ConnectionSettingProperties - Properties for a Connection Setting Item

func (ConnectionSettingProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConnectionSettingProperties.

func (*ConnectionSettingProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionSettingProperties.

type ConnectionSettingResponseList 

type ConnectionSettingResponseList struct {
	// The link used to get the next page of bot service connection setting resources.
	NextLink *string

	// READ-ONLY; Gets the list of bot service connection settings and their properties.
	Value []*ConnectionSetting
}

ConnectionSettingResponseList - The list of bot service connection settings response.

func (ConnectionSettingResponseList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConnectionSettingResponseList.

func (*ConnectionSettingResponseList) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectionSettingResponseList.

type CreateEmailSignInURLResponse added in v1.0.0 

type CreateEmailSignInURLResponse struct {
	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to sign in url
	Properties *CreateEmailSignInURLResponseProperties

	// READ-ONLY; Specifies the resource ID.
	ID *string
}

CreateEmailSignInURLResponse - The ARM create email sign in url operation response.

func (CreateEmailSignInURLResponse) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateEmailSignInURLResponse.

func (*CreateEmailSignInURLResponse) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateEmailSignInURLResponse.

type CreateEmailSignInURLResponseProperties added in v1.0.0 

type CreateEmailSignInURLResponseProperties struct {
	// Sign in url.
	URL *string
}

CreateEmailSignInURLResponseProperties - The set of properties specific to sign in url

func (CreateEmailSignInURLResponseProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateEmailSignInURLResponseProperties.

func (*CreateEmailSignInURLResponseProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateEmailSignInURLResponseProperties.

type DirectLineChannel 

type DirectLineChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Direct Line channel resource
	Properties *DirectLineChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

DirectLineChannel - Direct Line channel definition

func (*DirectLineChannel) GetChannel added in v0.2.0 

func (d *DirectLineChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type DirectLineChannel.

func (DirectLineChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DirectLineChannel.

func (*DirectLineChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DirectLineChannel.

type DirectLineChannelProperties 

type DirectLineChannelProperties struct {
	// Direct Line embed code of the resource
	DirectLineEmbedCode *string

	// The extensionKey1
	ExtensionKey1 *string

	// The extensionKey2
	ExtensionKey2 *string

	// The list of Direct Line sites
	Sites []*DirectLineSite
}

DirectLineChannelProperties - The parameters to provide for the Direct Line channel.

func (DirectLineChannelProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DirectLineChannelProperties.

func (*DirectLineChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DirectLineChannelProperties.

type DirectLineClient 

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

DirectLineClient contains the methods for the DirectLine group. Don't use this type directly, use NewDirectLineClient() instead.

func NewDirectLineClient 

func NewDirectLineClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DirectLineClient, error)

NewDirectLineClient creates a new instance of DirectLineClient 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 (*DirectLineClient) RegenerateKeys 

func (client *DirectLineClient) RegenerateKeys(ctx context.Context, resourceGroupName string, resourceName string, channelName RegenerateKeysChannelName, parameters SiteInfo, options *DirectLineClientRegenerateKeysOptions) (DirectLineClientRegenerateKeysResponse, error)

RegenerateKeys - Regenerates secret keys and returns them for the DirectLine Channel of a particular BotService resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • channelName - The name of the Channel resource for which keys are to be regenerated.
  • parameters - The parameters to provide for the created bot.
  • options - DirectLineClientRegenerateKeysOptions contains the optional parameters for the DirectLineClient.RegenerateKeys method.
Example (RegenerateKeysForDirectLineChannelSite)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/DirectlineRegenerateKeys.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDirectLineClient().RegenerateKeys(ctx, "OneResourceGroupName", "samplebotname", armbotservice.RegenerateKeysChannelNameDirectLineChannel, armbotservice.SiteInfo{
		Key:      to.Ptr(armbotservice.KeyKey1),
		SiteName: to.Ptr("testSiteName"),
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.DirectLineChannel{
	// 		ChannelName: to.Ptr("DirectLineChannel"),
	// 		Properties: &armbotservice.DirectLineChannelProperties{
	// 			Sites: []*armbotservice.DirectLineSite{
	// 				{
	// 					IsEnabled: to.Ptr(true),
	// 					IsV1Enabled: to.Ptr(true),
	// 					IsV3Enabled: to.Ptr(true),
	// 					Key: to.Ptr("key1"),
	// 					Key2: to.Ptr("key2"),
	// 					SiteID: to.Ptr("abcd"),
	// 					SiteName: to.Ptr("Default Site"),
	// 			}},
	// 		},
	// 	},
	// }
}

Output:
Example (RegenerateKeysForWebChatChannelSite)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/WebChatRegenerateKeys.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDirectLineClient().RegenerateKeys(ctx, "OneResourceGroupName", "samplebotname", armbotservice.RegenerateKeysChannelNameWebChatChannel, armbotservice.SiteInfo{
		Key:      to.Ptr(armbotservice.KeyKey1),
		SiteName: to.Ptr("testSiteName"),
	}, 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.BotChannel = armbotservice.BotChannel{
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.WebChatChannel{
	// 		ChannelName: to.Ptr("WebChatChannel"),
	// 		Properties: &armbotservice.WebChatChannelProperties{
	// 			Sites: []*armbotservice.WebChatSite{
	// 				{
	// 					IsEnabled: to.Ptr(true),
	// 					IsWebchatPreviewEnabled: to.Ptr(true),
	// 					Key: to.Ptr("key1"),
	// 					Key2: to.Ptr("key2"),
	// 					SiteID: to.Ptr("abcd"),
	// 					SiteName: to.Ptr("Default Site"),
	// 			}},
	// 		},
	// 	},
	// }
}

Output:

type DirectLineClientRegenerateKeysOptions added in v0.2.0 

type DirectLineClientRegenerateKeysOptions struct {
}

DirectLineClientRegenerateKeysOptions contains the optional parameters for the DirectLineClient.RegenerateKeys method.

type DirectLineClientRegenerateKeysResponse added in v0.2.0 

type DirectLineClientRegenerateKeysResponse struct {
	// Bot channel resource definition
	BotChannel
}

DirectLineClientRegenerateKeysResponse contains the response from method DirectLineClient.RegenerateKeys.

type DirectLineSite 

type DirectLineSite struct {
	// REQUIRED; Whether this site is enabled for DirectLine channel
	IsEnabled *bool

	// REQUIRED; Site name
	SiteName *string

	// DirectLine application id
	AppID *string

	// Entity Tag
	ETag *string

	// Whether this site is enabled for block user upload.
	IsBlockUserUploadEnabled *bool

	// Whether this site is disabled detailed logging for
	IsDetailedLoggingEnabled *bool

	// Whether this site is EndpointParameters enabled for channel
	IsEndpointParametersEnabled *bool

	// Whether this no-storage site is disabled detailed logging for
	IsNoStorageEnabled *bool

	// Whether this site is enabled for authentication with Bot Framework.
	IsSecureSiteEnabled *bool

	// Whether this site is enabled for Bot Framework V1 protocol.
	IsV1Enabled *bool

	// Whether this site is enabled for Bot Framework V3 protocol.
	IsV3Enabled *bool

	// Whether this site is enabled for Webchat Speech
	IsWebChatSpeechEnabled *bool

	// Whether this site is enabled for preview versions of Webchat
	IsWebchatPreviewEnabled *bool

	// Tenant Id
	TenantID *string

	// List of Trusted Origin URLs for this site. This field is applicable only if isSecureSiteEnabled is True.
	TrustedOrigins []*string

	// READ-ONLY; Whether this site is token enabled for channel
	IsTokenEnabled *bool

	// READ-ONLY; Primary key. Value only returned through POST to the action Channel List API, otherwise empty.
	Key *string

	// READ-ONLY; Secondary key. Value only returned through POST to the action Channel List API, otherwise empty.
	Key2 *string

	// READ-ONLY; Site Id
	SiteID *string
}

DirectLineSite - A site for the Direct Line channel

func (DirectLineSite) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DirectLineSite.

func (*DirectLineSite) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DirectLineSite.

type DirectLineSpeechChannel 

type DirectLineSpeechChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to DirectLine Speech channel resource
	Properties *DirectLineSpeechChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

DirectLineSpeechChannel - DirectLine Speech channel definition

func (*DirectLineSpeechChannel) GetChannel added in v0.2.0 

func (d *DirectLineSpeechChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type DirectLineSpeechChannel.

func (DirectLineSpeechChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DirectLineSpeechChannel.

func (*DirectLineSpeechChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DirectLineSpeechChannel.

type DirectLineSpeechChannelProperties 

type DirectLineSpeechChannelProperties struct {
	// The cognitive service region with this channel registration.
	CognitiveServiceRegion *string

	// The cognitive service id with this channel registration.
	CognitiveServiceResourceID *string

	// The cognitive service subscription key to use with this channel registration.
	CognitiveServiceSubscriptionKey *string

	// Custom voice deployment id (optional).
	CustomSpeechModelID *string

	// Custom speech model id (optional).
	CustomVoiceDeploymentID *string

	// Make this a default bot for chosen cognitive service account.
	IsDefaultBotForCogSvcAccount *bool

	// Whether this channel is enabled or not.
	IsEnabled *bool
}

DirectLineSpeechChannelProperties - The parameters to provide for the DirectLine Speech channel.

func (DirectLineSpeechChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type DirectLineSpeechChannelProperties.

func (*DirectLineSpeechChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DirectLineSpeechChannelProperties.

type EmailChannel 

type EmailChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to email channel resource
	Properties *EmailChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

EmailChannel - Email channel definition

func (*EmailChannel) GetChannel added in v0.2.0 

func (e *EmailChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type EmailChannel.

func (EmailChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EmailChannel.

func (*EmailChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EmailChannel.

type EmailChannelAuthMethod added in v1.0.0 

type EmailChannelAuthMethod float32

EmailChannelAuthMethod - Email channel auth method. 0 Password (Default); 1 Graph. 

const (
	// EmailChannelAuthMethodGraph - Modern authentication.
	EmailChannelAuthMethodGraph EmailChannelAuthMethod = 1
	// EmailChannelAuthMethodPassword - Basic authentication.
	EmailChannelAuthMethodPassword EmailChannelAuthMethod = 0
)

func PossibleEmailChannelAuthMethodValues added in v1.0.0 

func PossibleEmailChannelAuthMethodValues() []EmailChannelAuthMethod

PossibleEmailChannelAuthMethodValues returns the possible values for the EmailChannelAuthMethod const type.

type EmailChannelProperties 

type EmailChannelProperties struct {
	// REQUIRED; The email address
	EmailAddress *string

	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// Email channel auth method. 0 Password (Default); 1 Graph.
	AuthMethod *EmailChannelAuthMethod

	// The magic code for setting up the modern authentication.
	MagicCode *string

	// The password for the email address. Value only returned through POST to the action Channel List API, otherwise empty.
	Password *string
}

EmailChannelProperties - The parameters to provide for the Email channel.

func (EmailChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type EmailChannelProperties.

func (*EmailChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EmailChannelProperties.

type EmailClient added in v1.0.0 

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

EmailClient contains the methods for the Email group. Don't use this type directly, use NewEmailClient() instead.

func NewEmailClient added in v1.0.0 

func NewEmailClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*EmailClient, error)

NewEmailClient creates a new instance of EmailClient 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 (*EmailClient) CreateSignInURL added in v1.0.0 

func (client *EmailClient) CreateSignInURL(ctx context.Context, resourceGroupName string, resourceName string, options *EmailClientCreateSignInURLOptions) (EmailClientCreateSignInURLResponse, error)

CreateSignInURL - Creates an email channel sign in url for a Bot Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • options - EmailClientCreateSignInURLOptions contains the optional parameters for the EmailClient.CreateSignInURL method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/CreateEmailSignInUrl.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewEmailClient().CreateSignInURL(ctx, "OneResourceGroupName", "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.CreateEmailSignInURLResponse = armbotservice.CreateEmailSignInURLResponse{
	// 	ID: to.Ptr("/subscriptions/subscription-id/resourceGroups/OneResourceGroupName/providers/Microsoft.BotService/botServices/samplebotname"),
	// 	Location: to.Ptr("global"),
	// 	Properties: &armbotservice.CreateEmailSignInURLResponseProperties{
	// 		URL: to.Ptr("https://token.botframework.com/api/oauth/signin?signin=XXX"),
	// 	},
	// }
}

Output:

type EmailClientCreateSignInURLOptions added in v1.0.0 

type EmailClientCreateSignInURLOptions struct {
}

EmailClientCreateSignInURLOptions contains the optional parameters for the EmailClient.CreateSignInURL method.

type EmailClientCreateSignInURLResponse added in v1.0.0 

type EmailClientCreateSignInURLResponse struct {
	// The ARM create email sign in url operation response.
	CreateEmailSignInURLResponse
}

EmailClientCreateSignInURLResponse contains the response from method EmailClient.CreateSignInURL.

type Error 

type Error struct {
	// The error body.
	Error *ErrorBody
}

Error - Bot Service error object.

func (Error) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type Error.

func (*Error) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Error.

type ErrorBody 

type ErrorBody struct {
	// REQUIRED; error code
	Code *string

	// REQUIRED; error message
	Message *string
}

ErrorBody - Bot Service error body.

func (ErrorBody) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ErrorBody.

func (*ErrorBody) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorBody.

type FacebookChannel 

type FacebookChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to bot facebook channel
	Properties *FacebookChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

FacebookChannel - Facebook channel definition

func (*FacebookChannel) GetChannel added in v0.2.0 

func (f *FacebookChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type FacebookChannel.

func (FacebookChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FacebookChannel.

func (*FacebookChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FacebookChannel.

type FacebookChannelProperties 

type FacebookChannelProperties struct {
	// REQUIRED; Facebook application id
	AppID *string

	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// Facebook application secret. Value only returned through POST to the action Channel List API, otherwise empty.
	AppSecret *string

	// The list of Facebook pages
	Pages []*FacebookPage

	// READ-ONLY; Callback Url
	CallbackURL *string

	// READ-ONLY; Verify token. Value only returned through POST to the action Channel List API, otherwise empty.
	VerifyToken *string
}

FacebookChannelProperties - The parameters to provide for the Facebook channel.

func (FacebookChannelProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FacebookChannelProperties.

func (*FacebookChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FacebookChannelProperties.

type FacebookPage 

type FacebookPage struct {
	// REQUIRED; Page id
	ID *string

	// Facebook application access token. Value only returned through POST to the action Channel List API, otherwise empty.
	AccessToken *string
}

FacebookPage - A Facebook page for Facebook channel registration

func (FacebookPage) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type FacebookPage.

func (*FacebookPage) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FacebookPage.

type HostSettingsClient 

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

HostSettingsClient contains the methods for the HostSettings group. Don't use this type directly, use NewHostSettingsClient() instead.

func NewHostSettingsClient 

func NewHostSettingsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*HostSettingsClient, error)

NewHostSettingsClient creates a new instance of HostSettingsClient 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 (*HostSettingsClient) Get 

func (client *HostSettingsClient) Get(ctx context.Context, options *HostSettingsClientGetOptions) (HostSettingsClientGetResponse, error)

Get - Get per subscription settings needed to host bot in compute resource such as Azure App Service If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • options - HostSettingsClientGetOptions contains the optional parameters for the HostSettingsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetHostSettings.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewHostSettingsClient().Get(ctx, 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.HostSettingsResponse = armbotservice.HostSettingsResponse{
	// 	BotOpenIDMetadata: to.Ptr("https://login.botframework.com/v1/.well-known/openidconfiguration"),
	// 	OAuthURL: to.Ptr("https://token.botframework.com/"),
	// 	ToBotFromChannelOpenIDMetadataURL: to.Ptr("https://login.botframework.com/v1/.well-known/openidconfiguration"),
	// 	ToBotFromChannelTokenIssuer: to.Ptr("https://api.botframework.com"),
	// 	ToBotFromEmulatorOpenIDMetadataURL: to.Ptr("https://login.microsoftonline.com/botframework.com/v2.0/.well-known/openid-configuration"),
	// 	ToChannelFromBotLoginURL: to.Ptr("https://login.microsoftonline.com/botframework.com"),
	// 	ToChannelFromBotOAuthScope: to.Ptr("https://api.botframework.com"),
	// 	ValidateAuthority: to.Ptr(true),
	// }
}

Output:

type HostSettingsClientGetOptions added in v0.2.0 

type HostSettingsClientGetOptions struct {
}

HostSettingsClientGetOptions contains the optional parameters for the HostSettingsClient.Get method.

type HostSettingsClientGetResponse added in v0.2.0 

type HostSettingsClientGetResponse struct {
	// The response body returned for a request to Bot Service Management to check per subscription hostSettings
	HostSettingsResponse
}

HostSettingsClientGetResponse contains the response from method HostSettingsClient.Get.

type HostSettingsResponse 

type HostSettingsResponse struct {
	// Same as toBotFromChannelOpenIdMetadataUrl, used by SDK < v4.12
	BotOpenIDMetadata *string

	// For in-conversation bot user authentication
	OAuthURL *string

	// For verifying incoming tokens from the channels
	ToBotFromChannelOpenIDMetadataURL *string

	// For verifying incoming tokens from the channels
	ToBotFromChannelTokenIssuer *string

	// For verifying incoming tokens from bot emulator
	ToBotFromEmulatorOpenIDMetadataURL *string

	// For getting access token to channels from bot host
	ToChannelFromBotLoginURL *string

	// For getting access token to channels from bot host
	ToChannelFromBotOAuthScope *string

	// Per cloud OAuth setting on whether authority is validated
	ValidateAuthority *bool
}

HostSettingsResponse - The response body returned for a request to Bot Service Management to check per subscription hostSettings

func (HostSettingsResponse) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type HostSettingsResponse.

func (*HostSettingsResponse) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HostSettingsResponse.

type Key 

type Key string

Key - Determines which key is to be regenerated 

const (
	KeyKey1 Key = "key1"
	KeyKey2 Key = "key2"
)

func PossibleKeyValues 

func PossibleKeyValues() []Key

PossibleKeyValues returns the possible values for the Key const type.

type KikChannel 

type KikChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Kik channel resource
	Properties *KikChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

KikChannel - Kik channel definition

func (*KikChannel) GetChannel added in v0.2.0 

func (k *KikChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type KikChannel.

func (KikChannel) MarshalJSON 

func (k KikChannel) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KikChannel.

func (*KikChannel) UnmarshalJSON 

func (k *KikChannel) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KikChannel.

type KikChannelProperties 

type KikChannelProperties struct {
	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// REQUIRED; The Kik user name
	UserName *string

	// Kik API key. Value only returned through POST to the action Channel List API, otherwise empty.
	APIKey *string

	// Whether this channel is validated for the bot
	IsValidated *bool
}

KikChannelProperties - The parameters to provide for the Kik channel.

func (KikChannelProperties) MarshalJSON added in v1.0.0 

func (k KikChannelProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KikChannelProperties.

func (*KikChannelProperties) UnmarshalJSON added in v1.0.0 

func (k *KikChannelProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KikChannelProperties.

type Kind 

type Kind string

Kind - Indicates the type of bot service 

const (
	KindAzurebot Kind = "azurebot"
	KindBot      Kind = "bot"
	KindDesigner Kind = "designer"
	KindFunction Kind = "function"
	KindSdk      Kind = "sdk"
)

func PossibleKindValues 

func PossibleKindValues() []Kind

PossibleKindValues returns the possible values for the Kind const type.

type LineChannel 

type LineChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to line channel resource
	Properties *LineChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

LineChannel - Line channel definition

func (*LineChannel) GetChannel added in v0.2.0 

func (l *LineChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type LineChannel.

func (LineChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LineChannel.

func (*LineChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LineChannel.

type LineChannelProperties 

type LineChannelProperties struct {
	// REQUIRED; The list of line channel registrations
	LineRegistrations []*LineRegistration

	// READ-ONLY; Callback Url to enter in line registration.
	CallbackURL *string

	// READ-ONLY; Whether this channel is validated for the bot
	IsValidated *bool
}

LineChannelProperties - The parameters to provide for the Line channel.

func (LineChannelProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LineChannelProperties.

func (*LineChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LineChannelProperties.

type LineRegistration 

type LineRegistration struct {
	// Access token for the line channel registration
	ChannelAccessToken *string

	// Secret for the line channel registration
	ChannelSecret *string

	// READ-ONLY; Id generated for the line channel registration
	GeneratedID *string
}

LineRegistration - The properties corresponding to a line channel registration

func (LineRegistration) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type LineRegistration.

func (*LineRegistration) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LineRegistration.

type ListChannelWithKeysResponse added in v0.2.0 

type ListChannelWithKeysResponse struct {
	// Changed time of the resource
	ChangedTime *string

	// Entity tag of the resource
	EntityTag *string

	// Entity Tag
	Etag *string

	// Required. Gets or sets the Kind of the resource.
	Kind *Kind

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to bot channel resource
	Properties ChannelClassification

	// Provisioning state of the resource
	ProvisioningState *string

	// The set of properties specific to bot channel resource
	Resource ChannelClassification

	// Gets or sets the SKU of the resource.
	SKU *SKU

	// Channel settings
	Setting *ChannelSettings

	// Contains resource tags defined as key/value pairs.
	Tags map[string]*string

	// READ-ONLY; Specifies the resource ID.
	ID *string

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

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

	// READ-ONLY; Entity zones
	Zones []*string
}

ListChannelWithKeysResponse - The ARM channel of list channel with keys operation response.

func (ListChannelWithKeysResponse) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ListChannelWithKeysResponse.

func (*ListChannelWithKeysResponse) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListChannelWithKeysResponse.

type M365Extensions added in v1.0.0 

type M365Extensions struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

M365Extensions - M365 Extensions definition

func (*M365Extensions) GetChannel added in v1.0.0 

func (m *M365Extensions) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type M365Extensions.

func (M365Extensions) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type M365Extensions.

func (*M365Extensions) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type M365Extensions.

type MsTeamsChannel 

type MsTeamsChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Microsoft Teams channel resource
	Properties *MsTeamsChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

MsTeamsChannel - Microsoft Teams channel definition

func (*MsTeamsChannel) GetChannel added in v0.2.0 

func (m *MsTeamsChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type MsTeamsChannel.

func (MsTeamsChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MsTeamsChannel.

func (*MsTeamsChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MsTeamsChannel.

type MsTeamsChannelProperties 

type MsTeamsChannelProperties struct {
	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// Whether this channel accepted terms
	AcceptedTerms *bool

	// Webhook for Microsoft Teams channel calls
	CallingWebhook *string

	// Deployment environment for Microsoft Teams channel calls
	DeploymentEnvironment *string

	// Enable calling for Microsoft Teams channel
	EnableCalling *bool

	// Webhook for Microsoft Teams channel calls
	IncomingCallRoute *string
}

MsTeamsChannelProperties - The parameters to provide for the Microsoft Teams channel.

func (MsTeamsChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type MsTeamsChannelProperties.

func (*MsTeamsChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MsTeamsChannelProperties.

type MsaAppType 

type MsaAppType string

MsaAppType - Microsoft App Type for the bot 

const (
	MsaAppTypeMultiTenant     MsaAppType = "MultiTenant"
	MsaAppTypeSingleTenant    MsaAppType = "SingleTenant"
	MsaAppTypeUserAssignedMSI MsaAppType = "UserAssignedMSI"
)

func PossibleMsaAppTypeValues 

func PossibleMsaAppTypeValues() []MsaAppType

PossibleMsaAppTypeValues returns the possible values for the MsaAppType const type.

type Omnichannel added in v1.0.0 

type Omnichannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

Omnichannel channel definition

func (*Omnichannel) GetChannel added in v1.0.0 

func (o *Omnichannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type Omnichannel.

func (Omnichannel) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type Omnichannel.

func (*Omnichannel) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Omnichannel.

type OperationDisplayInfo 

type OperationDisplayInfo struct {
	// The description of the operation.
	Description *string

	// The action that users can perform, based on their permission level.
	Operation *string

	// Service provider: Microsoft Bot Service.
	Provider *string

	// Resource on which the operation is performed.
	Resource *string
}

OperationDisplayInfo - The operation supported by Bot Service Management.

func (OperationDisplayInfo) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplayInfo.

func (*OperationDisplayInfo) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplayInfo.

type OperationEntity 

type OperationEntity struct {
	// The operation supported by Bot Service Management.
	Display *OperationDisplayInfo

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

	// The origin of the operation.
	Origin *string

	// Additional properties.
	Properties any
}

OperationEntity - The operations supported by Bot Service Management.

func (OperationEntity) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationEntity.

func (*OperationEntity) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationEntity.

type OperationEntityListResult 

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

	// The list of operations.
	Value []*OperationEntity
}

OperationEntityListResult - The list of bot service operation response.

func (OperationEntityListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationEntityListResult.

func (*OperationEntityListResult) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationEntityListResult.

type OperationResultStatus 

type OperationResultStatus string

OperationResultStatus - The status of the operation being performed. 

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

func PossibleOperationResultStatusValues 

func PossibleOperationResultStatusValues() []OperationResultStatus

PossibleOperationResultStatusValues returns the possible values for the OperationResultStatus const type.

type OperationResultsClient 

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

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

func NewOperationResultsClient 

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

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

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

func (*OperationResultsClient) BeginGet 

func (client *OperationResultsClient) BeginGet(ctx context.Context, operationResultID string, options *OperationResultsClientBeginGetOptions) (*runtime.Poller[OperationResultsClientGetResponse], error)

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

Generated from API version 2022-09-15

  • operationResultID - The ID of the operation result to get.
  • options - OperationResultsClientBeginGetOptions contains the optional parameters for the OperationResultsClient.BeginGet method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/OperationResultsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOperationResultsClient().BeginGet(ctx, "exampleid", 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.OperationResultsDescription = armbotservice.OperationResultsDescription{
	// 	Name: to.Ptr("servicename"),
	// 	ID: to.Ptr("/subscriptions/subid/providers/Microsoft.BotService/locations/westus/operationresults/exampleid"),
	// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-01-21T06:03:30.271Z"); return t}()),
	// 	Status: to.Ptr(armbotservice.OperationResultStatusRequested),
	// }
}

Output:

type OperationResultsClientBeginGetOptions added in v0.2.0 

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

OperationResultsClientBeginGetOptions contains the optional parameters for the OperationResultsClient.BeginGet method.

type OperationResultsClientGetResponse added in v0.2.0 

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

OperationResultsClientGetResponse contains the response from method OperationResultsClient.BeginGet.

type OperationResultsDescription 

type OperationResultsDescription struct {
	// READ-ONLY; The ID of the operation returned.
	ID *string

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

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

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

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

func (OperationResultsDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationResultsDescription.

func (*OperationResultsDescription) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationResultsDescription.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager added in v0.4.0 

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

NewListPager - Lists all the available BotService operations.

Generated from API version 2022-09-15

  • 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/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.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.OperationEntityListResult = armbotservice.OperationEntityListResult{
		// 	Value: []*armbotservice.OperationEntity{
		// 		{
		// 			Name: to.Ptr("Microsoft.BotService/botService/read"),
		// 			Display: &armbotservice.OperationDisplayInfo{
		// 				Description: to.Ptr("Read Bot Service"),
		// 				Operation: to.Ptr("Read Bot Service"),
		// 				Provider: to.Ptr("Microsoft Bot Service"),
		// 				Resource: to.Ptr("Bot Service"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.BotService/botService/write"),
		// 			Display: &armbotservice.OperationDisplayInfo{
		// 				Description: to.Ptr("Writes Bot Service"),
		// 				Operation: to.Ptr("Write Bot Service"),
		// 				Provider: to.Ptr("Microsoft Bot Service"),
		// 				Resource: to.Ptr("Bot Service"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.BotService/botService/delete"),
		// 			Display: &armbotservice.OperationDisplayInfo{
		// 				Description: to.Ptr("Deletes Bot Service"),
		// 				Operation: to.Ptr("Delete Bot Service"),
		// 				Provider: to.Ptr("Microsoft Bot Service"),
		// 				Resource: to.Ptr("Bot Service"),
		// 			},
		// 			Origin: to.Ptr("user,system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.BotService/botService/botName/read"),
		// 			Display: &armbotservice.OperationDisplayInfo{
		// 				Description: to.Ptr("Check bot name availability"),
		// 				Operation: to.Ptr("Check bot name availability"),
		// 				Provider: to.Ptr("Microsoft Bot Service"),
		// 				Resource: to.Ptr("Bot Service name availability"),
		// 			},
		// 			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 {
	// The list of bot service operation response.
	OperationEntityListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OutlookChannel added in v1.0.0 

type OutlookChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

OutlookChannel - Outlook channel definition

func (*OutlookChannel) GetChannel added in v1.0.0 

func (o *OutlookChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type OutlookChannel.

func (OutlookChannel) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type OutlookChannel.

func (*OutlookChannel) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OutlookChannel.

type PrivateEndpoint 

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

PrivateEndpoint - The Private Endpoint resource.

func (PrivateEndpoint) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpoint.

func (*PrivateEndpoint) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpoint.

type PrivateEndpointConnection 

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

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

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

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

PrivateEndpointConnection - The Private Endpoint Connection resource.

func (PrivateEndpointConnection) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnection.

func (*PrivateEndpointConnection) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnection.

type PrivateEndpointConnectionListResult 

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

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

func (PrivateEndpointConnectionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionListResult.

func (*PrivateEndpointConnectionListResult) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionListResult.

type PrivateEndpointConnectionProperties 

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

	// Group ids
	GroupIDs []*string

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

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

PrivateEndpointConnectionProperties - Properties of the PrivateEndpointConnectProperties.

func (PrivateEndpointConnectionProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionProperties.

func (*PrivateEndpointConnectionProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionProperties.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

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

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionsClient 

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

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

func NewPrivateEndpointConnectionsClient 

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

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

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

func (*PrivateEndpointConnectionsClient) Create 

func (client *PrivateEndpointConnectionsClient) Create(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, properties PrivateEndpointConnection, options *PrivateEndpointConnectionsClientCreateOptions) (PrivateEndpointConnectionsClientCreateResponse, error)

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

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • properties - The private endpoint connection properties.
  • options - PrivateEndpointConnectionsClientCreateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/PutPrivateEndpointConnection.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateEndpointConnectionsClient().Create(ctx, "res7687", "sto9699", "{privateEndpointConnectionName}", armbotservice.PrivateEndpointConnection{
		Properties: &armbotservice.PrivateEndpointConnectionProperties{
			PrivateLinkServiceConnectionState: &armbotservice.PrivateLinkServiceConnectionState{
				Description: to.Ptr("Auto-Approved"),
				Status:      to.Ptr(armbotservice.PrivateEndpointServiceConnectionStatusApproved),
			},
		},
	}, 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.PrivateEndpointConnection = armbotservice.PrivateEndpointConnection{
	// 	Name: to.Ptr("{privateEndpointConnectionName}"),
	// 	Type: to.Ptr("Microsoft.BotService/botServices/privateEndpointConnections"),
	// 	ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.BotService/botServices/sto288/privateEndpointConnections/{privateEndpointConnectionName}"),
	// 	Properties: &armbotservice.PrivateEndpointConnectionProperties{
	// 		PrivateEndpoint: &armbotservice.PrivateEndpoint{
	// 			ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.Network/privateEndpoints/petest01"),
	// 		},
	// 		PrivateLinkServiceConnectionState: &armbotservice.PrivateLinkServiceConnectionState{
	// 			Description: to.Ptr("Auto-Approved"),
	// 			ActionsRequired: to.Ptr("None"),
	// 			Status: to.Ptr(armbotservice.PrivateEndpointServiceConnectionStatusApproved),
	// 		},
	// 		ProvisioningState: to.Ptr(armbotservice.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*PrivateEndpointConnectionsClient) Delete 

func (client *PrivateEndpointConnectionsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientDeleteOptions) (PrivateEndpointConnectionsClientDeleteResponse, error)

Delete - Deletes the specified private endpoint connection associated with the Bot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource
  • options - PrivateEndpointConnectionsClientDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/DeletePrivateEndpointConnection.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

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

Output:

func (*PrivateEndpointConnectionsClient) Get 

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

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

Generated from API version 2022-09-15

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/GetPrivateEndpointConnection.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "res6977", "sto2527", "{privateEndpointConnectionName}", 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.PrivateEndpointConnection = armbotservice.PrivateEndpointConnection{
	// 	Name: to.Ptr("{privateEndpointConnectionName}"),
	// 	Type: to.Ptr("Microsoft.BotService/botServices/privateEndpointConnections"),
	// 	ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.BotService/botServices/sto288/privateEndpointConnections/{privateEndpointConnectionName}"),
	// 	Properties: &armbotservice.PrivateEndpointConnectionProperties{
	// 		PrivateEndpoint: &armbotservice.PrivateEndpoint{
	// 			ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.Network/privateEndpoints/petest01"),
	// 		},
	// 		PrivateLinkServiceConnectionState: &armbotservice.PrivateLinkServiceConnectionState{
	// 			Description: to.Ptr("Auto-Approved"),
	// 			ActionsRequired: to.Ptr("None"),
	// 			Status: to.Ptr(armbotservice.PrivateEndpointServiceConnectionStatusApproved),
	// 		},
	// 		ProvisioningState: to.Ptr(armbotservice.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*PrivateEndpointConnectionsClient) NewListPager added in v0.4.0 

func (client *PrivateEndpointConnectionsClient) NewListPager(resourceGroupName string, resourceName string, options *PrivateEndpointConnectionsClientListOptions) *runtime.Pager[PrivateEndpointConnectionsClientListResponse]

NewListPager - List all the private endpoint connections associated with the Bot.

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • options - PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListPrivateEndpointConnections.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPrivateEndpointConnectionsClient().NewListPager("res6977", "sto2527", 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.PrivateEndpointConnectionListResult = armbotservice.PrivateEndpointConnectionListResult{
		// 	Value: []*armbotservice.PrivateEndpointConnection{
		// 		{
		// 			Name: to.Ptr("{privateEndpointConnectionName}"),
		// 			Type: to.Ptr("Microsoft.BotService/botServices/privateEndpointConnections"),
		// 			ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.BotService/botServices/sto288/privateEndpointConnections/{privateEndpointConnectionName}"),
		// 			Properties: &armbotservice.PrivateEndpointConnectionProperties{
		// 				PrivateEndpoint: &armbotservice.PrivateEndpoint{
		// 					ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.Network/privateEndpoints/petest01"),
		// 				},
		// 				PrivateLinkServiceConnectionState: &armbotservice.PrivateLinkServiceConnectionState{
		// 					Description: to.Ptr("Auto-Approved"),
		// 					ActionsRequired: to.Ptr("None"),
		// 					Status: to.Ptr(armbotservice.PrivateEndpointServiceConnectionStatusApproved),
		// 				},
		// 				ProvisioningState: to.Ptr(armbotservice.PrivateEndpointConnectionProvisioningStateSucceeded),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("{privateEndpointConnectionName}"),
		// 			Type: to.Ptr("Microsoft.BotService/botServices/privateEndpointConnections"),
		// 			ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.BotService/botServices/sto288/privateEndpointConnections/{privateEndpointConnectionName}"),
		// 			Properties: &armbotservice.PrivateEndpointConnectionProperties{
		// 				PrivateEndpoint: &armbotservice.PrivateEndpoint{
		// 					ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res7231/providers/Microsoft.Network/privateEndpoints/petest02"),
		// 				},
		// 				PrivateLinkServiceConnectionState: &armbotservice.PrivateLinkServiceConnectionState{
		// 					Description: to.Ptr("Auto-Approved"),
		// 					ActionsRequired: to.Ptr("None"),
		// 					Status: to.Ptr(armbotservice.PrivateEndpointServiceConnectionStatusApproved),
		// 				},
		// 				ProvisioningState: to.Ptr(armbotservice.PrivateEndpointConnectionProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

type PrivateEndpointConnectionsClientCreateOptions added in v0.2.0 

type PrivateEndpointConnectionsClientCreateOptions struct {
}

PrivateEndpointConnectionsClientCreateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Create method.

type PrivateEndpointConnectionsClientCreateResponse added in v0.2.0 

type PrivateEndpointConnectionsClientCreateResponse struct {
	// The Private Endpoint Connection resource.
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientCreateResponse contains the response from method PrivateEndpointConnectionsClient.Create.

type PrivateEndpointConnectionsClientDeleteOptions added in v0.2.0 

type PrivateEndpointConnectionsClientDeleteOptions struct {
}

PrivateEndpointConnectionsClientDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Delete method.

type PrivateEndpointConnectionsClientDeleteResponse added in v0.2.0 

type PrivateEndpointConnectionsClientDeleteResponse struct {
}

PrivateEndpointConnectionsClientDeleteResponse contains the response from method PrivateEndpointConnectionsClient.Delete.

type PrivateEndpointConnectionsClientGetOptions added in v0.2.0 

type PrivateEndpointConnectionsClientGetOptions struct {
}

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

type PrivateEndpointConnectionsClientGetResponse added in v0.2.0 

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

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListOptions added in v0.2.0 

type PrivateEndpointConnectionsClientListOptions struct {
}

PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListPager method.

type PrivateEndpointConnectionsClientListResponse added in v0.2.0 

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

PrivateEndpointConnectionsClientListResponse contains the response from method PrivateEndpointConnectionsClient.NewListPager.

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string

PrivateEndpointServiceConnectionStatus - The private endpoint connection status. 

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

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.

type PrivateLinkResource 

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

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

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

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

PrivateLinkResource - A private link resource

func (PrivateLinkResource) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResource.

func (*PrivateLinkResource) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResource.

type PrivateLinkResourceBase 

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

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

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

PrivateLinkResourceBase - Common fields that are returned in the response for all BotService Private Link Resources

func (PrivateLinkResourceBase) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceBase.

func (*PrivateLinkResourceBase) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceBase.

type PrivateLinkResourceListResult 

type PrivateLinkResourceListResult struct {
	// Array of private link resources
	Value []*PrivateLinkResource
}

PrivateLinkResourceListResult - A list of private link resources

func (PrivateLinkResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceListResult.

func (*PrivateLinkResourceListResult) UnmarshalJSON added in v1.0.0 

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

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceProperties.

type PrivateLinkResourcesClient 

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

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

func NewPrivateLinkResourcesClient 

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

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

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

func (*PrivateLinkResourcesClient) ListByBotResource 

func (client *PrivateLinkResourcesClient) ListByBotResource(ctx context.Context, resourceGroupName string, resourceName string, options *PrivateLinkResourcesClientListByBotResourceOptions) (PrivateLinkResourcesClientListByBotResourceResponse, error)

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

Generated from API version 2022-09-15

  • resourceGroupName - The name of the Bot resource group in the user subscription.
  • resourceName - The name of the Bot resource.
  • options - PrivateLinkResourcesClientListByBotResourceOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByBotResource method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListPrivateLinkResources.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPrivateLinkResourcesClient().ListByBotResource(ctx, "res6977", "sto2527", 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.PrivateLinkResourceListResult = armbotservice.PrivateLinkResourceListResult{
	// 	Value: []*armbotservice.PrivateLinkResource{
	// 		{
	// 			Name: to.Ptr("resource1"),
	// 			Type: to.Ptr("Microsoft.BotService/botServices/privateLinkResources"),
	// 			ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res6977/providers/Microsoft.BotService/botServices/sto2527/privateLinkResources/resource1"),
	// 			Properties: &armbotservice.PrivateLinkResourceProperties{
	// 				GroupID: to.Ptr("bot"),
	// 				RequiredMembers: []*string{
	// 					to.Ptr("bot")},
	// 					RequiredZoneNames: []*string{
	// 						to.Ptr("privatelink.botframework.com")},
	// 					},
	// 			}},
	// 		}
}

Output:

type PrivateLinkResourcesClientListByBotResourceOptions added in v0.2.0 

type PrivateLinkResourcesClientListByBotResourceOptions struct {
}

PrivateLinkResourcesClientListByBotResourceOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByBotResource method.

type PrivateLinkResourcesClientListByBotResourceResponse added in v0.2.0 

type PrivateLinkResourcesClientListByBotResourceResponse struct {
	// A list of private link resources
	PrivateLinkResourceListResult
}

PrivateLinkResourcesClientListByBotResourceResponse contains the response from method PrivateLinkResourcesClient.ListByBotResource.

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

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkServiceConnectionState.

func (*PrivateLinkServiceConnectionState) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkServiceConnectionState.

type PublicNetworkAccess added in v0.2.0 

type PublicNetworkAccess string

PublicNetworkAccess - Whether the bot is in an isolated network 

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

func PossiblePublicNetworkAccessValues added in v0.2.0 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

type QnAMakerEndpointKeysClient added in v1.0.0 

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

QnAMakerEndpointKeysClient contains the methods for the QnAMakerEndpointKeys group. Don't use this type directly, use NewQnAMakerEndpointKeysClient() instead.

func NewQnAMakerEndpointKeysClient added in v1.0.0 

func NewQnAMakerEndpointKeysClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*QnAMakerEndpointKeysClient, error)

NewQnAMakerEndpointKeysClient creates a new instance of QnAMakerEndpointKeysClient 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 (*QnAMakerEndpointKeysClient) Get added in v1.0.0 

func (client *QnAMakerEndpointKeysClient) Get(ctx context.Context, parameters QnAMakerEndpointKeysRequestBody, options *QnAMakerEndpointKeysClientGetOptions) (QnAMakerEndpointKeysClientGetResponse, error)

Get - Lists the QnA Maker endpoint keys If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-09-15

  • parameters - The request body parameters to provide for the check name availability request
  • options - QnAMakerEndpointKeysClientGetOptions contains the optional parameters for the QnAMakerEndpointKeysClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/botservice/resource-manager/Microsoft.BotService/stable/2022-09-15/examples/ListQnAMakerEndpointKeys.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/botservice/armbotservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbotservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewQnAMakerEndpointKeysClient().Get(ctx, armbotservice.QnAMakerEndpointKeysRequestBody{
		Authkey:  to.Ptr("testAuthKey"),
		Hostname: to.Ptr("https://xxx.cognitiveservices.azure.com/"),
	}, 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.QnAMakerEndpointKeysResponse = armbotservice.QnAMakerEndpointKeysResponse{
	// 	InstalledVersion: to.Ptr("4.1.0"),
	// 	LastStableVersion: to.Ptr("4.2.0"),
	// 	PrimaryEndpointKey: to.Ptr("sample_primaryEndpointKey"),
	// 	SecondaryEndpointKey: to.Ptr("sample_secondaryEndpointKey"),
	// }
}

Output:

type QnAMakerEndpointKeysClientGetOptions added in v1.0.0 

type QnAMakerEndpointKeysClientGetOptions struct {
}

QnAMakerEndpointKeysClientGetOptions contains the optional parameters for the QnAMakerEndpointKeysClient.Get method.

type QnAMakerEndpointKeysClientGetResponse added in v1.0.0 

type QnAMakerEndpointKeysClientGetResponse struct {
	// Schema for EndpointKeys generate/refresh operations.
	QnAMakerEndpointKeysResponse
}

QnAMakerEndpointKeysClientGetResponse contains the response from method QnAMakerEndpointKeysClient.Get.

type QnAMakerEndpointKeysRequestBody added in v1.0.0 

type QnAMakerEndpointKeysRequestBody struct {
	// Subscription key which provides access to this API.
	Authkey *string

	// the host name of the QnA Maker endpoint
	Hostname *string
}

QnAMakerEndpointKeysRequestBody - The request body for a request to Bot Service Management to list QnA Maker endpoint keys.

func (QnAMakerEndpointKeysRequestBody) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type QnAMakerEndpointKeysRequestBody.

func (*QnAMakerEndpointKeysRequestBody) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type QnAMakerEndpointKeysRequestBody.

type QnAMakerEndpointKeysResponse added in v1.0.0 

type QnAMakerEndpointKeysResponse struct {
	// Current version of runtime.
	InstalledVersion *string

	// Latest version of runtime.
	LastStableVersion *string

	// Primary Access Key.
	PrimaryEndpointKey *string

	// Secondary Access Key.
	SecondaryEndpointKey *string
}

QnAMakerEndpointKeysResponse - Schema for EndpointKeys generate/refresh operations.

func (QnAMakerEndpointKeysResponse) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type QnAMakerEndpointKeysResponse.

func (*QnAMakerEndpointKeysResponse) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type QnAMakerEndpointKeysResponse.

type RegenerateKeysChannelName 

type RegenerateKeysChannelName string
const (
	RegenerateKeysChannelNameDirectLineChannel RegenerateKeysChannelName = "DirectLineChannel"
	RegenerateKeysChannelNameWebChatChannel    RegenerateKeysChannelName = "WebChatChannel"
)

func PossibleRegenerateKeysChannelNameValues 

func PossibleRegenerateKeysChannelNameValues() []RegenerateKeysChannelName

PossibleRegenerateKeysChannelNameValues returns the possible values for the RegenerateKeysChannelName const type.

type Resource 

type Resource struct {
	// Entity Tag
	Etag *string

	// Required. Gets or sets the Kind of the resource.
	Kind *Kind

	// Specifies the location of the resource.
	Location *string

	// Gets or sets the SKU of the resource.
	SKU *SKU

	// Contains resource tags defined as key/value pairs.
	Tags map[string]*string

	// READ-ONLY; Specifies the resource ID.
	ID *string

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

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

	// READ-ONLY; Entity zones
	Zones []*string
}

Resource - Azure resource

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SKU 

type SKU struct {
	// REQUIRED; The sku name
	Name *SKUName

	// READ-ONLY; Gets the sku tier. This is based on the SKU name.
	Tier *SKUTier
}

SKU - The SKU of the cognitive services account.

func (SKU) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON added in v1.0.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 SKU. 

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

func PossibleSKUNameValues 

func PossibleSKUNameValues() []SKUName

PossibleSKUNameValues returns the possible values for the SKUName const type.

type SKUTier 

type SKUTier string

SKUTier - Gets the sku tier. This is based on the SKU name. 

const (
	SKUTierFree     SKUTier = "Free"
	SKUTierStandard SKUTier = "Standard"
)

func PossibleSKUTierValues 

func PossibleSKUTierValues() []SKUTier

PossibleSKUTierValues returns the possible values for the SKUTier const type.

type SearchAssistant added in v1.0.0 

type SearchAssistant struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

SearchAssistant definition

func (*SearchAssistant) GetChannel added in v1.0.0 

func (s *SearchAssistant) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type SearchAssistant.

func (SearchAssistant) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type SearchAssistant.

func (*SearchAssistant) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SearchAssistant.

type ServiceProvider 

type ServiceProvider struct {
	// The Properties of a Service Provider Object
	Properties *ServiceProviderProperties
}

ServiceProvider - Service Provider Definition

func (ServiceProvider) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ServiceProvider.

func (*ServiceProvider) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceProvider.

type ServiceProviderParameter 

type ServiceProviderParameter struct {
	// READ-ONLY; Default Name for the Service Provider
	Default *string

	// READ-ONLY; Description of the Service Provider
	Description *string

	// READ-ONLY; Display Name of the Service Provider
	DisplayName *string

	// READ-ONLY; Help Url for the Service Provider
	HelpURL *string

	// READ-ONLY; Meta data for the Service Provider
	Metadata *ServiceProviderParameterMetadata

	// READ-ONLY; Name of the Service Provider
	Name *string

	// READ-ONLY; Type of the Service Provider
	Type *string
}

ServiceProviderParameter - Extra Parameters specific to each Service Provider

func (ServiceProviderParameter) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ServiceProviderParameter.

func (*ServiceProviderParameter) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceProviderParameter.

type ServiceProviderParameterMetadata added in v0.2.0 

type ServiceProviderParameterMetadata struct {
	// the constraints of the bot meta data.
	Constraints *ServiceProviderParameterMetadataConstraints
}

ServiceProviderParameterMetadata - Meta data for the Service Provider

func (ServiceProviderParameterMetadata) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ServiceProviderParameterMetadata.

func (*ServiceProviderParameterMetadata) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceProviderParameterMetadata.

type ServiceProviderParameterMetadataConstraints added in v0.2.0 

type ServiceProviderParameterMetadataConstraints struct {
	// Whether required the constraints of the bot meta data.
	Required *bool
}

ServiceProviderParameterMetadataConstraints - the constraints of the bot meta data.

func (ServiceProviderParameterMetadataConstraints) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ServiceProviderParameterMetadataConstraints.

func (*ServiceProviderParameterMetadataConstraints) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceProviderParameterMetadataConstraints.

type ServiceProviderProperties 

type ServiceProviderProperties struct {
	// The URL of icon
	IconURL *string

	// The list of parameters for the Service Provider
	Parameters []*ServiceProviderParameter

	// READ-ONLY; URL of Dev Portal
	DevPortalURL *string

	// READ-ONLY; Display Name of the Service Provider
	DisplayName *string

	// READ-ONLY; Id for Service Provider
	ID *string

	// READ-ONLY; Name of the Service Provider
	ServiceProviderName *string
}

ServiceProviderProperties - The Object used to describe a Service Provider supported by Bot Service

func (ServiceProviderProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceProviderProperties.

func (*ServiceProviderProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceProviderProperties.

type ServiceProviderResponseList 

type ServiceProviderResponseList struct {
	// The link used to get the next page of bot service providers.
	NextLink *string

	// READ-ONLY; Gets the list of bot service providers and their properties.
	Value []*ServiceProvider
}

ServiceProviderResponseList - The list of bot service providers response.

func (ServiceProviderResponseList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceProviderResponseList.

func (*ServiceProviderResponseList) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceProviderResponseList.

type Site added in v0.2.0 

type Site struct {
	// REQUIRED; Whether this site is enabled for DirectLine channel
	IsEnabled *bool

	// REQUIRED; Site name
	SiteName *string

	// DirectLine application id
	AppID *string

	// Entity Tag
	ETag *string

	// Whether this site is enabled for block user upload.
	IsBlockUserUploadEnabled *bool

	// Whether this site is disabled detailed logging for
	IsDetailedLoggingEnabled *bool

	// Whether this site is EndpointParameters enabled for channel
	IsEndpointParametersEnabled *bool

	// Whether this no-storage site is disabled detailed logging for
	IsNoStorageEnabled *bool

	// Whether this site is enabled for authentication with Bot Framework.
	IsSecureSiteEnabled *bool

	// Whether this site is enabled for Bot Framework V1 protocol.
	IsV1Enabled *bool

	// Whether this site is enabled for Bot Framework V3 protocol.
	IsV3Enabled *bool

	// Whether this site is enabled for Webchat Speech
	IsWebChatSpeechEnabled *bool

	// Whether this site is enabled for preview versions of Webchat
	IsWebchatPreviewEnabled *bool

	// Tenant Id
	TenantID *string

	// List of Trusted Origin URLs for this site. This field is applicable only if isSecureSiteEnabled is True.
	TrustedOrigins []*string

	// READ-ONLY; Whether this site is token enabled for channel
	IsTokenEnabled *bool

	// READ-ONLY; Primary key. Value only returned through POST to the action Channel List API, otherwise empty.
	Key *string

	// READ-ONLY; Secondary key. Value only returned through POST to the action Channel List API, otherwise empty.
	Key2 *string

	// READ-ONLY; Site Id
	SiteID *string
}

Site - A site for the channel

func (Site) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type Site.

func (*Site) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Site.

type SiteInfo 

type SiteInfo struct {
	// REQUIRED; Determines which key is to be regenerated
	Key *Key

	// REQUIRED; The site name
	SiteName *string
}

SiteInfo - Site information for WebChat or DirectLine Channels to identify which site to regenerate keys for.

func (SiteInfo) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type SiteInfo.

func (*SiteInfo) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteInfo.

type SkypeChannel 

type SkypeChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Skype channel resource
	Properties *SkypeChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

SkypeChannel - Skype channel definition

func (*SkypeChannel) GetChannel added in v0.2.0 

func (s *SkypeChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type SkypeChannel.

func (SkypeChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SkypeChannel.

func (*SkypeChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SkypeChannel.

type SkypeChannelProperties 

type SkypeChannelProperties struct {
	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// Calling web hook for Skype channel
	CallingWebHook *string

	// Enable calling for Skype channel
	EnableCalling *bool

	// Enable groups for Skype channel
	EnableGroups *bool

	// Enable media cards for Skype channel
	EnableMediaCards *bool

	// Enable messaging for Skype channel
	EnableMessaging *bool

	// Enable screen sharing for Skype channel
	EnableScreenSharing *bool

	// Enable video for Skype channel
	EnableVideo *bool

	// Group mode for Skype channel
	GroupsMode *string

	// Incoming call route for Skype channel
	IncomingCallRoute *string
}

SkypeChannelProperties - The parameters to provide for the Microsoft Teams channel.

func (SkypeChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type SkypeChannelProperties.

func (*SkypeChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SkypeChannelProperties.

type SlackChannel 

type SlackChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Slack channel resource
	Properties *SlackChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

SlackChannel - Slack channel definition

func (*SlackChannel) GetChannel added in v0.2.0 

func (s *SlackChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type SlackChannel.

func (SlackChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SlackChannel.

func (*SlackChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SlackChannel.

type SlackChannelProperties 

type SlackChannelProperties struct {
	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// The Slack client id
	ClientID *string

	// The Slack client secret. Value only returned through POST to the action Channel List API, otherwise empty.
	ClientSecret *string

	// The Slack landing page Url
	LandingPageURL *string

	// Whether to register the settings before OAuth validation is performed. Recommended to True.
	RegisterBeforeOAuthFlow *bool

	// The Slack permission scopes.
	Scopes *string

	// The Slack signing secret.
	SigningSecret *string

	// The Slack verification token. Value only returned through POST to the action Channel List API, otherwise empty.
	VerificationToken *string

	// READ-ONLY; Whether this channel is validated for the bot
	IsValidated *bool

	// READ-ONLY; The Sms auth token
	LastSubmissionID *string

	// READ-ONLY; The Slack redirect action
	RedirectAction *string
}

SlackChannelProperties - The parameters to provide for the Slack channel.

func (SlackChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type SlackChannelProperties.

func (*SlackChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SlackChannelProperties.

type SmsChannel 

type SmsChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Sms channel resource
	Properties *SmsChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

SmsChannel - Sms channel definition

func (*SmsChannel) GetChannel added in v0.2.0 

func (s *SmsChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type SmsChannel.

func (SmsChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SmsChannel.

func (*SmsChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SmsChannel.

type SmsChannelProperties 

type SmsChannelProperties struct {
	// REQUIRED; The Sms account SID. Value only returned through POST to the action Channel List API, otherwise empty.
	AccountSID *string

	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// REQUIRED; The Sms phone
	Phone *string

	// The Sms auth token. Value only returned through POST to the action Channel List API, otherwise empty.
	AuthToken *string

	// Whether this channel is validated for the bot
	IsValidated *bool
}

SmsChannelProperties - The parameters to provide for the Sms channel.

func (SmsChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type SmsChannelProperties.

func (*SmsChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SmsChannelProperties.

type TelegramChannel 

type TelegramChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Telegram channel resource
	Properties *TelegramChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

TelegramChannel - Telegram channel definition

func (*TelegramChannel) GetChannel added in v0.2.0 

func (t *TelegramChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type TelegramChannel.

func (TelegramChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TelegramChannel.

func (*TelegramChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TelegramChannel.

type TelegramChannelProperties 

type TelegramChannelProperties struct {
	// REQUIRED; Whether this channel is enabled for the bot
	IsEnabled *bool

	// The Telegram access token. Value only returned through POST to the action Channel List API, otherwise empty.
	AccessToken *string

	// Whether this channel is validated for the bot
	IsValidated *bool
}

TelegramChannelProperties - The parameters to provide for the Telegram channel.

func (TelegramChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type TelegramChannelProperties.

func (*TelegramChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TelegramChannelProperties.

type TelephonyChannel added in v1.0.0 

type TelephonyChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Telephony channel resource
	Properties *TelephonyChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

TelephonyChannel - Telephony channel definition

func (*TelephonyChannel) GetChannel added in v1.0.0 

func (t *TelephonyChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type TelephonyChannel.

func (TelephonyChannel) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type TelephonyChannel.

func (*TelephonyChannel) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TelephonyChannel.

type TelephonyChannelProperties added in v1.0.0 

type TelephonyChannelProperties struct {
	// The list of Telephony api configuration
	APIConfigurations []*TelephonyChannelResourceAPIConfiguration

	// The extensionKey2
	CognitiveServiceRegion *string

	// The extensionKey1
	CognitiveServiceSubscriptionKey *string

	// The default locale of the channel
	DefaultLocale *string

	// Whether the channel is enabled
	IsEnabled *bool

	// The list of Telephony phone numbers
	PhoneNumbers []*TelephonyPhoneNumbers

	// The premium SKU applied to the channel
	PremiumSKU *string
}

TelephonyChannelProperties - The parameters to provide for the Direct Line channel.

func (TelephonyChannelProperties) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type TelephonyChannelProperties.

func (*TelephonyChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TelephonyChannelProperties.

type TelephonyChannelResourceAPIConfiguration added in v1.0.0 

type TelephonyChannelResourceAPIConfiguration struct {
	// The cognitive service region.
	CognitiveServiceRegion *string

	// The cognitive service resourceId.
	CognitiveServiceResourceID *string

	// The cognitive service subscription key.
	CognitiveServiceSubscriptionKey *string

	// The default locale.
	DefaultLocale *string

	// The id of config.
	ID *string

	// The provider name.
	ProviderName *string
}

TelephonyChannelResourceAPIConfiguration - A resource Api configuration for the Telephony channel

func (TelephonyChannelResourceAPIConfiguration) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type TelephonyChannelResourceAPIConfiguration.

func (*TelephonyChannelResourceAPIConfiguration) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TelephonyChannelResourceAPIConfiguration.

type TelephonyPhoneNumbers added in v1.0.0 

type TelephonyPhoneNumbers struct {
	// The endpoint of ACS.
	AcsEndpoint *string

	// The resource id of ACS.
	AcsResourceID *string

	// The secret of ACS.
	AcsSecret *string

	// The service region of cognitive service.
	CognitiveServiceRegion *string

	// The resource id of cognitive service.
	CognitiveServiceResourceID *string

	// The subscription key of cognitive service.
	CognitiveServiceSubscriptionKey *string

	// The default locale of the phone number.
	DefaultLocale *string

	// The element id.
	ID *string

	// Optional Property that will determine the offering type of the phone.
	OfferType *string

	// The phone number.
	PhoneNumber *string
}

TelephonyPhoneNumbers - A telephone number for the Telephony channel

func (TelephonyPhoneNumbers) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type TelephonyPhoneNumbers.

func (*TelephonyPhoneNumbers) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TelephonyPhoneNumbers.

type WebChatChannel 

type WebChatChannel struct {
	// REQUIRED; The channel name
	ChannelName *string

	// Entity Tag of the resource
	Etag *string

	// Specifies the location of the resource.
	Location *string

	// The set of properties specific to Web Chat channel resource
	Properties *WebChatChannelProperties

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *string
}

WebChatChannel - Web Chat channel definition

func (*WebChatChannel) GetChannel added in v0.2.0 

func (w *WebChatChannel) GetChannel() *Channel

GetChannel implements the ChannelClassification interface for type WebChatChannel.

func (WebChatChannel) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type WebChatChannel.

func (*WebChatChannel) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type WebChatChannel.

type WebChatChannelProperties 

type WebChatChannelProperties struct {
	// The list of Web Chat sites
	Sites []*WebChatSite

	// READ-ONLY; Web chat control embed code
	WebChatEmbedCode *string
}

WebChatChannelProperties - The parameters to provide for the Web Chat channel.

func (WebChatChannelProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type WebChatChannelProperties.

func (*WebChatChannelProperties) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type WebChatChannelProperties.

type WebChatSite 

type WebChatSite struct {
	// REQUIRED; Whether this site is enabled for DirectLine channel
	IsEnabled *bool

	// REQUIRED; Site name
	SiteName *string

	// DirectLine application id
	AppID *string

	// Entity Tag
	ETag *string

	// Whether this site is enabled for block user upload.
	IsBlockUserUploadEnabled *bool

	// Whether this site is disabled detailed logging for
	IsDetailedLoggingEnabled *bool

	// Whether this site is EndpointParameters enabled for channel
	IsEndpointParametersEnabled *bool

	// Whether this no-storage site is disabled detailed logging for
	IsNoStorageEnabled *bool

	// Whether this site is enabled for authentication with Bot Framework.
	IsSecureSiteEnabled *bool

	// Whether this site is enabled for Bot Framework V1 protocol.
	IsV1Enabled *bool

	// Whether this site is enabled for Bot Framework V3 protocol.
	IsV3Enabled *bool

	// Whether this site is enabled for Webchat Speech
	IsWebChatSpeechEnabled *bool

	// Whether this site is enabled for preview versions of Webchat
	IsWebchatPreviewEnabled *bool

	// Tenant Id
	TenantID *string

	// List of Trusted Origin URLs for this site. This field is applicable only if isSecureSiteEnabled is True.
	TrustedOrigins []*string

	// READ-ONLY; Whether this site is token enabled for channel
	IsTokenEnabled *bool

	// READ-ONLY; Primary key. Value only returned through POST to the action Channel List API, otherwise empty.
	Key *string

	// READ-ONLY; Secondary key. Value only returned through POST to the action Channel List API, otherwise empty.
	Key2 *string

	// READ-ONLY; Site Id
	SiteID *string
}

WebChatSite - A site for the Webchat channel

func (WebChatSite) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type WebChatSite.

func (*WebChatSite) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type WebChatSite.

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.