armengagementfabric

package module
v0.3.0 Latest Latest
Warning

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

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

README

Azure Engagement Fabric Module for Go

PkgGoDev

The armengagementfabric module provides operations for working with Azure Engagement Fabric.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Engagement Fabric module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Engagement Fabric. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Engagement Fabric module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armengagementfabric.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armengagementfabric.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewAccountsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Engagement Fabric label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Account 

type Account struct {
	// REQUIRED; The location of the resource
	Location *string

	// REQUIRED; The SKU of the resource
	SKU *SKU

	// The tags of the resource
	Tags map[string]*string

	// READ-ONLY; The ID of the resource
	ID *string

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

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

Account - The EngagementFabric account

func (Account) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Account.

func (*Account) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Account.

type AccountList 

type AccountList struct {
	// EngagementFabric accounts
	Value []*Account
}

AccountList - The list of the EngagementFabric accounts

func (AccountList) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccountList.

func (*AccountList) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountList.

type AccountPatch 

type AccountPatch struct {
	// The tags of the resource
	Tags map[string]*string
}

AccountPatch - The patch of EngagementFabric account

func (AccountPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountPatch.

func (*AccountPatch) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountPatch.

type AccountsClient 

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

AccountsClient contains the methods for the Accounts group. Don't use this type directly, use NewAccountsClient() instead.

func NewAccountsClient 

func NewAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AccountsClient, error)

NewAccountsClient creates a new instance of AccountsClient with the specified values.

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

func (*AccountsClient) CreateOrUpdate 

func (client *AccountsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, account Account, options *AccountsClientCreateOrUpdateOptions) (AccountsClientCreateOrUpdateResponse, error)

CreateOrUpdate - Create or Update the EngagementFabric account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • account - The EngagementFabric account description
  • options - AccountsClientCreateOrUpdateOptions contains the optional parameters for the AccountsClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsCreateOrUpdateExample.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/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().CreateOrUpdate(ctx, "ExampleRg", "ExampleAccount", armengagementfabric.Account{
		Location: to.Ptr("WestUS"),
		SKU: &armengagementfabric.SKU{
			Name: to.Ptr("B1"),
		},
	}, 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.Account = armengagementfabric.Account{
	// 	Name: to.Ptr("ExampleAccount"),
	// 	Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
	// 	ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount"),
	// 	Location: to.Ptr("WestUS"),
	// 	SKU: &armengagementfabric.SKU{
	// 		Name: to.Ptr("B1"),
	// 		Tier: to.Ptr("Basic"),
	// 	},
	// }
}

Output:

func (*AccountsClient) Delete 

func (client *AccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientDeleteOptions) (AccountsClientDeleteResponse, error)

Delete - Delete the EngagementFabric account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • options - AccountsClientDeleteOptions contains the optional parameters for the AccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsDeleteExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

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

Output:

func (*AccountsClient) Get 

func (client *AccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientGetOptions) (AccountsClientGetResponse, error)

Get - Get the EngagementFabric account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • options - AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsGetExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().Get(ctx, "ExampleRg", "ExampleAccount", 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.Account = armengagementfabric.Account{
	// 	Name: to.Ptr("ExampleAccount"),
	// 	Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
	// 	ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount"),
	// 	Location: to.Ptr("WestUS"),
	// 	SKU: &armengagementfabric.SKU{
	// 		Name: to.Ptr("B1"),
	// 		Tier: to.Ptr("Basic"),
	// 	},
	// }
}

Output:

func (*AccountsClient) ListChannelTypes 

func (client *AccountsClient) ListChannelTypes(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientListChannelTypesOptions) (AccountsClientListChannelTypesResponse, error)

ListChannelTypes - List available EngagementFabric channel types and functions If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • options - AccountsClientListChannelTypesOptions contains the optional parameters for the AccountsClient.ListChannelTypes method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsListChannelTypesExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().ListChannelTypes(ctx, "ExampleRg", "ExampleAccount", 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.ChannelTypeDescriptionList = armengagementfabric.ChannelTypeDescriptionList{
	// 	Value: []*armengagementfabric.ChannelTypeDescription{
	// 		{
	// 			ChannelDescription: to.Ptr("Description of mockChannel1"),
	// 			ChannelFunctions: []*string{
	// 				to.Ptr("MockFunction1"),
	// 				to.Ptr("MockFunction2")},
	// 				ChannelType: to.Ptr("MockChannel1"),
	// 			},
	// 			{
	// 				ChannelDescription: to.Ptr("Description of mockChannel2"),
	// 				ChannelFunctions: []*string{
	// 					to.Ptr("MockFunction1"),
	// 					to.Ptr("MockFunction3")},
	// 					ChannelType: to.Ptr("MockChannel2"),
	// 				},
	// 				{
	// 					ChannelDescription: to.Ptr("Description of mockChannel3"),
	// 					ChannelFunctions: []*string{
	// 						to.Ptr("MockFunction1"),
	// 						to.Ptr("MockFunction2"),
	// 						to.Ptr("MockFunction3")},
	// 						ChannelType: to.Ptr("MockChannel3"),
	// 				}},
	// 			}
}

Output:

func (*AccountsClient) NewListByResourceGroupPager 

func (client *AccountsClient) NewListByResourceGroupPager(resourceGroupName string, options *AccountsClientListByResourceGroupOptions) *runtime.Pager[AccountsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List EngagementFabric accounts in given resource group

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • options - AccountsClientListByResourceGroupOptions contains the optional parameters for the AccountsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsListByResourceGroupExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().NewListByResourceGroupPager("ExampleRg", 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.AccountList = armengagementfabric.AccountList{
		// 	Value: []*armengagementfabric.Account{
		// 		{
		// 			Name: to.Ptr("ExampleAccount"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount"),
		// 			Location: to.Ptr("WestUS"),
		// 			SKU: &armengagementfabric.SKU{
		// 				Name: to.Ptr("B1"),
		// 				Tier: to.Ptr("Basic"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ExampleAccount2"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount2"),
		// 			Location: to.Ptr("WestUS"),
		// 			SKU: &armengagementfabric.SKU{
		// 				Name: to.Ptr("S1"),
		// 				Tier: to.Ptr("Standard"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ExampleAccount3"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount3"),
		// 			Location: to.Ptr("WestUS"),
		// 			SKU: &armengagementfabric.SKU{
		// 				Name: to.Ptr("P1"),
		// 				Tier: to.Ptr("Premium"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AccountsClient) NewListKeysPager 

func (client *AccountsClient) NewListKeysPager(resourceGroupName string, accountName string, options *AccountsClientListKeysOptions) *runtime.Pager[AccountsClientListKeysResponse]

NewListKeysPager - List keys of the EngagementFabric account

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • options - AccountsClientListKeysOptions contains the optional parameters for the AccountsClient.NewListKeysPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsListKeysExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().NewListKeysPager("ExampleRg", "ExampleAccount", 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.KeyDescriptionList = armengagementfabric.KeyDescriptionList{
		// 	Value: []*armengagementfabric.KeyDescription{
		// 		{
		// 			Name: to.Ptr("Full"),
		// 			Rank: to.Ptr(armengagementfabric.KeyRankPrimaryKey),
		// 			Value: to.Ptr("<ExampleFullPrimaryKeyValue>"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Full"),
		// 			Rank: to.Ptr(armengagementfabric.KeyRankSecondaryKey),
		// 			Value: to.Ptr("<ExampleFullSecondaryKeyValue>"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Device"),
		// 			Rank: to.Ptr(armengagementfabric.KeyRankPrimaryKey),
		// 			Value: to.Ptr("<ExampleDevicePrimaryKeyValue>"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Device"),
		// 			Rank: to.Ptr(armengagementfabric.KeyRankSecondaryKey),
		// 			Value: to.Ptr("<ExampleDeviceSecondaryKeyValue>"),
		// 	}},
		// }
	}
}

Output:

func (*AccountsClient) NewListPager 

func (client *AccountsClient) NewListPager(options *AccountsClientListOptions) *runtime.Pager[AccountsClientListResponse]

NewListPager - List the EngagementFabric accounts in given subscription

Generated from API version 2018-09-01-preview

  • options - AccountsClientListOptions contains the optional parameters for the AccountsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsListExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().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.AccountList = armengagementfabric.AccountList{
		// 	Value: []*armengagementfabric.Account{
		// 		{
		// 			Name: to.Ptr("ExampleAccount"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount"),
		// 			Location: to.Ptr("WestUS"),
		// 			SKU: &armengagementfabric.SKU{
		// 				Name: to.Ptr("B1"),
		// 				Tier: to.Ptr("Basic"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ExampleAccount2"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount2"),
		// 			Location: to.Ptr("WestUS"),
		// 			SKU: &armengagementfabric.SKU{
		// 				Name: to.Ptr("S1"),
		// 				Tier: to.Ptr("Standard"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("ExampleAccount3"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount3"),
		// 			Location: to.Ptr("WestUS"),
		// 			SKU: &armengagementfabric.SKU{
		// 				Name: to.Ptr("P1"),
		// 				Tier: to.Ptr("Premium"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AccountsClient) RegenerateKey 

func (client *AccountsClient) RegenerateKey(ctx context.Context, resourceGroupName string, accountName string, parameter RegenerateKeyParameter, options *AccountsClientRegenerateKeyOptions) (AccountsClientRegenerateKeyResponse, error)

RegenerateKey - Regenerate key of the EngagementFabric account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • parameter - Parameters specifying the key to be regenerated
  • options - AccountsClientRegenerateKeyOptions contains the optional parameters for the AccountsClient.RegenerateKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsRegenerateKeyExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().RegenerateKey(ctx, "ExampleRg", "ExampleAccount", armengagementfabric.RegenerateKeyParameter{}, 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.KeyDescription = armengagementfabric.KeyDescription{
	// 	Name: to.Ptr("Full"),
	// 	Rank: to.Ptr(armengagementfabric.KeyRankPrimaryKey),
	// 	Value: to.Ptr("<ExampleFullPrimaryKeyValue>"),
	// }
}

Output:

func (*AccountsClient) Update 

func (client *AccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, accountPatch AccountPatch, options *AccountsClientUpdateOptions) (AccountsClientUpdateResponse, error)

Update - Update EngagementFabric account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • accountPatch - The account patch
  • options - AccountsClientUpdateOptions contains the optional parameters for the AccountsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/AccountsUpdateExample.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/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().Update(ctx, "ExampleRg", "ExampleAccount", armengagementfabric.AccountPatch{
		Tags: map[string]*string{
			"tagName": to.Ptr("tagValue"),
		},
	}, 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.Account = armengagementfabric.Account{
	// 	Name: to.Ptr("ExampleAccount"),
	// 	Type: to.Ptr("Microsoft.EngagementFabric/Accounts"),
	// 	ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount"),
	// 	Location: to.Ptr("WestUS"),
	// 	SKU: &armengagementfabric.SKU{
	// 		Name: to.Ptr("B1"),
	// 		Tier: to.Ptr("Basic"),
	// 	},
	// 	Tags: map[string]*string{
	// 		"tagName": to.Ptr("tagValue"),
	// 	},
	// }
}

Output:

type AccountsClientCreateOrUpdateOptions 

type AccountsClientCreateOrUpdateOptions struct {
}

AccountsClientCreateOrUpdateOptions contains the optional parameters for the AccountsClient.CreateOrUpdate method.

type AccountsClientCreateOrUpdateResponse 

type AccountsClientCreateOrUpdateResponse struct {
	// The EngagementFabric account
	Account
}

AccountsClientCreateOrUpdateResponse contains the response from method AccountsClient.CreateOrUpdate.

type AccountsClientDeleteOptions 

type AccountsClientDeleteOptions struct {
}

AccountsClientDeleteOptions contains the optional parameters for the AccountsClient.Delete method.

type AccountsClientDeleteResponse 

type AccountsClientDeleteResponse struct {
}

AccountsClientDeleteResponse contains the response from method AccountsClient.Delete.

type AccountsClientGetOptions 

type AccountsClientGetOptions struct {
}

AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.

type AccountsClientGetResponse 

type AccountsClientGetResponse struct {
	// The EngagementFabric account
	Account
}

AccountsClientGetResponse contains the response from method AccountsClient.Get.

type AccountsClientListByResourceGroupOptions 

type AccountsClientListByResourceGroupOptions struct {
}

AccountsClientListByResourceGroupOptions contains the optional parameters for the AccountsClient.NewListByResourceGroupPager method.

type AccountsClientListByResourceGroupResponse 

type AccountsClientListByResourceGroupResponse struct {
	// The list of the EngagementFabric accounts
	AccountList
}

AccountsClientListByResourceGroupResponse contains the response from method AccountsClient.NewListByResourceGroupPager.

type AccountsClientListChannelTypesOptions 

type AccountsClientListChannelTypesOptions struct {
}

AccountsClientListChannelTypesOptions contains the optional parameters for the AccountsClient.ListChannelTypes method.

type AccountsClientListChannelTypesResponse 

type AccountsClientListChannelTypesResponse struct {
	// List of the EngagementFabric channel descriptions
	ChannelTypeDescriptionList
}

AccountsClientListChannelTypesResponse contains the response from method AccountsClient.ListChannelTypes.

type AccountsClientListKeysOptions 

type AccountsClientListKeysOptions struct {
}

AccountsClientListKeysOptions contains the optional parameters for the AccountsClient.NewListKeysPager method.

type AccountsClientListKeysResponse 

type AccountsClientListKeysResponse struct {
	// The list of the EngagementFabric account keys
	KeyDescriptionList
}

AccountsClientListKeysResponse contains the response from method AccountsClient.NewListKeysPager.

type AccountsClientListOptions 

type AccountsClientListOptions struct {
}

AccountsClientListOptions contains the optional parameters for the AccountsClient.NewListPager method.

type AccountsClientListResponse 

type AccountsClientListResponse struct {
	// The list of the EngagementFabric accounts
	AccountList
}

AccountsClientListResponse contains the response from method AccountsClient.NewListPager.

type AccountsClientRegenerateKeyOptions 

type AccountsClientRegenerateKeyOptions struct {
}

AccountsClientRegenerateKeyOptions contains the optional parameters for the AccountsClient.RegenerateKey method.

type AccountsClientRegenerateKeyResponse 

type AccountsClientRegenerateKeyResponse struct {
	// The description of the EngagementFabric account key
	KeyDescription
}

AccountsClientRegenerateKeyResponse contains the response from method AccountsClient.RegenerateKey.

type AccountsClientUpdateOptions 

type AccountsClientUpdateOptions struct {
}

AccountsClientUpdateOptions contains the optional parameters for the AccountsClient.Update method.

type AccountsClientUpdateResponse 

type AccountsClientUpdateResponse struct {
	// The EngagementFabric account
	Account
}

AccountsClientUpdateResponse contains the response from method AccountsClient.Update.

type Channel 

type Channel struct {
	// The properties of the channel
	Properties *ChannelProperties

	// READ-ONLY; The ID of the resource
	ID *string

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

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

Channel - The EngagementFabric channel

func (Channel) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type Channel.

func (*Channel) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Channel.

type ChannelList 

type ChannelList struct {
	// EngagementFabric channels
	Value []*Channel
}

ChannelList - The list of the EngagementFabric channels

func (ChannelList) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ChannelList.

func (*ChannelList) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChannelList.

type ChannelProperties 

type ChannelProperties struct {
	// REQUIRED; The channel type
	ChannelType *string

	// The functions to be enabled for the channel
	ChannelFunctions []*string

	// The channel credentials
	Credentials map[string]*string
}

ChannelProperties - The EngagementFabric channel properties

func (ChannelProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ChannelProperties.

func (*ChannelProperties) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChannelProperties.

type ChannelTypeDescription 

type ChannelTypeDescription struct {
	// Text description for the channel
	ChannelDescription *string

	// All the available functions for the channel
	ChannelFunctions []*string

	// Channel type
	ChannelType *string
}

ChannelTypeDescription - EngagementFabric channel description

func (ChannelTypeDescription) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ChannelTypeDescription.

func (*ChannelTypeDescription) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChannelTypeDescription.

type ChannelTypeDescriptionList 

type ChannelTypeDescriptionList struct {
	// Channel descriptions
	Value []*ChannelTypeDescription
}

ChannelTypeDescriptionList - List of the EngagementFabric channel descriptions

func (ChannelTypeDescriptionList) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ChannelTypeDescriptionList.

func (*ChannelTypeDescriptionList) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ChannelTypeDescriptionList.

type ChannelsClient 

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

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

func NewChannelsClient 

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

NewChannelsClient creates a new instance of ChannelsClient with the specified values.

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

func (*ChannelsClient) CreateOrUpdate 

func (client *ChannelsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, channelName string, channel Channel, options *ChannelsClientCreateOrUpdateOptions) (ChannelsClientCreateOrUpdateResponse, error)

CreateOrUpdate - Create or Update the EngagementFabric channel If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • channelName - Channel Name
  • channel - The EngagementFabric channel description
  • options - ChannelsClientCreateOrUpdateOptions contains the optional parameters for the ChannelsClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/ChannelsCreateOrUpdateExample.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/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().CreateOrUpdate(ctx, "ExampleRg", "ExampleAccount", "ExampleChannel", armengagementfabric.Channel{
		Properties: &armengagementfabric.ChannelProperties{
			ChannelFunctions: []*string{
				to.Ptr("MockFunction1"),
				to.Ptr("MockFunction2")},
			ChannelType: to.Ptr("MockChannel"),
			Credentials: map[string]*string{
				"AppId":  to.Ptr("exampleApp"),
				"AppKey": to.Ptr("exampleAppKey"),
			},
		},
	}, 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.Channel = armengagementfabric.Channel{
	// 	Name: to.Ptr("ExampleChannel"),
	// 	Type: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels"),
	// 	ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount/Channels/ExampleChannel"),
	// 	Properties: &armengagementfabric.ChannelProperties{
	// 		ChannelFunctions: []*string{
	// 			to.Ptr("MockFunction1"),
	// 			to.Ptr("MockFunction2")},
	// 			ChannelType: to.Ptr("MockChannel"),
	// 			Credentials: map[string]*string{
	// 				"AppId": to.Ptr("exampleApp"),
	// 				"AppKey": to.Ptr(""),
	// 			},
	// 		},
	// 	}
}

Output:

func (*ChannelsClient) Delete 

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

Delete - Delete the EngagementFabric channel If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • channelName - The EngagementFabric channel name
  • options - ChannelsClientDeleteOptions contains the optional parameters for the ChannelsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/ChannelsDeleteExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

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

Output:

func (*ChannelsClient) Get 

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

Get - Get the EngagementFabric channel If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • channelName - Channel Name
  • options - ChannelsClientGetOptions contains the optional parameters for the ChannelsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/ChannelsGetExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewChannelsClient().Get(ctx, "ExampleRg", "ExampleAccount", "ExampleChannel", 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.Channel = armengagementfabric.Channel{
	// 	Name: to.Ptr("ExampleChannel"),
	// 	Type: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels"),
	// 	ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount/Channels/ExampleChannel"),
	// 	Properties: &armengagementfabric.ChannelProperties{
	// 		ChannelFunctions: []*string{
	// 			to.Ptr("MockFunction1"),
	// 			to.Ptr("MockFunction2")},
	// 			ChannelType: to.Ptr("MockChannel"),
	// 			Credentials: map[string]*string{
	// 				"AppId": to.Ptr("exampleApp"),
	// 				"AppKey": to.Ptr(""),
	// 			},
	// 		},
	// 	}
}

Output:

func (*ChannelsClient) NewListByAccountPager 

func (client *ChannelsClient) NewListByAccountPager(resourceGroupName string, accountName string, options *ChannelsClientListByAccountOptions) *runtime.Pager[ChannelsClientListByAccountResponse]

NewListByAccountPager - List the EngagementFabric channels

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • accountName - Account Name
  • options - ChannelsClientListByAccountOptions contains the optional parameters for the ChannelsClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/ChannelsListExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewChannelsClient().NewListByAccountPager("ExampleRg", "ExampleAccount", 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.ChannelList = armengagementfabric.ChannelList{
		// 	Value: []*armengagementfabric.Channel{
		// 		{
		// 			Name: to.Ptr("ExampleChannel"),
		// 			Type: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels"),
		// 			ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount/Channels/ExampleChannel"),
		// 			Properties: &armengagementfabric.ChannelProperties{
		// 				ChannelFunctions: []*string{
		// 					to.Ptr("MockFunction1"),
		// 					to.Ptr("MockFunction2")},
		// 					ChannelType: to.Ptr("MockChannel"),
		// 					Credentials: map[string]*string{
		// 						"AppId": to.Ptr("exampleApp"),
		// 						"AppKey": to.Ptr(""),
		// 					},
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("ExampleChannel2"),
		// 				Type: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels"),
		// 				ID: to.Ptr("subscriptions/EDBF0095-A524-4A84-95FB-F72DA41AA6A1/resourceGroups/ExampleRg/providers/Microsoft.EngagementFabric/Accounts/ExampleAccount/Channels/ExampleChannel2"),
		// 				Properties: &armengagementfabric.ChannelProperties{
		// 					ChannelFunctions: []*string{
		// 						to.Ptr("MockFunction1"),
		// 						to.Ptr("MockFunction3")},
		// 						ChannelType: to.Ptr("MockChannel2"),
		// 						Credentials: map[string]*string{
		// 							"AppId": to.Ptr("exampleApp2"),
		// 							"AppKey": to.Ptr(""),
		// 						},
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type ChannelsClientCreateOrUpdateOptions 

type ChannelsClientCreateOrUpdateOptions struct {
}

ChannelsClientCreateOrUpdateOptions contains the optional parameters for the ChannelsClient.CreateOrUpdate method.

type ChannelsClientCreateOrUpdateResponse 

type ChannelsClientCreateOrUpdateResponse struct {
	// The EngagementFabric channel
	Channel
}

ChannelsClientCreateOrUpdateResponse contains the response from method ChannelsClient.CreateOrUpdate.

type ChannelsClientDeleteOptions 

type ChannelsClientDeleteOptions struct {
}

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

type ChannelsClientDeleteResponse 

type ChannelsClientDeleteResponse struct {
}

ChannelsClientDeleteResponse contains the response from method ChannelsClient.Delete.

type ChannelsClientGetOptions 

type ChannelsClientGetOptions struct {
}

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

type ChannelsClientGetResponse 

type ChannelsClientGetResponse struct {
	// The EngagementFabric channel
	Channel
}

ChannelsClientGetResponse contains the response from method ChannelsClient.Get.

type ChannelsClientListByAccountOptions 

type ChannelsClientListByAccountOptions struct {
}

ChannelsClientListByAccountOptions contains the optional parameters for the ChannelsClient.NewListByAccountPager method.

type ChannelsClientListByAccountResponse 

type ChannelsClientListByAccountResponse struct {
	// The list of the EngagementFabric channels
	ChannelList
}

ChannelsClientListByAccountResponse contains the response from method ChannelsClient.NewListByAccountPager.

type CheckNameAvailabilityParameter 

type CheckNameAvailabilityParameter struct {
	// REQUIRED; The name to be checked
	Name *string

	// REQUIRED; The fully qualified resource type for the name to be checked
	Type *string
}

CheckNameAvailabilityParameter - The parameter for name availability check

func (CheckNameAvailabilityParameter) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityParameter.

func (*CheckNameAvailabilityParameter) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityParameter.

type CheckNameAvailabilityResult 

type CheckNameAvailabilityResult struct {
	// READ-ONLY; The message if name is unavailable
	Message *string

	// READ-ONLY; The name to be checked
	NameAvailable *bool

	// READ-ONLY; The reason if name is unavailable
	Reason *CheckNameUnavailableReason
}

CheckNameAvailabilityResult - The result of name availability check

func (CheckNameAvailabilityResult) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResult.

func (*CheckNameAvailabilityResult) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityResult.

type CheckNameUnavailableReason 

type CheckNameUnavailableReason string

CheckNameUnavailableReason - The reason of name availability result 

const (
	CheckNameUnavailableReasonAlreadyExists CheckNameUnavailableReason = "AlreadyExists"
	CheckNameUnavailableReasonInvalid       CheckNameUnavailableReason = "Invalid"
)

func PossibleCheckNameUnavailableReasonValues 

func PossibleCheckNameUnavailableReasonValues() []CheckNameUnavailableReason

PossibleCheckNameUnavailableReasonValues returns the possible values for the CheckNameUnavailableReason const type.

type Client 

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

Client contains the methods for the EngagementFabric group. Don't use this type directly, use NewClient() instead.

func NewClient 

func NewClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*Client, error)

NewClient creates a new instance of Client with the specified values.

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

func (*Client) CheckNameAvailability 

func (client *Client) CheckNameAvailability(ctx context.Context, resourceGroupName string, parameters CheckNameAvailabilityParameter, options *ClientCheckNameAvailabilityOptions) (ClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check availability of EngagementFabric resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2018-09-01-preview

  • resourceGroupName - Resource Group Name
  • parameters - Parameter describing the name to be checked
  • options - ClientCheckNameAvailabilityOptions contains the optional parameters for the Client.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/CheckNameAvailabilityExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().CheckNameAvailability(ctx, "<resource-group-name>", armengagementfabric.CheckNameAvailabilityParameter{}, 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.CheckNameAvailabilityResult = armengagementfabric.CheckNameAvailabilityResult{
	// 	Message: to.Ptr("Account 'ExampleAccount' already exists"),
	// 	NameAvailable: to.Ptr(false),
	// 	Reason: to.Ptr(armengagementfabric.CheckNameUnavailableReasonAlreadyExists),
	// }
}

Output:

type ClientCheckNameAvailabilityOptions 

type ClientCheckNameAvailabilityOptions struct {
}

ClientCheckNameAvailabilityOptions contains the optional parameters for the Client.CheckNameAvailability method.

type ClientCheckNameAvailabilityResponse 

type ClientCheckNameAvailabilityResponse struct {
	// The result of name availability check
	CheckNameAvailabilityResult
}

ClientCheckNameAvailabilityResponse contains the response from method Client.CheckNameAvailability.

type ClientFactory added in v0.2.0 

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

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

func NewClientFactory added in v0.2.0 

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

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

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

func (*ClientFactory) NewAccountsClient added in v0.2.0 

func (c *ClientFactory) NewAccountsClient() *AccountsClient

NewAccountsClient creates a new instance of AccountsClient.

func (*ClientFactory) NewChannelsClient added in v0.2.0 

func (c *ClientFactory) NewChannelsClient() *ChannelsClient

NewChannelsClient creates a new instance of ChannelsClient.

func (*ClientFactory) NewClient added in v0.2.0 

func (c *ClientFactory) NewClient() *Client

NewClient creates a new instance of Client.

func (*ClientFactory) NewOperationsClient added in v0.2.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewSKUsClient added in v0.2.0 

func (c *ClientFactory) NewSKUsClient() *SKUsClient

NewSKUsClient creates a new instance of SKUsClient.

type KeyDescription 

type KeyDescription struct {
	// READ-ONLY; The name of the key
	Name *string

	// READ-ONLY; The rank of the key
	Rank *KeyRank

	// READ-ONLY; The value of the key
	Value *string
}

KeyDescription - The description of the EngagementFabric account key

func (KeyDescription) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type KeyDescription.

func (*KeyDescription) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type KeyDescription.

type KeyDescriptionList 

type KeyDescriptionList struct {
	// READ-ONLY; Account keys
	Value []*KeyDescription
}

KeyDescriptionList - The list of the EngagementFabric account keys

func (KeyDescriptionList) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type KeyDescriptionList.

func (*KeyDescriptionList) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type KeyDescriptionList.

type KeyRank 

type KeyRank string

KeyRank - The rank of the EngagementFabric account key 

const (
	KeyRankPrimaryKey   KeyRank = "PrimaryKey"
	KeyRankSecondaryKey KeyRank = "SecondaryKey"
)

func PossibleKeyRankValues 

func PossibleKeyRankValues() []KeyRank

PossibleKeyRankValues returns the possible values for the KeyRank const type.

type Operation 

type Operation struct {
	// READ-ONLY; The display content of the EngagementFabric operation
	Display *OperationDisplay

	// READ-ONLY; The name of the EngagementFabric operation
	Name *string
}

Operation - The EngagementFabric operation

func (Operation) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The description of the EngagementFabric operation
	Description *string

	// READ-ONLY; The name of the EngagementFabric operation
	Operation *string

	// READ-ONLY; The resource provider namespace of the EngagementFabric operation
	Provider *string

	// READ-ONLY; The resource type of the EngagementFabric operation
	Resource *string
}

OperationDisplay - The display information of the EngagementFabric operation

func (OperationDisplay) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationList 

type OperationList struct {
	// READ-ONLY; The EngagementFabric operations
	Value []*Operation
}

OperationList - The list of the EngagementFabric operations

func (OperationList) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationList.

func (*OperationList) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationList.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager 

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

NewListPager - List operation of EngagementFabric resources

Generated from API version 2018-09-01-preview

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/OperationsListExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.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.OperationList = armengagementfabric.OperationList{
		// 	Value: []*armengagementfabric.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/read"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("List or get the EngagementFabric account"),
		// 				Operation: to.Ptr("List or get the EngagementFabric account"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/write"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Create or update the EngagementFabric account"),
		// 				Operation: to.Ptr("Create or update the EngagementFabric account"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/delete"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Delete the EngagementFabric account"),
		// 				Operation: to.Ptr("Delete the EngagementFabric account"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/ListKeys/action"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Get all keys of the EngagementFabric account"),
		// 				Operation: to.Ptr("Get all keys of the EngagementFabric account"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/RegenerateKey/action"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Regenerate the EngagementFabric account key"),
		// 				Operation: to.Ptr("Regenerate the EngagementFabric account key"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/ListChannelTypes/action"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("List available EngagementFabric channel types and functions"),
		// 				Operation: to.Ptr("List available EngagementFabric channel types and functions"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels/read"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("List or get the EngagementFabric channel"),
		// 				Operation: to.Ptr("List or get the EngagementFabric channel"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Channels"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels/write"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Create or update the EngagementFabric channel"),
		// 				Operation: to.Ptr("Create or update the EngagementFabric channel"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Channels"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/Accounts/Channels/delete"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Delete the EngagementFabric channel"),
		// 				Operation: to.Ptr("Delete the EngagementFabric channel"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Channels"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/checkNameAvailability/action"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("Check name availability"),
		// 				Operation: to.Ptr("Check name availability"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/operations/read"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("List available operations"),
		// 				Operation: to.Ptr("List available operations"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Operations"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.EngagementFabric/skus/read"),
		// 			Display: &armengagementfabric.OperationDisplay{
		// 				Description: to.Ptr("List available SKUs"),
		// 				Operation: to.Ptr("List available SKUs"),
		// 				Provider: to.Ptr("Microsoft Customer Engagement Fabric"),
		// 				Resource: to.Ptr("Accounts"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// The list of the EngagementFabric operations
	OperationList
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type ProxyOnlyResource 

type ProxyOnlyResource struct {
	// READ-ONLY; The ID of the resource
	ID *string

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

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

ProxyOnlyResource - The base model for the proxy-only Azure resource

func (ProxyOnlyResource) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ProxyOnlyResource.

func (*ProxyOnlyResource) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProxyOnlyResource.

type RegenerateKeyParameter 

type RegenerateKeyParameter struct {
	// REQUIRED; The name of key to be regenerated
	Name *string

	// REQUIRED; The rank of the key to be regenerated
	Rank *KeyRank
}

RegenerateKeyParameter - The parameter to regenerate single EngagementFabric account key

func (RegenerateKeyParameter) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type RegenerateKeyParameter.

func (*RegenerateKeyParameter) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RegenerateKeyParameter.

type Resource 

type Resource struct {
	// READ-ONLY; The ID of the resource
	ID *string

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

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

Resource - The base model for Azure resource

func (Resource) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SKU 

type SKU struct {
	// REQUIRED; The name of the SKU
	Name *string

	// The price tier of the SKU
	Tier *string
}

SKU - The EngagementFabric SKU

func (SKU) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SKUDescription 

type SKUDescription struct {
	// READ-ONLY; Locations and zones
	LocationInfo []*SKULocationInfoItem

	// READ-ONLY; The set of locations that the SKU is available
	Locations []*string

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

	// READ-ONLY; The fully qualified resource type
	ResourceType *string

	// READ-ONLY; The restrictions because of which SKU cannot be used
	Restrictions []any

	// READ-ONLY; The price tier of the SKU
	Tier *string
}

SKUDescription - The EngagementFabric SKU description of given resource type

func (SKUDescription) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SKUDescription.

func (*SKUDescription) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKUDescription.

type SKUDescriptionList 

type SKUDescriptionList struct {
	// READ-ONLY; SKU descriptions
	Value []*SKUDescription
}

SKUDescriptionList - The list of the EngagementFabric SKU descriptions

func (SKUDescriptionList) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SKUDescriptionList.

func (*SKUDescriptionList) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKUDescriptionList.

type SKULocationInfoItem 

type SKULocationInfoItem struct {
	// The available location of the SKU
	Location *string

	// The available zone of the SKU
	Zones []*string
}

SKULocationInfoItem - The Locations and zones info for SKU

func (SKULocationInfoItem) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type SKULocationInfoItem.

func (*SKULocationInfoItem) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKULocationInfoItem.

type SKUsClient 

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

SKUsClient contains the methods for the SKUs group. Don't use this type directly, use NewSKUsClient() instead.

func NewSKUsClient 

func NewSKUsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SKUsClient, error)

NewSKUsClient creates a new instance of SKUsClient with the specified values.

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

func (*SKUsClient) NewListPager 

func (client *SKUsClient) NewListPager(options *SKUsClientListOptions) *runtime.Pager[SKUsClientListResponse]

NewListPager - List available SKUs of EngagementFabric resource

Generated from API version 2018-09-01-preview

  • options - SKUsClientListOptions contains the optional parameters for the SKUsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/163e27c0ca7570bc39e00a46f255740d9b3ba3cb/specification/engagementfabric/resource-manager/Microsoft.EngagementFabric/preview/2018-09-01/examples/SKUsListExample.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/engagementfabric/armengagementfabric"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armengagementfabric.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSKUsClient().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.SKUDescriptionList = armengagementfabric.SKUDescriptionList{
		// 	Value: []*armengagementfabric.SKUDescription{
		// 		{
		// 			Name: to.Ptr("B1"),
		// 			LocationInfo: []*armengagementfabric.SKULocationInfoItem{
		// 				{
		// 					Location: to.Ptr("Central US"),
		// 				},
		// 				{
		// 					Location: to.Ptr("North Europe"),
		// 				},
		// 				{
		// 					Location: to.Ptr("West Europe"),
		// 			}},
		// 			Locations: []*string{
		// 				to.Ptr("Central US"),
		// 				to.Ptr("North Europe"),
		// 				to.Ptr("West Europe")},
		// 				ResourceType: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 				Restrictions: []any{
		// 				},
		// 				Tier: to.Ptr("Basic"),
		// 			},
		// 			{
		// 				Name: to.Ptr("S1"),
		// 				LocationInfo: []*armengagementfabric.SKULocationInfoItem{
		// 					{
		// 						Location: to.Ptr("Central US"),
		// 					},
		// 					{
		// 						Location: to.Ptr("North Europe"),
		// 					},
		// 					{
		// 						Location: to.Ptr("West Europe"),
		// 				}},
		// 				Locations: []*string{
		// 					to.Ptr("Central US"),
		// 					to.Ptr("North Europe"),
		// 					to.Ptr("West Europe")},
		// 					ResourceType: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 					Restrictions: []any{
		// 					},
		// 					Tier: to.Ptr("Standard"),
		// 				},
		// 				{
		// 					Name: to.Ptr("P1"),
		// 					LocationInfo: []*armengagementfabric.SKULocationInfoItem{
		// 						{
		// 							Location: to.Ptr("Central US"),
		// 						},
		// 						{
		// 							Location: to.Ptr("North Europe"),
		// 						},
		// 						{
		// 							Location: to.Ptr("West Europe"),
		// 					}},
		// 					Locations: []*string{
		// 						to.Ptr("Central US"),
		// 						to.Ptr("North Europe"),
		// 						to.Ptr("West Europe")},
		// 						ResourceType: to.Ptr("Microsoft.EngagementFabric/Accounts"),
		// 						Restrictions: []any{
		// 						},
		// 						Tier: to.Ptr("Premium"),
		// 				}},
		// 			}
	}
}

Output:

type SKUsClientListOptions 

type SKUsClientListOptions struct {
}

SKUsClientListOptions contains the optional parameters for the SKUsClient.NewListPager method.

type SKUsClientListResponse 

type SKUsClientListResponse struct {
	// The list of the EngagementFabric SKU descriptions
	SKUDescriptionList
}

SKUsClientListResponse contains the response from method SKUsClient.NewListPager.

type TrackedResource 

type TrackedResource struct {
	// REQUIRED; The location of the resource
	Location *string

	// REQUIRED; The SKU of the resource
	SKU *SKU

	// The tags of the resource
	Tags map[string]*string

	// READ-ONLY; The ID of the resource
	ID *string

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

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

TrackedResource - The base model for the tracked Azure resource

func (TrackedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.