armiotcentral

package module
v2.0.0-beta.2 Latest Latest
Warning

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

 Go to latest Published: Mar 30, 2023 License: MIT Imports: 14 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()

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 geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// REQUIRED; A valid instance SKU.
	SKU *AppSKUInfo `json:"sku,omitempty"`

	// The managed identities for the IoT Central application.
	Identity *SystemAssignedServiceIdentity `json:"identity,omitempty"`

	// The common properties of an IoT Central application.
	Properties *AppProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

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 

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 `json:"message,omitempty" azure:"ro"`

	// READ-ONLY; The value which indicates whether the provided name is available.
	NameAvailable *bool `json:"nameAvailable,omitempty" azure:"ro"`

	// READ-ONLY; The reason for unavailability.
	Reason *string `json:"reason,omitempty" azure:"ro"`
}

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

func (AppAvailabilityInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppAvailabilityInfo.

func (*AppAvailabilityInfo) UnmarshalJSON 

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 `json:"nextLink,omitempty"`

	// A list of IoT Central Applications.
	Value []*App `json:"value,omitempty"`
}

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 

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 `json:"identity,omitempty"`

	// The common properties of an IoT Central application.
	Properties *AppProperties `json:"properties,omitempty"`

	// A valid instance SKU.
	SKU *AppSKUInfo `json:"sku,omitempty"`

	// Instance tags
	Tags map[string]*string `json:"tags,omitempty"`
}

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 

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 `json:"displayName,omitempty"`

	// Network Rule Set Properties of this IoT Central application.
	NetworkRuleSets *NetworkRuleSets `json:"networkRuleSets,omitempty"`

	// Whether requests from the public network are allowed.
	PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"`

	// The subdomain of the application.
	Subdomain *string `json:"subdomain,omitempty"`

	// 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 `json:"template,omitempty"`

	// READ-ONLY; The ID of the application.
	ApplicationID *string `json:"applicationId,omitempty" azure:"ro"`

	// READ-ONLY; Private endpoint connections created on this IoT Central application.
	PrivateEndpointConnections []*PrivateEndpointConnection `json:"privateEndpointConnections,omitempty" azure:"ro"`

	// READ-ONLY; The provisioning state of the application.
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; The current state of the application.
	State *AppState `json:"state,omitempty" azure:"ro"`
}

AppProperties - The properties of an IoT Central application.

func (AppProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppProperties.

func (*AppProperties) UnmarshalJSON 

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 `json:"name,omitempty"`
}

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

func (AppSKUInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppSKUInfo.

func (*AppSKUInfo) UnmarshalJSON 

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 `json:"description,omitempty" azure:"ro"`

	// READ-ONLY; The industry of the template.
	Industry *string `json:"industry,omitempty" azure:"ro"`

	// READ-ONLY; A list of locations that support the template.
	Locations []*AppTemplateLocations `json:"locations,omitempty" azure:"ro"`

	// READ-ONLY; The ID of the template.
	ManifestID *string `json:"manifestId,omitempty" azure:"ro"`

	// READ-ONLY; The version of the template.
	ManifestVersion *string `json:"manifestVersion,omitempty" azure:"ro"`

	// READ-ONLY; The name of the template.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The order of the template in the templates list.
	Order *float32 `json:"order,omitempty" azure:"ro"`

	// READ-ONLY; The title of the template.
	Title *string `json:"title,omitempty" azure:"ro"`
}

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 

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 `json:"displayName,omitempty" azure:"ro"`

	// READ-ONLY; The ID of the location.
	ID *string `json:"id,omitempty" azure:"ro"`
}

AppTemplateLocations - IoT Central Application Template Locations.

func (AppTemplateLocations) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AppTemplateLocations.

func (*AppTemplateLocations) UnmarshalJSON 

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 `json:"nextLink,omitempty"`

	// READ-ONLY; A list of IoT Central Application Templates.
	Value []*AppTemplate `json:"value,omitempty" azure:"ro"`
}

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 

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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_CreateOrUpdate.json 

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"),
// 		NetworkRuleSets: &armiotcentral.NetworkRuleSets{
// 			ApplyToDevices: to.Ptr(false),
// 			ApplyToIoTCentral: to.Ptr(false),
// 			DefaultAction: to.Ptr(armiotcentral.NetworkActionDeny),
// 			IPRules: []*armiotcentral.NetworkRuleSetIPRule{
// 			},
// 		},
// 		PrivateEndpointConnections: []*armiotcentral.PrivateEndpointConnection{
// 		},
// 		ProvisioningState: to.Ptr(armiotcentral.ProvisioningStateSucceeded),
// 		PublicNetworkAccess: to.Ptr(armiotcentral.PublicNetworkAccessEnabled),
// 		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.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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_Delete.json 

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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_Update.json 

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)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_CheckNameAvailability.json 

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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_CheckSubdomainAvailability.json 

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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_Get.json 

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"),
// 		NetworkRuleSets: &armiotcentral.NetworkRuleSets{
// 			ApplyToDevices: to.Ptr(true),
// 			ApplyToIoTCentral: to.Ptr(false),
// 			DefaultAction: to.Ptr(armiotcentral.NetworkActionDeny),
// 			IPRules: []*armiotcentral.NetworkRuleSetIPRule{
// 				{
// 					FilterName: to.Ptr("My Computer"),
// 					IPMask: to.Ptr("21.19.35.40/24"),
// 			}},
// 		},
// 		PrivateEndpointConnections: []*armiotcentral.PrivateEndpointConnection{
// 			{
// 				Name: to.Ptr("myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
// 				Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections"),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/PrivateEndpointConnections/myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
// 				Properties: &armiotcentral.PrivateEndpointConnectionProperties{
// 					GroupIDs: []*string{
// 						to.Ptr("iotApp")},
// 						PrivateEndpoint: &armiotcentral.PrivateEndpoint{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.Network/privateEndpoints/myIoTCentralAppEndpoint"),
// 						},
// 						PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
// 							Description: to.Ptr("Auto-approved"),
// 							ActionsRequired: to.Ptr("None"),
// 							Status: to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
// 						},
// 					},
// 			}},
// 			PublicNetworkAccess: to.Ptr(armiotcentral.PublicNetworkAccessEnabled),
// 			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.AppSKUST2),
// 		},
// 	}

Output:

func (*AppsClient) NewListByResourceGroupPager 

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-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_ListByResourceGroup.json 

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"),
	// 				NetworkRuleSets: &armiotcentral.NetworkRuleSets{
	// 					ApplyToDevices: to.Ptr(true),
	// 					ApplyToIoTCentral: to.Ptr(false),
	// 					DefaultAction: to.Ptr(armiotcentral.NetworkActionDeny),
	// 					IPRules: []*armiotcentral.NetworkRuleSetIPRule{
	// 						{
	// 							FilterName: to.Ptr("My Computer"),
	// 							IPMask: to.Ptr("21.19.35.40/24"),
	// 					}},
	// 				},
	// 				PrivateEndpointConnections: []*armiotcentral.PrivateEndpointConnection{
	// 					{
	// 						Name: to.Ptr("myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
	// 						Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections"),
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/PrivateEndpointConnections/myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
	// 						Properties: &armiotcentral.PrivateEndpointConnectionProperties{
	// 							GroupIDs: []*string{
	// 								to.Ptr("iotApp")},
	// 								PrivateEndpoint: &armiotcentral.PrivateEndpoint{
	// 									ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.Network/privateEndpoints/myIoTCentralAppEndpoint"),
	// 								},
	// 								PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
	// 									Description: to.Ptr("Auto-approved"),
	// 									ActionsRequired: to.Ptr("None"),
	// 									Status: to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
	// 								},
	// 							},
	// 					}},
	// 					PublicNetworkAccess: to.Ptr(armiotcentral.PublicNetworkAccessEnabled),
	// 					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 

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

NewListBySubscriptionPager - Get all IoT Central Applications in a subscription.

Generated from API version 2021-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_ListBySubscription.json 

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"),
	// 				NetworkRuleSets: &armiotcentral.NetworkRuleSets{
	// 					ApplyToDevices: to.Ptr(true),
	// 					ApplyToIoTCentral: to.Ptr(false),
	// 					DefaultAction: to.Ptr(armiotcentral.NetworkActionDeny),
	// 					IPRules: []*armiotcentral.NetworkRuleSetIPRule{
	// 						{
	// 							FilterName: to.Ptr("My Computer"),
	// 							IPMask: to.Ptr("21.19.35.40/24"),
	// 					}},
	// 				},
	// 				PrivateEndpointConnections: []*armiotcentral.PrivateEndpointConnection{
	// 					{
	// 						Name: to.Ptr("myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
	// 						Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections"),
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/PrivateEndpointConnections/myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
	// 						Properties: &armiotcentral.PrivateEndpointConnectionProperties{
	// 							GroupIDs: []*string{
	// 								to.Ptr("iotApp")},
	// 								PrivateEndpoint: &armiotcentral.PrivateEndpoint{
	// 									ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.Network/privateEndpoints/myIoTCentralAppEndpoint"),
	// 								},
	// 								PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
	// 									Description: to.Ptr("Auto-approved"),
	// 									ActionsRequired: to.Ptr("None"),
	// 									Status: to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
	// 								},
	// 							},
	// 					}},
	// 					ProvisioningState: to.Ptr(armiotcentral.ProvisioningStateSucceeded),
	// 					PublicNetworkAccess: to.Ptr(armiotcentral.PublicNetworkAccessEnabled),
	// 					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 

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

NewListTemplatesPager - Get all available application templates.

Generated from API version 2021-11-01-preview

  • 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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Apps_Templates.json 

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 

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

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

type AppsClientBeginDeleteOptions 

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

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

type AppsClientBeginUpdateOptions 

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

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

type AppsClientCheckNameAvailabilityOptions 

type AppsClientCheckNameAvailabilityOptions struct {
}

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

type AppsClientCheckNameAvailabilityResponse 

type AppsClientCheckNameAvailabilityResponse struct {
	AppAvailabilityInfo
}

AppsClientCheckNameAvailabilityResponse contains the response from method AppsClient.CheckNameAvailability.

type AppsClientCheckSubdomainAvailabilityOptions 

type AppsClientCheckSubdomainAvailabilityOptions struct {
}

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

type AppsClientCheckSubdomainAvailabilityResponse 

type AppsClientCheckSubdomainAvailabilityResponse struct {
	AppAvailabilityInfo
}

AppsClientCheckSubdomainAvailabilityResponse contains the response from method AppsClient.CheckSubdomainAvailability.

type AppsClientCreateOrUpdateResponse 

type AppsClientCreateOrUpdateResponse struct {
	App
}

AppsClientCreateOrUpdateResponse contains the response from method AppsClient.BeginCreateOrUpdate.

type AppsClientDeleteResponse 

type AppsClientDeleteResponse struct {
}

AppsClientDeleteResponse contains the response from method AppsClient.BeginDelete.

type AppsClientGetOptions 

type AppsClientGetOptions struct {
}

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

type AppsClientGetResponse 

type AppsClientGetResponse struct {
	App
}

AppsClientGetResponse contains the response from method AppsClient.Get.

type AppsClientListByResourceGroupOptions 

type AppsClientListByResourceGroupOptions struct {
}

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

type AppsClientListByResourceGroupResponse 

type AppsClientListByResourceGroupResponse struct {
	AppListResult
}

AppsClientListByResourceGroupResponse contains the response from method AppsClient.NewListByResourceGroupPager.

type AppsClientListBySubscriptionOptions 

type AppsClientListBySubscriptionOptions struct {
}

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

type AppsClientListBySubscriptionResponse 

type AppsClientListBySubscriptionResponse struct {
	AppListResult
}

AppsClientListBySubscriptionResponse contains the response from method AppsClient.NewListBySubscriptionPager.

type AppsClientListTemplatesOptions 

type AppsClientListTemplatesOptions struct {
}

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

type AppsClientListTemplatesResponse 

type AppsClientListTemplatesResponse struct {
	AppTemplatesResult
}

AppsClientListTemplatesResponse contains the response from method AppsClient.NewListTemplatesPager.

type AppsClientUpdateResponse 

type AppsClientUpdateResponse struct {
}

AppsClientUpdateResponse contains the response from method AppsClient.BeginUpdate.

type ClientFactory 

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 

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 

func (c *ClientFactory) NewAppsClient() *AppsClient

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

func (*ClientFactory) NewPrivateEndpointConnectionsClient 

func (c *ClientFactory) NewPrivateEndpointConnectionsClient() *PrivateEndpointConnectionsClient

func (*ClientFactory) NewPrivateLinksClient 

func (c *ClientFactory) NewPrivateLinksClient() *PrivateLinksClient

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any `json:"info,omitempty" azure:"ro"`

	// READ-ONLY; The additional info type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

type ErrorDetail struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo `json:"additionalInfo,omitempty" azure:"ro"`

	// READ-ONLY; The error code.
	Code *string `json:"code,omitempty" azure:"ro"`

	// READ-ONLY; The error details.
	Details []*ErrorDetail `json:"details,omitempty" azure:"ro"`

	// READ-ONLY; The error message.
	Message *string `json:"message,omitempty" azure:"ro"`

	// READ-ONLY; The error target.
	Target *string `json:"target,omitempty" azure:"ro"`
}

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type ErrorResponse 

type ErrorResponse struct {
	// The error object.
	Error *ErrorDetail `json:"error,omitempty"`
}

ErrorResponse - Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

func (ErrorResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorResponse.

func (*ErrorResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.

type IPRuleAction 

type IPRuleAction string

IPRuleAction - The network action for the IP mask. 

const (
	IPRuleActionAllow IPRuleAction = "Allow"
)

func PossibleIPRuleActionValues 

func PossibleIPRuleActionValues() []IPRuleAction

PossibleIPRuleActionValues returns the possible values for the IPRuleAction const type.

type NetworkAction 

type NetworkAction string

NetworkAction - Whether to allow or deny network traffic. 

const (
	NetworkActionAllow NetworkAction = "Allow"
	NetworkActionDeny  NetworkAction = "Deny"
)

func PossibleNetworkActionValues 

func PossibleNetworkActionValues() []NetworkAction

PossibleNetworkActionValues returns the possible values for the NetworkAction const type.

type NetworkRuleSetIPRule 

type NetworkRuleSetIPRule struct {
	// The readable name of the IP rule.
	FilterName *string `json:"filterName,omitempty"`

	// The CIDR block defining the IP range.
	IPMask *string `json:"ipMask,omitempty"`

	// READ-ONLY; The network action for the IP mask.
	Action *IPRuleAction `json:"action,omitempty" azure:"ro"`
}

NetworkRuleSetIPRule - An object for an IP range that will be allowed access.

func (NetworkRuleSetIPRule) MarshalJSON 

func (n NetworkRuleSetIPRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkRuleSetIPRule.

func (*NetworkRuleSetIPRule) UnmarshalJSON 

func (n *NetworkRuleSetIPRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkRuleSetIPRule.

type NetworkRuleSets 

type NetworkRuleSets struct {
	// Whether these rules apply for device connectivity to IoT Hub and Device Provisioning service associated with this application.
	ApplyToDevices *bool `json:"applyToDevices,omitempty"`

	// Whether these rules apply for connectivity via IoT Central web portal and APIs.
	ApplyToIoTCentral *bool `json:"applyToIoTCentral,omitempty"`

	// The default network action to apply.
	DefaultAction *NetworkAction `json:"defaultAction,omitempty"`

	// List of IP rules.
	IPRules []*NetworkRuleSetIPRule `json:"ipRules,omitempty"`
}

NetworkRuleSets - Network Rule Set Properties of this IoT Central application.

func (NetworkRuleSets) MarshalJSON 

func (n NetworkRuleSets) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkRuleSets.

func (*NetworkRuleSets) UnmarshalJSON 

func (n *NetworkRuleSets) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkRuleSets.

type Operation 

type Operation struct {
	// The object that represents the operation.
	Display *OperationDisplay `json:"display,omitempty"`

	// READ-ONLY; Operation name: {provider}/{resource}/{read | write | action | delete}
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The intended executor of the operation.
	Origin *string `json:"origin,omitempty" azure:"ro"`

	// READ-ONLY; Additional descriptions for the operation.
	Properties any `json:"properties,omitempty" azure:"ro"`
}

Operation - IoT Central REST API operation

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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 `json:"description,omitempty" azure:"ro"`

	// READ-ONLY; Name of the operation
	Operation *string `json:"operation,omitempty" azure:"ro"`

	// READ-ONLY; Service provider: Microsoft IoT Central
	Provider *string `json:"provider,omitempty" azure:"ro"`

	// READ-ONLY; Resource Type: IoT Central
	Resource *string `json:"resource,omitempty" azure:"ro"`
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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 `json:"name,omitempty"`

	// The type of the IoT Central resource to query.
	Type *string `json:"type,omitempty"`
}

OperationInputs - Input values.

func (OperationInputs) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationInputs.

func (*OperationInputs) UnmarshalJSON 

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 `json:"nextLink,omitempty"`

	// READ-ONLY; A list of operations supported by the Microsoft.IoTCentral resource provider.
	Value []*Operation `json:"value,omitempty" azure:"ro"`
}

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 

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 

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-11-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/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/Operations_List.json 

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("Read IoTApp resources"),
	// 				Operation: to.Ptr("Get/List IoTApp resource(s)"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/write"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Create or update a IoTApp resource"),
	// 				Operation: to.Ptr("Create/Update/Patch IoTApp resources"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/delete"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Delete IoTApp resource"),
	// 				Operation: to.Ptr("Delete IoTApp resource"),
	// 				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 a IoTApp resource name is available"),
	// 				Operation: to.Ptr("Check IoTApp 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("Check if a IoTApp resource subdomain is available"),
	// 				Operation: to.Ptr("Check IoTApp 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("Get/List all the available operations for IoT Central"),
	// 				Operation: to.Ptr("Get/List operations"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr(""),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/appTemplates/action"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Lists application templates for IoTApps resources."),
	// 				Operation: to.Ptr("List app 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 the IoTCentral resource provider"),
	// 				Operation: to.Ptr("Register Microsoft.IoTCentral resource provider"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("Azure IoT Central resource provider"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateLinkResources/read"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Read private link resources"),
	// 				Operation: to.Ptr("Get/List private link resources"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateLinkResources"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections/write"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Approve/reject/disconnect private endpoint connections"),
	// 				Operation: to.Ptr("Approve/Reject/Disconnect private endpoint connections"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnections"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections/read"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Read private endpoint connections"),
	// 				Operation: to.Ptr("Get/List private endpoint connections"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnections"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections/delete"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Delete private endpoint connections"),
	// 				Operation: to.Ptr("Delete private endpoint connections"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnections"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnectionProxies/validate/action"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Validate private endpoint connection proxies during Create/Update/Patch"),
	// 				Operation: to.Ptr("Validate private endpoint connection proxies"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnectionProxies"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnectionProxies/read"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Read private endpoint connection proxies"),
	// 				Operation: to.Ptr("Get/List private endpoint connection proxies"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnectionProxies"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnectionProxies/write"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Create/Update/Patch private endpoint connection proxies"),
	// 				Operation: to.Ptr("Create/Update/Patch private endpoint connection proxies"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnectionProxies"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnectionProxies/delete"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Deletes private endpoint connection proxies"),
	// 				Operation: to.Ptr("Delete private endpoint connection proxies"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps/privateEndpointConnectionProxies"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/locations/operationResults/read"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Get async operation results for IoT Central"),
	// 				Operation: to.Ptr("Get async operation results"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("locations/operationResults"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.IoTCentral/iotApps/providers/Microsoft.Insights/metricDefinitions/read"),
	// 			Display: &armiotcentral.OperationDisplay{
	// 				Description: to.Ptr("Read all the available metric definitions for IoT Central"),
	// 				Operation: to.Ptr("Get/List metric 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",
	// 							"fillGapWithZero": true,
	// 							"lockAggregationType": "Total",
	// 							"supportedAggregationTypes":[]any{
	// 								"Average",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"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",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "provisionedDeviceCount",
	// 							"aggregationType": "Average",
	// 							"displayDescription": "Number of devices provisioned in IoT Central application",
	// 							"displayName": "Total Provisioned Devices",
	// 							"fillGapWithZero": true,
	// 							"lockAggregationType": "Total",
	// 							"supportedAggregationTypes":[]any{
	// 								"Average",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "deviceDataUsage",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "Bytes transferred to and from any devices connected to IoT Central application",
	// 							"displayName": "Total Device Data Usage",
	// 							"fillGapWithZero": true,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Bytes",
	// 						},
	// 						map[string]any{
	// 							"name": "c2d.commands.success",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "The count of all successful command requests initiated from IoT Central",
	// 							"displayName": "Successful command invocations",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "c2d.commands.failure",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "The count of all failed command requests initiated from IoT Central",
	// 							"displayName": "Failed command invocations",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "c2d.commands.requestSize",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "Request size of all command requests initiated from IoT Central",
	// 							"displayName": "Request size of command invocations",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Bytes",
	// 						},
	// 						map[string]any{
	// 							"name": "c2d.commands.responseSize",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "Response size of all command responses initiated from IoT Central",
	// 							"displayName": "Response size of command invocations",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Bytes",
	// 						},
	// 						map[string]any{
	// 							"name": "d2c.telemetry.ingress.allProtocol",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "Number of device-to-cloud telemetry messages attempted to be sent to the IoT Central application",
	// 							"displayName": "Total Telemetry Message Send Attempts",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "d2c.telemetry.ingress.success",
	// 							"aggregationType": "Total",
	// 							"displayDescription": "Number of device-to-cloud telemetry messages successfully sent to the IoT Central application",
	// 							"displayName": "Total Telemetry Messages Sent",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "dataExport.messages.received",
	// 							"aggregationType": "Total",
	// 							"dimensions":[]any{
	// 								map[string]any{
	// 									"name": "exportId",
	// 									"displayName": "Export Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "exportDisplayName",
	// 									"displayName": "Export Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationId",
	// 									"displayName": "Destination Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationDisplayName",
	// 									"displayName": "Destination Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 							},
	// 							"displayDescription": "Number of messages incoming to data export, before filtering and enrichment processing",
	// 							"displayName": "Data Export Messages Received",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "dataExport.messages.filtered",
	// 							"aggregationType": "Total",
	// 							"dimensions":[]any{
	// 								map[string]any{
	// 									"name": "exportId",
	// 									"displayName": "Export Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "exportDisplayName",
	// 									"displayName": "Export Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationId",
	// 									"displayName": "Destination Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationDisplayName",
	// 									"displayName": "Destination Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 							},
	// 							"displayDescription": "Number of messages that have passed through filters in data export",
	// 							"displayName": "Data Export Messages Filtered",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "dataExport.messages.written",
	// 							"aggregationType": "Total",
	// 							"dimensions":[]any{
	// 								map[string]any{
	// 									"name": "exportId",
	// 									"displayName": "Export Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "exportDisplayName",
	// 									"displayName": "Export Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationId",
	// 									"displayName": "Destination Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationDisplayName",
	// 									"displayName": "Destination Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 							},
	// 							"displayDescription": "Number of messages written to a destination",
	// 							"displayName": "Data Export Messages Written",
	// 							"fillGapWithZero": false,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "dataExport.error",
	// 							"aggregationType": "Total",
	// 							"dimensions":[]any{
	// 								map[string]any{
	// 									"name": "exportId",
	// 									"displayName": "Export Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "exportDisplayName",
	// 									"displayName": "Export Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationId",
	// 									"displayName": "Destination Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationDisplayName",
	// 									"displayName": "Destination Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 							},
	// 							"displayDescription": "Number of errors encountered for data export",
	// 							"displayName": "Data Export Errors",
	// 							"fillGapWithZero": true,
	// 							"supportedAggregationTypes":[]any{
	// 								"Total",
	// 							},
	// 							"supportedTimeGrainTypes":[]any{
	// 								"PT1M",
	// 								"PT5M",
	// 								"PT15M",
	// 								"PT30M",
	// 								"PT1H",
	// 								"PT6H",
	// 								"PT12H",
	// 								"P1D",
	// 							},
	// 							"unit": "Count",
	// 						},
	// 						map[string]any{
	// 							"name": "dataExport.statusChange",
	// 							"aggregationType": "Total",
	// 							"dimensions":[]any{
	// 								map[string]any{
	// 									"name": "exportId",
	// 									"displayName": "Export Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "exportDisplayName",
	// 									"displayName": "Export Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationId",
	// 									"displayName": "Destination Id",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "destinationDisplayName",
	// 									"displayName": "Destination Display Name",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 								map[string]any{
	// 									"name": "status",
	// 									"displayName": "Status",
	// 									"toBeExportedForShoebox": true,
	// 								},
	// 							},
	// 							"displayDescription": "Number of status changes",
	// 							"displayName": "Data Export Status Change",
	// 							"fillGapWithZero": true,
	// 							"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("Get/List all the diagnostic settings for the resource"),
	// 				Operation: to.Ptr("Get/List diagnostic settings"),
	// 				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("Set diagnostic settings for the resource"),
	// 				Operation: to.Ptr("Create/Update/Patch diagnostic settings"),
	// 				Provider: to.Ptr("Azure IoT Central"),
	// 				Resource: to.Ptr("IoTApps"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// READ-ONLY; The ARM identifier for private endpoint.
	ID *string `json:"id,omitempty" azure:"ro"`
}

PrivateEndpoint - The private endpoint resource.

func (PrivateEndpoint) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpoint.

func (*PrivateEndpoint) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpoint.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// Resource properties.
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

PrivateEndpointConnection - The private endpoint connection resource.

func (PrivateEndpointConnection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnection.

func (*PrivateEndpointConnection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnection.

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult struct {
	// Array of private endpoint connections.
	Value []*PrivateEndpointConnection `json:"value,omitempty"`
}

PrivateEndpointConnectionListResult - List of private endpoint connections associated with the specified resource.

func (PrivateEndpointConnectionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionListResult.

func (*PrivateEndpointConnectionListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionListResult.

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"privateLinkServiceConnectionState,omitempty"`

	// The private endpoint resource.
	PrivateEndpoint *PrivateEndpoint `json:"privateEndpoint,omitempty"`

	// READ-ONLY; The group ids for the private endpoint resource.
	GroupIDs []*string `json:"groupIds,omitempty" azure:"ro"`

	// READ-ONLY; The provisioning state of the private endpoint connection resource.
	ProvisioningState *PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty" azure:"ro"`
}

PrivateEndpointConnectionProperties - Properties of the private endpoint connection.

func (PrivateEndpointConnectionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionProperties.

func (*PrivateEndpointConnectionProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionProperties.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

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

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionsClient 

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

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

func NewPrivateEndpointConnectionsClient 

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

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

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

func (*PrivateEndpointConnectionsClient) BeginCreate 

func (client *PrivateEndpointConnectionsClient) BeginCreate(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection, options *PrivateEndpointConnectionsClientBeginCreateOptions) (*runtime.Poller[PrivateEndpointConnectionsClientCreateResponse], error)

BeginCreate - Update a private endpoint connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-11-01-preview

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • privateEndpointConnectionName - The private endpoint connection name.
  • privateEndpointConnection - The private endpoint connection metadata.
  • options - PrivateEndpointConnectionsClientBeginCreateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/PrivateEndpointConnections_Update.json 

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.NewPrivateEndpointConnectionsClient().BeginCreate(ctx, "resRg", "myIoTCentralApp", "myIoTCentralAppEndpoint", armiotcentral.PrivateEndpointConnection{
	Properties: &armiotcentral.PrivateEndpointConnectionProperties{
		PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
			Description:     to.Ptr("Auto-approved"),
			ActionsRequired: to.Ptr("None"),
			Status:          to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
		},
	},
}, 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.PrivateEndpointConnection = armiotcentral.PrivateEndpointConnection{
// 	Name: to.Ptr("myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
// 	Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/PrivateEndpointConnections/myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
// 	Properties: &armiotcentral.PrivateEndpointConnectionProperties{
// 		GroupIDs: []*string{
// 			to.Ptr("iotApp")},
// 			PrivateEndpoint: &armiotcentral.PrivateEndpoint{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.Network/privateEndpoints/myIoTCentralAppEndpoint"),
// 			},
// 			PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
// 				Description: to.Ptr("Auto-approved"),
// 				ActionsRequired: to.Ptr("None"),
// 				Status: to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
// 			},
// 		},
// 	}

Output:

func (*PrivateEndpointConnectionsClient) BeginDelete 

func (client *PrivateEndpointConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientBeginDeleteOptions) (*runtime.Poller[PrivateEndpointConnectionsClientDeleteResponse], error)

BeginDelete - Deletes a private endpoint connection from the IoT Central Application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-11-01-preview

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • privateEndpointConnectionName - The private endpoint connection name.
  • options - PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/PrivateEndpointConnections_Delete.json 

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.NewPrivateEndpointConnectionsClient().BeginDelete(ctx, "resRg", "myIoTCentralApp", "myIoTCentralAppEndpoint", 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 (*PrivateEndpointConnectionsClient) Get 

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

Get - Get the metadata of a private endpoint connection for the IoT Central Application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-11-01-preview

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • privateEndpointConnectionName - The private endpoint connection name.
  • options - PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/PrivateEndpointConnections_Get.json 

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.NewPrivateEndpointConnectionsClient().Get(ctx, "resRg", "myIoTCentralApp", "myIoTCentralAppEndpoint", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.PrivateEndpointConnection = armiotcentral.PrivateEndpointConnection{
// 	Name: to.Ptr("myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
// 	Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/PrivateEndpointConnections/myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
// 	Properties: &armiotcentral.PrivateEndpointConnectionProperties{
// 		GroupIDs: []*string{
// 			to.Ptr("iotApp")},
// 			PrivateEndpoint: &armiotcentral.PrivateEndpoint{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.Network/privateEndpoints/myIoTCentralAppEndpoint"),
// 			},
// 			PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
// 				Description: to.Ptr("Auto-approved"),
// 				ActionsRequired: to.Ptr("None"),
// 				Status: to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
// 			},
// 		},
// 	}

Output:

func (*PrivateEndpointConnectionsClient) NewListPager 

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

NewListPager - Get all private endpoint connections of a IoT Central Application.

Generated from API version 2021-11-01-preview

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • options - PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/PrivateEndpointConnections_List.json 

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.NewPrivateEndpointConnectionsClient().NewListPager("resRg", "myIoTCentralApp", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.PrivateEndpointConnectionListResult = armiotcentral.PrivateEndpointConnectionListResult{
	// 	Value: []*armiotcentral.PrivateEndpointConnection{
	// 		{
	// 			Name: to.Ptr("myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
	// 			Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateEndpointConnections"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/PrivateEndpointConnections/myIoTCentralAppEndpoint.a791c6b5-874d-4f03-9092-718490d33770"),
	// 			Properties: &armiotcentral.PrivateEndpointConnectionProperties{
	// 				GroupIDs: []*string{
	// 					to.Ptr("iotApp")},
	// 					PrivateEndpoint: &armiotcentral.PrivateEndpoint{
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resRg/providers/Microsoft.Network/privateEndpoints/myIoTCentralAppEndpoint"),
	// 					},
	// 					PrivateLinkServiceConnectionState: &armiotcentral.PrivateLinkServiceConnectionState{
	// 						Description: to.Ptr("Auto-approved"),
	// 						ActionsRequired: to.Ptr("None"),
	// 						Status: to.Ptr(armiotcentral.PrivateEndpointServiceConnectionStatusApproved),
	// 					},
	// 				},
	// 		}},
	// 	}
}

Output:

type PrivateEndpointConnectionsClientBeginCreateOptions 

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

PrivateEndpointConnectionsClientBeginCreateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginCreate method.

type PrivateEndpointConnectionsClientBeginDeleteOptions 

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

PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.

type PrivateEndpointConnectionsClientCreateResponse 

type PrivateEndpointConnectionsClientCreateResponse struct {
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientCreateResponse contains the response from method PrivateEndpointConnectionsClient.BeginCreate.

type PrivateEndpointConnectionsClientDeleteResponse 

type PrivateEndpointConnectionsClientDeleteResponse struct {
}

PrivateEndpointConnectionsClientDeleteResponse contains the response from method PrivateEndpointConnectionsClient.BeginDelete.

type PrivateEndpointConnectionsClientGetOptions 

type PrivateEndpointConnectionsClientGetOptions struct {
}

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

type PrivateEndpointConnectionsClientGetResponse 

type PrivateEndpointConnectionsClientGetResponse struct {
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListOptions 

type PrivateEndpointConnectionsClientListOptions struct {
}

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

type PrivateEndpointConnectionsClientListResponse 

type PrivateEndpointConnectionsClientListResponse struct {
	PrivateEndpointConnectionListResult
}

PrivateEndpointConnectionsClientListResponse contains the response from method PrivateEndpointConnectionsClient.NewListPager.

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string

PrivateEndpointServiceConnectionStatus - The private endpoint connection status. 

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

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// Resource properties.
	Properties *PrivateLinkResourceProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

PrivateLinkResource - A private link resource.

func (PrivateLinkResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResource.

func (*PrivateLinkResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResource.

type PrivateLinkResourceListResult 

type PrivateLinkResourceListResult struct {
	// Array of private link resources
	Value []*PrivateLinkResource `json:"value,omitempty"`
}

PrivateLinkResourceListResult - A list of private link resources.

func (PrivateLinkResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceListResult.

func (*PrivateLinkResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceListResult.

type PrivateLinkResourceProperties 

type PrivateLinkResourceProperties struct {
	// The private link resource private link DNS zone name.
	RequiredZoneNames []*string `json:"requiredZoneNames,omitempty"`

	// READ-ONLY; The private link resource group id.
	GroupID *string `json:"groupId,omitempty" azure:"ro"`

	// READ-ONLY; The private link resource required member names.
	RequiredMembers []*string `json:"requiredMembers,omitempty" azure:"ro"`
}

PrivateLinkResourceProperties - Properties of a private link resource.

func (PrivateLinkResourceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceProperties.

func (*PrivateLinkResourceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceProperties.

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// A message indicating if changes on the service provider require any updates on the consumer.
	ActionsRequired *string `json:"actionsRequired,omitempty"`

	// The reason for approval/rejection of the connection.
	Description *string `json:"description,omitempty"`

	// Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
	Status *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"`
}

PrivateLinkServiceConnectionState - A collection of information about the state of the connection between service consumer and provider.

func (PrivateLinkServiceConnectionState) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkServiceConnectionState.

func (*PrivateLinkServiceConnectionState) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkServiceConnectionState.

type PrivateLinksClient 

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

PrivateLinksClient contains the methods for the PrivateLinks group. Don't use this type directly, use NewPrivateLinksClient() instead.

func NewPrivateLinksClient 

func NewPrivateLinksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateLinksClient, error)

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

func (client *PrivateLinksClient) Get(ctx context.Context, resourceGroupName string, resourceName string, groupID string, options *PrivateLinksClientGetOptions) (PrivateLinksClientGetResponse, error)

Get - Get a private link resource of a IoT Central Application. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-11-01-preview

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • groupID - The private link resource name.
  • options - PrivateLinksClientGetOptions contains the optional parameters for the PrivateLinksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/PrivateLinks_Get.json 

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.NewPrivateLinksClient().Get(ctx, "resRg", "myIoTCentralApp", "iotApp", 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.PrivateLinkResource = armiotcentral.PrivateLinkResource{
// 	Name: to.Ptr("iotApp"),
// 	Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateLinkResources"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/privateLinkResources/iotApp"),
// 	Properties: &armiotcentral.PrivateLinkResourceProperties{
// 		GroupID: to.Ptr("iotApp"),
// 		RequiredMembers: []*string{
// 			to.Ptr("myIoTCentralApp"),
// 			to.Ptr("iotc-00000000-0000-0000-0000-000000000000"),
// 			to.Ptr("iotc-00000000-0000-0000-0"),
// 			to.Ptr("saas-dps-00000000-0000-0000-0000-000000000000")},
// 			RequiredZoneNames: []*string{
// 				to.Ptr("privatelink.azureiotcentral-test.com"),
// 				to.Ptr("privatelink.azure-devices.net"),
// 				to.Ptr("privatelink.servicebus.windows.net"),
// 				to.Ptr("privatelink.azure-devices-provisioning.net")},
// 			},
// 		}

Output:

func (*PrivateLinksClient) NewListPager 

func (client *PrivateLinksClient) NewListPager(resourceGroupName string, resourceName string, options *PrivateLinksClientListOptions) *runtime.Pager[PrivateLinksClientListResponse]

NewListPager - Get all private link resources of a IoT Central Application.

Generated from API version 2021-11-01-preview

  • resourceGroupName - The name of the resource group that contains the IoT Central application.
  • resourceName - The ARM resource name of the IoT Central application.
  • options - PrivateLinksClientListOptions contains the optional parameters for the PrivateLinksClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/96e52e2b911d533f95a0ad8e324c828d556c5f2b/specification/iotcentral/resource-manager/Microsoft.IoTCentral/preview/2021-11-01-preview/examples/PrivateLinks_List.json 

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.NewPrivateLinksClient().NewListPager("resRg", "myIoTCentralApp", 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.PrivateLinkResourceListResult = armiotcentral.PrivateLinkResourceListResult{
	// 	Value: []*armiotcentral.PrivateLinkResource{
	// 		{
	// 			Name: to.Ptr("iotApp"),
	// 			Type: to.Ptr("Microsoft.IoTCentral/iotApps/privateLinkResources"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/resRg/providers/Microsoft.IoTCentral/iotApps/myIoTCentralApp/privateLinkResources/iotApp"),
	// 			Properties: &armiotcentral.PrivateLinkResourceProperties{
	// 				GroupID: to.Ptr("iotApp"),
	// 				RequiredMembers: []*string{
	// 					to.Ptr("myIoTCentralApp"),
	// 					to.Ptr("iotc-00000000-0000-0000-0000-000000000000"),
	// 					to.Ptr("iotc-00000000-0000-0000-0"),
	// 					to.Ptr("saas-dps-00000000-0000-0000-0000-000000000000")},
	// 					RequiredZoneNames: []*string{
	// 						to.Ptr("privatelink.azureiotcentral-test.com"),
	// 						to.Ptr("privatelink.azure-devices.net"),
	// 						to.Ptr("privatelink.servicebus.windows.net"),
	// 						to.Ptr("privatelink.azure-devices-provisioning.net")},
	// 					},
	// 			}},
	// 		}
}

Output:

type PrivateLinksClientGetOptions 

type PrivateLinksClientGetOptions struct {
}

PrivateLinksClientGetOptions contains the optional parameters for the PrivateLinksClient.Get method.

type PrivateLinksClientGetResponse 

type PrivateLinksClientGetResponse struct {
	PrivateLinkResource
}

PrivateLinksClientGetResponse contains the response from method PrivateLinksClient.Get.

type PrivateLinksClientListOptions 

type PrivateLinksClientListOptions struct {
}

PrivateLinksClientListOptions contains the optional parameters for the PrivateLinksClient.NewListPager method.

type PrivateLinksClientListResponse 

type PrivateLinksClientListResponse struct {
	PrivateLinkResourceListResult
}

PrivateLinksClientListResponse contains the response from method PrivateLinksClient.NewListPager.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The provisioning state of the application. 

const (
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateCreating  ProvisioningState = "Creating"
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	ProvisioningStateUpdating  ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type PublicNetworkAccess 

type PublicNetworkAccess string

PublicNetworkAccess - Whether requests from the public network are allowed. 

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

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SystemAssignedServiceIdentity 

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

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string `json:"tenantId,omitempty" azure:"ro"`
}

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

func (SystemAssignedServiceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemAssignedServiceIdentity.

func (*SystemAssignedServiceIdentity) UnmarshalJSON 

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.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time `json:"createdAt,omitempty"`

	// The identity that created the resource.
	CreatedBy *string `json:"createdBy,omitempty"`

	// The type of identity that created the resource.
	CreatedByType *CreatedByType `json:"createdByType,omitempty"`

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time `json:"lastModifiedAt,omitempty"`

	// The identity that last modified the resource.
	LastModifiedBy *string `json:"lastModifiedBy,omitempty"`

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType `json:"lastModifiedByType,omitempty"`
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TrackedResource 

type TrackedResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

TrackedResource - The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'

func (TrackedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

Source Files

View all Source files

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.