armbotservice

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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: