armiotcentral

package module
v1.2.0 Latest Latest
Warning

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

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

README

Azure IoT Central Module for Go

PkgGoDev

The armiotcentral module provides operations for working with Azure IoT Central.

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 IoT Central module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral

Authorization

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

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 IoT Central 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 App 

type App struct {
	// REQUIRED; The resource location.
	Location *string

	// REQUIRED; A valid instance SKU.
	SKU *AppSKUInfo

	// The managed identities for the IoT Central application.
	Identity *SystemAssignedServiceIdentity

	// The common properties of an IoT Central application.
	Properties *AppProperties

	// The resource tags.
	Tags map[string]*string

	// READ-ONLY; The ARM resource identifier.
	ID *string

	// READ-ONLY; The ARM resource name.
	Name *string

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

App - The IoT Central application.

func (App) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type App.

func (*App) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type App.

type AppAvailabilityInfo 

type AppAvailabilityInfo struct {
	// READ-ONLY; The detailed reason message.
	Message *string

	// READ-ONLY; The value which indicates whether the provided name is available.
	NameAvailable *bool

	// READ-ONLY; The reason for unavailability.
	Reason *string
}

AppAvailabilityInfo - The properties indicating whether a given IoT Central application name or subdomain is available.

func (AppAvailabilityInfo) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type AppAvailabilityInfo.

func (*AppAvailabilityInfo) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppAvailabilityInfo.

type AppListResult 

type AppListResult struct {
	// The link used to get the next page of IoT Central Applications.
	NextLink *string

	// A list of IoT Central Applications.
	Value []*App
}

AppListResult - A list of IoT Central Applications with a next link.

func (AppListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppListResult.

func (*AppListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppListResult.

type AppPatch 

type AppPatch struct {
	// The managed identities for the IoT Central application.
	Identity *SystemAssignedServiceIdentity

	// The common properties of an IoT Central application.
	Properties *AppProperties

	// A valid instance SKU.
	SKU *AppSKUInfo

	// Instance tags
	Tags map[string]*string
}

AppPatch - The description of the IoT Central application.

func (AppPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppPatch.

func (*AppPatch) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppPatch.

type AppProperties 

type AppProperties struct {
	// The display name of the application.
	DisplayName *string

	// The subdomain of the application.
	Subdomain *string

	// The ID of the application template, which is a blueprint that defines the characteristics and behaviors of an application.
	// Optional; if not specified, defaults to a blank blueprint and allows the
	// application to be defined from scratch.
	Template *string

	// READ-ONLY; The ID of the application.
	ApplicationID *string

	// READ-ONLY; The current state of the application.
	State *AppState
}

AppProperties - The properties of an IoT Central application.

func (AppProperties) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AppProperties.

func (*AppProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppProperties.

type AppSKU 

type AppSKU string

AppSKU - The name of the SKU. 

const (
	AppSKUST0 AppSKU = "ST0"
	AppSKUST1 AppSKU = "ST1"
	AppSKUST2 AppSKU = "ST2"
)

func PossibleAppSKUValues 

func PossibleAppSKUValues() []AppSKU

PossibleAppSKUValues returns the possible values for the AppSKU const type.

type AppSKUInfo 

type AppSKUInfo struct {
	// REQUIRED; The name of the SKU.
	Name *AppSKU
}

AppSKUInfo - Information about the SKU of the IoT Central application.

func (AppSKUInfo) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type AppSKUInfo.

func (*AppSKUInfo) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppSKUInfo.

type AppState 

type AppState string

AppState - The current state of the application. 

const (
	AppStateCreated   AppState = "created"
	AppStateSuspended AppState = "suspended"
)

func PossibleAppStateValues 

func PossibleAppStateValues() []AppState

PossibleAppStateValues returns the possible values for the AppState const type.

type AppTemplate 

type AppTemplate struct {
	// READ-ONLY; The description of the template.
	Description *string

	// READ-ONLY; The industry of the template.
	Industry *string

	// READ-ONLY; A list of locations that support the template.
	Locations []*AppTemplateLocations

	// READ-ONLY; The ID of the template.
	ManifestID *string

	// READ-ONLY; The version of the template.
	ManifestVersion *string

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

	// READ-ONLY; The order of the template in the templates list.
	Order *float32

	// READ-ONLY; The title of the template.
	Title *string
}

AppTemplate - IoT Central Application Template.

func (AppTemplate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppTemplate.

func (*AppTemplate) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppTemplate.

type AppTemplateLocations 

type AppTemplateLocations struct {
	// READ-ONLY; The display name of the location.
	DisplayName *string

	// READ-ONLY; The ID of the location.
	ID *string
}

AppTemplateLocations - IoT Central Application Template Locations.

func (AppTemplateLocations) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type AppTemplateLocations.

func (*AppTemplateLocations) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppTemplateLocations.

type AppTemplatesResult 

type AppTemplatesResult struct {
	// The link used to get the next page of IoT Central application templates.
	NextLink *string

	// READ-ONLY; A list of IoT Central Application Templates.
	Value []*AppTemplate
}

AppTemplatesResult - A list of IoT Central Application Templates with a next link.

func (AppTemplatesResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppTemplatesResult.

func (*AppTemplatesResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AppTemplatesResult.

type AppsClient 

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

AppsClient contains the methods for the Apps group. Don't use this type directly, use NewAppsClient() instead.

func NewAppsClient 

func NewAppsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AppsClient, error)

NewAppsClient creates a new instance of AppsClient with the specified values.

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

func (*AppsClient) BeginCreateOrUpdate 

func (client *AppsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, app App, options *AppsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AppsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update the metadata of an IoT Central application. The usual pattern to modify a property is to retrieve the IoT Central application metadata and security metadata, and then combine them with the modified values in a new body to update the IoT Central application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-01

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • app - The IoT Central application metadata and security metadata.
  • options - AppsClientBeginCreateOrUpdateOptions contains the optional parameters for the AppsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_CreateOrUpdate.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/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAppsClient().BeginCreateOrUpdate(ctx, "resRg", "myIoTCentralApp", armiotcentral.App{
		Location: to.Ptr("westus"),
		Identity: &armiotcentral.SystemAssignedServiceIdentity{
			Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
		},
		Properties: &armiotcentral.AppProperties{
			DisplayName: to.Ptr("My IoT Central App"),
			Subdomain:   to.Ptr("my-iot-central-app"),
			Template:    to.Ptr("iotc-pnp-preview@1.0.0"),
		},
		SKU: &armiotcentral.AppSKUInfo{
			Name: to.Ptr(armiotcentral.AppSKUST2),
		},
	}, 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.App = armiotcentral.App{
	// 	Name: to.Ptr("myIoTCentralApp"),
	// 	Type: to.Ptr("Microsoft.IoTCentral/IoTApps"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/IoTApps/myIoTCentralApp"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armiotcentral.SystemAssignedServiceIdentity{
	// 		Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("8988ab15-3e7a-4586-8a1c-ed07a73a53e9"),
	// 		TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
	// 	},
	// 	Properties: &armiotcentral.AppProperties{
	// 		ApplicationID: to.Ptr("6ebd8fd3-6e34-419e-908f-9be61ec6f6d6"),
	// 		DisplayName: to.Ptr("My IoT Central App 2"),
	// 		State: to.Ptr(armiotcentral.AppStateCreated),
	// 		Subdomain: to.Ptr("my-iot-central-app-2"),
	// 		Template: to.Ptr("iotc-pnp-preview@1.0.0"),
	// 	},
	// 	SKU: &armiotcentral.AppSKUInfo{
	// 		Name: to.Ptr(armiotcentral.AppSKUST2),
	// 	},
	// }
}

Output:

func (*AppsClient) BeginDelete 

func (client *AppsClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, options *AppsClientBeginDeleteOptions) (*runtime.Poller[AppsClientDeleteResponse], error)

BeginDelete - Delete an IoT Central application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-01

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • options - AppsClientBeginDeleteOptions contains the optional parameters for the AppsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAppsClient().BeginDelete(ctx, "resRg", "myIoTCentralApp", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*AppsClient) BeginUpdate 

func (client *AppsClient) BeginUpdate(ctx context.Context, resourceGroupName string, resourceName string, appPatch AppPatch, options *AppsClientBeginUpdateOptions) (*runtime.Poller[AppsClientUpdateResponse], error)

BeginUpdate - Update the metadata of an IoT Central application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-01

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • appPatch - The IoT Central application metadata and security metadata.
  • options - AppsClientBeginUpdateOptions contains the optional parameters for the AppsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_Update.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/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAppsClient().BeginUpdate(ctx, "resRg", "myIoTCentralApp", armiotcentral.AppPatch{
		Identity: &armiotcentral.SystemAssignedServiceIdentity{
			Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
		},
		Properties: &armiotcentral.AppProperties{
			DisplayName: to.Ptr("My IoT Central App 2"),
		},
	}, 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.App = armiotcentral.App{
	// 	Name: to.Ptr("myIoTCentralApp"),
	// 	Type: to.Ptr("Microsoft.IoTCentral/IoTApps"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/IoTApps/myIoTCentralApp"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armiotcentral.SystemAssignedServiceIdentity{
	// 		Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("8988ab15-3e7a-4586-8a1c-ed07a73a53e9"),
	// 		TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
	// 	},
	// 	Properties: &armiotcentral.AppProperties{
	// 		ApplicationID: to.Ptr("6ebd8fd3-6e34-419e-908f-9be61ec6f6d6"),
	// 		DisplayName: to.Ptr("My IoT Central App 2"),
	// 		State: to.Ptr(armiotcentral.AppStateCreated),
	// 		Subdomain: to.Ptr("my-iot-central-app-2"),
	// 		Template: to.Ptr("iotc-pnp-preview@1.0.0"),
	// 	},
	// 	SKU: &armiotcentral.AppSKUInfo{
	// 		Name: to.Ptr(armiotcentral.AppSKUST2),
	// 	},
	// }
}

Output:

func (*AppsClient) CheckNameAvailability 

func (client *AppsClient) CheckNameAvailability(ctx context.Context, operationInputs OperationInputs, options *AppsClientCheckNameAvailabilityOptions) (AppsClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check if an IoT Central application name is available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-01

  • operationInputs - Set the name parameter in the OperationInputs structure to the name of the IoT Central application to check.
  • options - AppsClientCheckNameAvailabilityOptions contains the optional parameters for the AppsClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_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/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppsClient().CheckNameAvailability(ctx, armiotcentral.OperationInputs{
		Name: to.Ptr("myiotcentralapp"),
		Type: to.Ptr("IoTApps"),
	}, 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.AppAvailabilityInfo = armiotcentral.AppAvailabilityInfo{
	// 	NameAvailable: to.Ptr(true),
	// }
}

Output:

func (*AppsClient) CheckSubdomainAvailability 

func (client *AppsClient) CheckSubdomainAvailability(ctx context.Context, operationInputs OperationInputs, options *AppsClientCheckSubdomainAvailabilityOptions) (AppsClientCheckSubdomainAvailabilityResponse, error)

CheckSubdomainAvailability - Check if an IoT Central application subdomain is available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-01

  • operationInputs - Set the name parameter in the OperationInputs structure to the subdomain of the IoT Central application to check.
  • options - AppsClientCheckSubdomainAvailabilityOptions contains the optional parameters for the AppsClient.CheckSubdomainAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_CheckSubdomainAvailability.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/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppsClient().CheckSubdomainAvailability(ctx, armiotcentral.OperationInputs{
		Name: to.Ptr("myiotcentralapp"),
		Type: to.Ptr("IoTApps"),
	}, 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.AppAvailabilityInfo = armiotcentral.AppAvailabilityInfo{
	// 	NameAvailable: to.Ptr(true),
	// }
}

Output:

func (*AppsClient) Get 

func (client *AppsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *AppsClientGetOptions) (AppsClientGetResponse, error)

Get - Get the metadata of an IoT Central application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-06-01

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • options - AppsClientGetOptions contains the optional parameters for the AppsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAppsClient().Get(ctx, "resRg", "myIoTCentralApp", 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.App = armiotcentral.App{
	// 	Name: to.Ptr("myIoTCentralApp"),
	// 	Type: to.Ptr("Microsoft.IoTCentral/IoTApps"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armiotcentral.SystemAssignedServiceIdentity{
	// 		Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("8988ab15-3e7a-4586-8a1c-ed07a73a53e9"),
	// 		TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
	// 	},
	// 	Properties: &armiotcentral.AppProperties{
	// 		ApplicationID: to.Ptr("6ebd8fd3-6e34-419e-908f-9be61ec6f6d6"),
	// 		DisplayName: to.Ptr("My IoT Central App"),
	// 		State: to.Ptr(armiotcentral.AppStateCreated),
	// 		Subdomain: to.Ptr("my-iot-central-app"),
	// 		Template: to.Ptr("iotc-pnp-preview@1.0.0"),
	// 	},
	// 	SKU: &armiotcentral.AppSKUInfo{
	// 		Name: to.Ptr(armiotcentral.AppSKU("F1")),
	// 	},
	// }
}

Output:

func (*AppsClient) NewListByResourceGroupPager added in v0.4.0 

func (client *AppsClient) NewListByResourceGroupPager(resourceGroupName string, options *AppsClientListByResourceGroupOptions) *runtime.Pager[AppsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Get all the IoT Central Applications in a resource group.

Generated from API version 2021-06-01

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • options - AppsClientListByResourceGroupOptions contains the optional parameters for the AppsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_ListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAppsClient().NewListByResourceGroupPager("resRg", 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.AppListResult = armiotcentral.AppListResult{
		// 	Value: []*armiotcentral.App{
		// 		{
		// 			Name: to.Ptr("myIoTCentralApp"),
		// 			Type: to.Ptr("Microsoft.IoTCentral/IoTApps"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp"),
		// 			Location: to.Ptr("westus"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Identity: &armiotcentral.SystemAssignedServiceIdentity{
		// 				Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
		// 				PrincipalID: to.Ptr("8988ab15-3e7a-4586-8a1c-ed07a73a53e9"),
		// 				TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
		// 			},
		// 			Properties: &armiotcentral.AppProperties{
		// 				ApplicationID: to.Ptr("6ebd8fd3-6e34-419e-908f-9be61ec6f6d6"),
		// 				DisplayName: to.Ptr("My IoT Central App"),
		// 				State: to.Ptr(armiotcentral.AppStateCreated),
		// 				Subdomain: to.Ptr("my-iot-central-app"),
		// 				Template: to.Ptr("iotc-pnp-preview@1.0.0"),
		// 			},
		// 			SKU: &armiotcentral.AppSKUInfo{
		// 				Name: to.Ptr(armiotcentral.AppSKU("F1")),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AppsClient) NewListBySubscriptionPager added in v0.4.0 

func (client *AppsClient) NewListBySubscriptionPager(options *AppsClientListBySubscriptionOptions) *runtime.Pager[AppsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Get all IoT Central Applications in a subscription.

Generated from API version 2021-06-01

  • options - AppsClientListBySubscriptionOptions contains the optional parameters for the AppsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_ListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAppsClient().NewListBySubscriptionPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AppListResult = armiotcentral.AppListResult{
		// 	Value: []*armiotcentral.App{
		// 		{
		// 			Name: to.Ptr("myIoTCentralApp"),
		// 			Type: to.Ptr("Microsoft.IoTCentral/IoTApps"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp"),
		// 			Location: to.Ptr("westus"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Identity: &armiotcentral.SystemAssignedServiceIdentity{
		// 				Type: to.Ptr(armiotcentral.SystemAssignedServiceIdentityTypeSystemAssigned),
		// 				PrincipalID: to.Ptr("8988ab15-3e7a-4586-8a1c-ed07a73a53e9"),
		// 				TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
		// 			},
		// 			Properties: &armiotcentral.AppProperties{
		// 				ApplicationID: to.Ptr("6ebd8fd3-6e34-419e-908f-9be61ec6f6d6"),
		// 				DisplayName: to.Ptr("My IoT Central App"),
		// 				State: to.Ptr(armiotcentral.AppStateCreated),
		// 				Subdomain: to.Ptr("my-iot-central-app"),
		// 				Template: to.Ptr("iotc-pnp-preview@1.0.0"),
		// 			},
		// 			SKU: &armiotcentral.AppSKUInfo{
		// 				Name: to.Ptr(armiotcentral.AppSKU("F1")),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AppsClient) NewListTemplatesPager added in v0.4.0 

func (client *AppsClient) NewListTemplatesPager(options *AppsClientListTemplatesOptions) *runtime.Pager[AppsClientListTemplatesResponse]

NewListTemplatesPager - Get all available application templates.

Generated from API version 2021-06-01

  • options - AppsClientListTemplatesOptions contains the optional parameters for the AppsClient.NewListTemplatesPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Apps_Templates.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAppsClient().NewListTemplatesPager(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.AppTemplatesResult = armiotcentral.AppTemplatesResult{
		// 	Value: []*armiotcentral.AppTemplate{
		// 		{
		// 			Name: to.Ptr("Store Analytics – Condition Monitoring"),
		// 			Description: to.Ptr("Digitally connect and monitor your store environment to reduce operating costs and create experiences that customers love."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-condition"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("In-store Analytics – Condition Monitoring"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Water Consumption application template"),
		// 			Description: to.Ptr("Enable remote tracking of water consumption to reduce field operations, detect leaks in time, while empowering cities to conserve water."),
		// 			Industry: to.Ptr("Government"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-consumption"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Water Consumption Monitoring"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Digital Distribution Center application template"),
		// 			Description: to.Ptr("Digitally manage warehouse conveyor belt system efficiency using object detection and tracking."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-distribution"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Digital Distribution Center"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Smart Inventory Management application template"),
		// 			Description: to.Ptr("Enable accurate inventory tracking and ensure shelves are always stocked."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-inventory"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Smart Inventory Management"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Connected Logistics application template"),
		// 			Description: to.Ptr("Track your shipment in real-time across air, water and land with location and condition monitoring."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-logistics"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Connected Logistics"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Smart Meter Analytics application template"),
		// 			Description: to.Ptr("Connect utility meters to gain insights into billing, forecast consumption, and proactively detect outages."),
		// 			Industry: to.Ptr("Energy"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-meter"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Smart Meter Analytics"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Micro-fulfillment Center"),
		// 			Description: to.Ptr("Digitally connect, monitor and manage all aspects of a fully automated fulfillment center to reduce costs by eliminating downtime while increasing security and overall efficiency."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-mfc"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Micro-fulfillment Center"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Phone-as-a-device application template"),
		// 			Description: to.Ptr("Create application with [\"paad\"] capabilities."),
		// 			Industry: to.Ptr("Utility"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-paad"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Paad"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Continuous Patient Monitoring application template"),
		// 			Description: to.Ptr("Connect and manage devices for in-patient and remote monitoring to improve patient outcomes, reduce re-admissions, and manage chronic diseases."),
		// 			Industry: to.Ptr("Health"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-patient"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Continuous Patient Monitoring"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central PnP template (preview)"),
		// 			Description: to.Ptr("Create an application with Azure IoT Plug and Play."),
		// 			Industry: to.Ptr(""),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-pnp-preview"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](1),
		// 			Title: to.Ptr("Custom application"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Solar Power Monitoring application template"),
		// 			Description: to.Ptr("Connect, monitor, and manage your solar panels and energy generation."),
		// 			Industry: to.Ptr("Energy"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-power"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Solar Power Monitoring"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Water Quality Monitoring application template"),
		// 			Description: to.Ptr("Improve water quality and detect issues earlier by analyzing real-time measurements across your environment."),
		// 			Industry: to.Ptr("Government"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-quality"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Water Quality Monitoring"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Store Analytics – Checkout"),
		// 			Description: to.Ptr("Monitor and manage the checkout flow inside your store to improve efficiency and reduce wait times."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-store"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("In-store Analytics – Checkout"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Video analytics - object and motion detection application template"),
		// 			Description: to.Ptr("Use cameras as a sensor in intelligent video analytics solutions powered by Azure IoT Edge, AI, and Azure Media Services."),
		// 			Industry: to.Ptr("Retail"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-video-analytics-om"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Video analytics - object and motion detection"),
		// 		},
		// 		{
		// 			Name: to.Ptr("IoT Central Connected Waste Management application template"),
		// 			Description: to.Ptr("Maximize efficiency in the collection of solid wastes by dispatching field operators at the right time along an optimized collection route."),
		// 			Industry: to.Ptr("Government"),
		// 			Locations: []*armiotcentral.AppTemplateLocations{
		// 				{
		// 					DisplayName: to.Ptr("United States"),
		// 					ID: to.Ptr("unitedstates"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Europe"),
		// 					ID: to.Ptr("europe"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Asia Pacific"),
		// 					ID: to.Ptr("asiapacific"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Australia"),
		// 					ID: to.Ptr("australia"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("United Kingdom"),
		// 					ID: to.Ptr("uk"),
		// 				},
		// 				{
		// 					DisplayName: to.Ptr("Japan"),
		// 					ID: to.Ptr("japan"),
		// 			}},
		// 			ManifestID: to.Ptr("iotc-waste"),
		// 			ManifestVersion: to.Ptr("1.0.0"),
		// 			Order: to.Ptr[float32](99),
		// 			Title: to.Ptr("Connected Waste Management"),
		// 	}},
		// }
	}
}

Output:

type AppsClientBeginCreateOrUpdateOptions added in v0.2.0 

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

AppsClientBeginCreateOrUpdateOptions contains the optional parameters for the AppsClient.BeginCreateOrUpdate method.

type AppsClientBeginDeleteOptions added in v0.2.0 

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

AppsClientBeginDeleteOptions contains the optional parameters for the AppsClient.BeginDelete method.

type AppsClientBeginUpdateOptions added in v0.2.0 

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

AppsClientBeginUpdateOptions contains the optional parameters for the AppsClient.BeginUpdate method.

type AppsClientCheckNameAvailabilityOptions added in v0.2.0 

type AppsClientCheckNameAvailabilityOptions struct {
}

AppsClientCheckNameAvailabilityOptions contains the optional parameters for the AppsClient.CheckNameAvailability method.

type AppsClientCheckNameAvailabilityResponse added in v0.2.0 

type AppsClientCheckNameAvailabilityResponse struct {
	// The properties indicating whether a given IoT Central application name or subdomain is available.
	AppAvailabilityInfo
}

AppsClientCheckNameAvailabilityResponse contains the response from method AppsClient.CheckNameAvailability.

type AppsClientCheckSubdomainAvailabilityOptions added in v0.2.0 

type AppsClientCheckSubdomainAvailabilityOptions struct {
}

AppsClientCheckSubdomainAvailabilityOptions contains the optional parameters for the AppsClient.CheckSubdomainAvailability method.

type AppsClientCheckSubdomainAvailabilityResponse added in v0.2.0 

type AppsClientCheckSubdomainAvailabilityResponse struct {
	// The properties indicating whether a given IoT Central application name or subdomain is available.
	AppAvailabilityInfo
}

AppsClientCheckSubdomainAvailabilityResponse contains the response from method AppsClient.CheckSubdomainAvailability.

type AppsClientCreateOrUpdateResponse added in v0.2.0 

type AppsClientCreateOrUpdateResponse struct {
	// The IoT Central application.
	App
}

AppsClientCreateOrUpdateResponse contains the response from method AppsClient.BeginCreateOrUpdate.

type AppsClientDeleteResponse added in v0.2.0 

type AppsClientDeleteResponse struct {
}

AppsClientDeleteResponse contains the response from method AppsClient.BeginDelete.

type AppsClientGetOptions added in v0.2.0 

type AppsClientGetOptions struct {
}

AppsClientGetOptions contains the optional parameters for the AppsClient.Get method.

type AppsClientGetResponse added in v0.2.0 

type AppsClientGetResponse struct {
	// The IoT Central application.
	App
}

AppsClientGetResponse contains the response from method AppsClient.Get.

type AppsClientListByResourceGroupOptions added in v0.2.0 

type AppsClientListByResourceGroupOptions struct {
}

AppsClientListByResourceGroupOptions contains the optional parameters for the AppsClient.NewListByResourceGroupPager method.

type AppsClientListByResourceGroupResponse added in v0.2.0 

type AppsClientListByResourceGroupResponse struct {
	// A list of IoT Central Applications with a next link.
	AppListResult
}

AppsClientListByResourceGroupResponse contains the response from method AppsClient.NewListByResourceGroupPager.

type AppsClientListBySubscriptionOptions added in v0.2.0 

type AppsClientListBySubscriptionOptions struct {
}

AppsClientListBySubscriptionOptions contains the optional parameters for the AppsClient.NewListBySubscriptionPager method.

type AppsClientListBySubscriptionResponse added in v0.2.0 

type AppsClientListBySubscriptionResponse struct {
	// A list of IoT Central Applications with a next link.
	AppListResult
}

AppsClientListBySubscriptionResponse contains the response from method AppsClient.NewListBySubscriptionPager.

type AppsClientListTemplatesOptions added in v0.2.0 

type AppsClientListTemplatesOptions struct {
}

AppsClientListTemplatesOptions contains the optional parameters for the AppsClient.NewListTemplatesPager method.

type AppsClientListTemplatesResponse added in v0.2.0 

type AppsClientListTemplatesResponse struct {
	// A list of IoT Central Application Templates with a next link.
	AppTemplatesResult
}

AppsClientListTemplatesResponse contains the response from method AppsClient.NewListTemplatesPager.

type AppsClientUpdateResponse added in v0.2.0 

type AppsClientUpdateResponse struct {
	// The IoT Central application.
	App
}

AppsClientUpdateResponse contains the response from method AppsClient.BeginUpdate.

type ClientFactory added in v1.1.0 

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

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

func NewClientFactory added in v1.1.0 

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

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

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

func (*ClientFactory) NewAppsClient added in v1.1.0 

func (c *ClientFactory) NewAppsClient() *AppsClient

NewAppsClient creates a new instance of AppsClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type CloudErrorBody 

type CloudErrorBody struct {
	// A list of additional details about the error.
	Details []*CloudErrorBody

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

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

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

CloudErrorBody - Details of error response.

func (CloudErrorBody) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CloudErrorBody.

func (*CloudErrorBody) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CloudErrorBody.

type Operation 

type Operation struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// READ-ONLY; Operation name: {provider}/{resource}/{read | write | action | delete}
	Name *string

	// READ-ONLY; The intended executor of the operation.
	Origin *string

	// READ-ONLY; Additional descriptions for the operation.
	Properties any
}

Operation - IoT Central REST API operation

func (Operation) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; Friendly description for the operation,
	Description *string

	// READ-ONLY; Name of the operation
	Operation *string

	// READ-ONLY; Service provider: Microsoft IoT Central
	Provider *string

	// READ-ONLY; Resource Type: IoT Central
	Resource *string
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationInputs 

type OperationInputs struct {
	// REQUIRED; The name of the IoT Central application instance to check.
	Name *string

	// The type of the IoT Central resource to query.
	Type *string
}

OperationInputs - Input values.

func (OperationInputs) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationInputs.

func (*OperationInputs) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationInputs.

type OperationListResult 

type OperationListResult struct {
	// The link used to get the next page of IoT Central description objects.
	NextLink *string

	// READ-ONLY; A list of operations supported by the Microsoft.IoTCentral resource provider.
	Value []*Operation
}

OperationListResult - A list of IoT Central operations. It contains a list of operations and a URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager added in v0.4.0 

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

NewListPager - Lists all of the available IoT Central Resource Provider operations.

Generated from API version 2021-06-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/iotcentral/resource-manager/Microsoft.IoTCentral/stable/2021-06-01/examples/Operations_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotcentral/armiotcentral"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotcentral.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.OperationListResult = armiotcentral.OperationListResult{
		// 	Value: []*armiotcentral.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/IoTApps/read"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Gets a single IoT Central Application"),
		// 				Operation: to.Ptr("Get IoT Central Application"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("IoTApps"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/IoTApps/write"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Creates or Updates an IoT Central Applications"),
		// 				Operation: to.Ptr("Create or Update IoT Central Application"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("IoTApps"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/IoTApps/delete"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Deletes an IoT Central Applications"),
		// 				Operation: to.Ptr("Delete IoT Central Application"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("IoTApps"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/checkNameAvailability/action"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Checks if an IoT Central Application name is available"),
		// 				Operation: to.Ptr("Check resource name availability"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr(""),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/checkSubdomainAvailability/action"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Checks if an IoT Central Application subdomain is available"),
		// 				Operation: to.Ptr("Check resource subdomain availability"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr(""),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/operations/read"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Gets all the available operations on IoT Central Applications"),
		// 				Operation: to.Ptr("Get all the available operations"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr(""),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/appTemplates/action"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Gets all the available application templates on Azure IoT Central"),
		// 				Operation: to.Ptr("Get all available application templates"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("Azure IoT Central Resource Provider"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/register/action"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Register the subscription for Azure IoT Central resource provider"),
		// 				Operation: to.Ptr("Register Azure IoT Central resource provider"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("Azure IoT Central Resource Provider"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/IoTApps/providers/Microsoft.Insights/metricDefinitions/read"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Gets all the available Metrics definitions on Azure IoT Central"),
		// 				Operation: to.Ptr("Get all available Metrics definitions"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("IoTApps"),
		// 			},
		// 			Origin: to.Ptr("system"),
		// 			Properties: map[string]any{
		// 				"serviceSpecification":map[string]any{
		// 					"metricSpecifications":[]any{
		// 						map[string]any{
		// 							"name": "connectedDeviceCount",
		// 							"aggregationType": "Average",
		// 							"displayDescription": "Number of devices connected to IoT Central",
		// 							"displayName": "Total Connected Devices",
		// 							"lockAggregationType": "Total",
		// 							"supportedAggregationTypes":[]any{
		// 								"Average",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "c2d.property.read.success",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all successful property reads initiated from IoT Central",
		// 							"displayName": "Successful Device Property Reads from IoT Central",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "c2d.property.read.failure",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all failed property reads initiated from IoT Central",
		// 							"displayName": "Failed Device Property Reads from IoT Central",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "d2c.property.read.success",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all successful property reads initiated from devices",
		// 							"displayName": "Successful Device Property Reads from Devices",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "d2c.property.read.failure",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all failed property reads initiated from devices",
		// 							"displayName": "Failed Device Property Reads from Devices",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "c2d.property.update.success",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all successful property updates initiated from IoT Central",
		// 							"displayName": "Successful Device Property Updates from IoT Central",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "c2d.property.update.failure",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all failed property updates initiated from IoT Central",
		// 							"displayName": "Failed Device Property Updates from IoT Central",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "d2c.property.update.success",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all successful property updates initiated from devices",
		// 							"displayName": "Successful Device Property Updates from Devices",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 						map[string]any{
		// 							"name": "d2c.property.update.failure",
		// 							"aggregationType": "Total",
		// 							"displayDescription": "The count of all failed property updates initiated from devices",
		// 							"displayName": "Failed Device Property Updates from Devices",
		// 							"supportedAggregationTypes":[]any{
		// 								"Total",
		// 							},
		// 							"supportedTimeGrainTypes":[]any{
		// 								"PT1M",
		// 								"PT5M",
		// 								"PT15M",
		// 								"PT30M",
		// 								"PT1H",
		// 								"PT6H",
		// 								"PT12H",
		// 								"P1D",
		// 							},
		// 							"unit": "Count",
		// 						},
		// 					},
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/IoTApps/providers/Microsoft.Insights/diagnosticSettings/read"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Gets the diagnostic setting for the resource"),
		// 				Operation: to.Ptr("Read diagnostic setting"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("IoTApps"),
		// 			},
		// 			Origin: to.Ptr("system"),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.IoTCentral/IoTApps/providers/Microsoft.Insights/diagnosticSettings/write"),
		// 			Display: &armiotcentral.OperationDisplay{
		// 				Description: to.Ptr("Creates or updates the diagnostic setting for the resource"),
		// 				Operation: to.Ptr("Write diagnostic setting"),
		// 				Provider: to.Ptr("Azure IoT Central"),
		// 				Resource: to.Ptr("IoTApps"),
		// 			},
		// 			Origin: to.Ptr("system"),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions added in v0.2.0 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse added in v0.2.0 

type OperationsClientListResponse struct {
	// A list of IoT Central operations. It contains a list of operations and a URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Resource 

type Resource struct {
	// REQUIRED; The resource location.
	Location *string

	// The resource tags.
	Tags map[string]*string

	// READ-ONLY; The ARM resource identifier.
	ID *string

	// READ-ONLY; The ARM resource name.
	Name *string

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

Resource - The common properties of an ARM resource.

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SystemAssignedServiceIdentity 

type SystemAssignedServiceIdentity struct {
	// REQUIRED; Type of managed service identity (either system assigned, or none).
	Type *SystemAssignedServiceIdentityType

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

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

SystemAssignedServiceIdentity - Managed service identity (either system assigned, or none)

func (SystemAssignedServiceIdentity) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type SystemAssignedServiceIdentity.

func (*SystemAssignedServiceIdentity) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemAssignedServiceIdentity.

type SystemAssignedServiceIdentityType 

type SystemAssignedServiceIdentityType string

SystemAssignedServiceIdentityType - Type of managed service identity (either system assigned, or none). 

const (
	SystemAssignedServiceIdentityTypeNone           SystemAssignedServiceIdentityType = "None"
	SystemAssignedServiceIdentityTypeSystemAssigned SystemAssignedServiceIdentityType = "SystemAssigned"
)

func PossibleSystemAssignedServiceIdentityTypeValues 

func PossibleSystemAssignedServiceIdentityTypeValues() []SystemAssignedServiceIdentityType

PossibleSystemAssignedServiceIdentityTypeValues returns the possible values for the SystemAssignedServiceIdentityType const type.

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.