armiotoperations

package module
v0.0.0-...-45adee8 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2024 License: MIT Imports: 14 Imported by: 0

README

Azure IoTOperations Module for Go

The armiotoperations module provides operations for working with Azure IoTOperations.

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 IoTOperations module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations

Authorization

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

Fakes

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

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

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the IoTOperations 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 ActionType 

type ActionType string

ActionType - Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	// ActionTypeInternal - Actions are for internal-only APIs.
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type AdvancedSettings 

type AdvancedSettings struct {
	// Configurations related to All Clients.
	Clients *ClientConfig

	// The setting to enable or disable encryption of internal Traffic.
	EncryptInternalTraffic *OperationalMode

	// Certificate rotation and private key configuration.
	InternalCerts *CertManagerCertOptions
}

AdvancedSettings - Broker Advanced Settings

func (AdvancedSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AdvancedSettings.

func (*AdvancedSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AdvancedSettings.

type AuthorizationConfig 

type AuthorizationConfig struct {
	// Enable caching of the authorization rules.
	Cache *OperationalMode

	// The authorization rules to follow. If no rule is set, but Authorization Resource is used that would mean DenyAll.
	Rules []*AuthorizationRule
}

AuthorizationConfig - Broker AuthorizationConfig properties

func (AuthorizationConfig) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AuthorizationConfig.

func (*AuthorizationConfig) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AuthorizationConfig.

type AuthorizationRule 

type AuthorizationRule struct {
	// REQUIRED; Give access to Broker methods and topics.
	BrokerResources []*BrokerResourceRule

	// REQUIRED; Give access to clients based on the following properties.
	Principals *PrincipalDefinition

	// Give access to state store resources.
	StateStoreResources []*StateStoreResourceRule
}

AuthorizationRule - AuthorizationConfig Rule Properties

func (AuthorizationRule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AuthorizationRule.

func (*AuthorizationRule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AuthorizationRule.

type BackendChain 

type BackendChain struct {
	// REQUIRED; The desired number of physical backend partitions.
	Partitions *int32

	// REQUIRED; The desired numbers of backend replicas (pods) in a physical partition.
	RedundancyFactor *int32

	// Number of logical backend workers per replica (pod).
	Workers *int32
}

BackendChain - Desired properties of the backend instances of the broker

func (BackendChain) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackendChain.

func (*BackendChain) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackendChain.

type BatchingConfiguration 

type BatchingConfiguration struct {
	// Batching latency in seconds.
	LatencySeconds *int32

	// Maximum number of messages in a batch.
	MaxMessages *int32
}

BatchingConfiguration - Batching configuration

func (BatchingConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BatchingConfiguration.

func (*BatchingConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BatchingConfiguration.

type BrokerAuthenticationClient 

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

BrokerAuthenticationClient contains the methods for the BrokerAuthentication group. Don't use this type directly, use NewBrokerAuthenticationClient() instead.

func NewBrokerAuthenticationClient 

func NewBrokerAuthenticationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BrokerAuthenticationClient, error)

NewBrokerAuthenticationClient creates a new instance of BrokerAuthenticationClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BrokerAuthenticationClient) BeginCreateOrUpdate 

func (client *BrokerAuthenticationClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, authenticationName string, resource BrokerAuthenticationResource, options *BrokerAuthenticationClientBeginCreateOrUpdateOptions) (*runtime.Poller[BrokerAuthenticationClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a BrokerAuthenticationResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • authenticationName - Name of Instance broker authentication resource
  • resource - Resource create parameters.
  • options - BrokerAuthenticationClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerAuthenticationClient.BeginCreateOrUpdate method.
Example (BrokerAuthenticationCreateOrUpdate)

Generated from example definition: 2024-11-01/BrokerAuthentication_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthenticationClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerAuthenticationResource{
		Properties: &armiotoperations.BrokerAuthenticationProperties{
			AuthenticationMethods: []*armiotoperations.BrokerAuthenticatorMethods{
				{
					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodCustom),
					CustomSettings: &armiotoperations.BrokerAuthenticatorMethodCustom{
						Auth: &armiotoperations.BrokerAuthenticatorCustomAuth{
							X509: &armiotoperations.X509ManualCertificate{
								SecretRef: to.Ptr("secret-name"),
							},
						},
						CaCertConfigMap: to.Ptr("pdecudefqyolvncbus"),
						Endpoint:        to.Ptr("https://www.example.com"),
						Headers: map[string]*string{
							"key8518": to.Ptr("bwityjy"),
						},
					},
					ServiceAccountTokenSettings: &armiotoperations.BrokerAuthenticatorMethodSat{
						Audiences: []*string{
							to.Ptr("jqyhyqatuydg"),
						},
					},
					X509Settings: &armiotoperations.BrokerAuthenticatorMethodX509{
						AuthorizationAttributes: map[string]*armiotoperations.BrokerAuthenticatorMethodX509Attributes{
							"key3384": {
								Attributes: map[string]*string{
									"key186": to.Ptr("ucpajramsz"),
								},
								Subject: to.Ptr("jpgwctfeixitptfgfnqhua"),
							},
						},
						TrustedClientCaCert: to.Ptr("vlctsqddl"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerAuthenticationClientCreateOrUpdateResponse{
	// 	BrokerAuthenticationResource: &armiotoperations.BrokerAuthenticationResource{
	// 		Properties: &armiotoperations.BrokerAuthenticationProperties{
	// 			AuthenticationMethods: []*armiotoperations.BrokerAuthenticatorMethods{
	// 				{
	// 					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodCustom),
	// 					CustomSettings: &armiotoperations.BrokerAuthenticatorMethodCustom{
	// 						Auth: &armiotoperations.BrokerAuthenticatorCustomAuth{
	// 							X509: &armiotoperations.X509ManualCertificate{
	// 								SecretRef: to.Ptr("secret-name"),
	// 							},
	// 						},
	// 						CaCertConfigMap: to.Ptr("pdecudefqyolvncbus"),
	// 						Endpoint: to.Ptr("https://www.example.com"),
	// 						Headers: map[string]*string{
	// 							"key8518": to.Ptr("bwityjy"),
	// 						},
	// 					},
	// 					ServiceAccountTokenSettings: &armiotoperations.BrokerAuthenticatorMethodSat{
	// 						Audiences: []*string{
	// 							to.Ptr("jqyhyqatuydg"),
	// 						},
	// 					},
	// 					X509Settings: &armiotoperations.BrokerAuthenticatorMethodX509{
	// 						AuthorizationAttributes: map[string]*armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 							"key3384": &armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 								Attributes: map[string]*string{
	// 									"key186": to.Ptr("ucpajramsz"),
	// 								},
	// 								Subject: to.Ptr("jpgwctfeixitptfgfnqhua"),
	// 							},
	// 						},
	// 						TrustedClientCaCert: to.Ptr("vlctsqddl"),
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authentications/resource-name123"),
	// 		Name: to.Ptr("lwucizfvtsdpx"),
	// 		Type: to.Ptr("kvtilkgcxanlfozrd"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerAuthenticationCreateOrUpdateComplex)

Generated from example definition: 2024-11-01/BrokerAuthentication_CreateOrUpdate_Complex.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthenticationClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerAuthenticationResource{
		Properties: &armiotoperations.BrokerAuthenticationProperties{
			AuthenticationMethods: []*armiotoperations.BrokerAuthenticatorMethods{
				{
					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodServiceAccountToken),
					ServiceAccountTokenSettings: &armiotoperations.BrokerAuthenticatorMethodSat{
						Audiences: []*string{
							to.Ptr("aio-internal"),
						},
					},
				},
				{
					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodX509),
					X509Settings: &armiotoperations.BrokerAuthenticatorMethodX509{
						TrustedClientCaCert: to.Ptr("my-ca"),
						AuthorizationAttributes: map[string]*armiotoperations.BrokerAuthenticatorMethodX509Attributes{
							"root": {
								Subject: to.Ptr("CN = Contoso Root CA Cert, OU = Engineering, C = US"),
								Attributes: map[string]*string{
									"organization": to.Ptr("contoso"),
								},
							},
							"intermediate": {
								Subject: to.Ptr("CN = Contoso Intermediate CA"),
								Attributes: map[string]*string{
									"city": to.Ptr("seattle"),
									"foo":  to.Ptr("bar"),
								},
							},
							"smart-fan": {
								Subject: to.Ptr("CN = smart-fan"),
								Attributes: map[string]*string{
									"building": to.Ptr("17"),
								},
							},
						},
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerAuthenticationClientCreateOrUpdateResponse{
	// 	BrokerAuthenticationResource: &armiotoperations.BrokerAuthenticationResource{
	// 		Properties: &armiotoperations.BrokerAuthenticationProperties{
	// 			AuthenticationMethods: []*armiotoperations.BrokerAuthenticatorMethods{
	// 				{
	// 					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodServiceAccountToken),
	// 					ServiceAccountTokenSettings: &armiotoperations.BrokerAuthenticatorMethodSat{
	// 						Audiences: []*string{
	// 							to.Ptr("aio-internal"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodX509),
	// 					X509Settings: &armiotoperations.BrokerAuthenticatorMethodX509{
	// 						TrustedClientCaCert: to.Ptr("my-ca"),
	// 						AuthorizationAttributes: map[string]*armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 							"root": &armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 								Subject: to.Ptr("CN = Contoso Root CA Cert, OU = Engineering, C = US"),
	// 								Attributes: map[string]*string{
	// 									"organization": to.Ptr("contoso"),
	// 								},
	// 							},
	// 							"intermediate": &armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 								Subject: to.Ptr("CN = Contoso Intermediate CA"),
	// 								Attributes: map[string]*string{
	// 									"city": to.Ptr("seattle"),
	// 									"foo": to.Ptr("bar"),
	// 								},
	// 							},
	// 							"smart-fan": &armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 								Subject: to.Ptr("CN = smart-fan"),
	// 								Attributes: map[string]*string{
	// 									"building": to.Ptr("17"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authentications/resource-name123"),
	// 		Name: to.Ptr("lwucizfvtsdpx"),
	// 		Type: to.Ptr("kvtilkgcxanlfozrd"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerAuthenticationClient) BeginDelete 

func (client *BrokerAuthenticationClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, authenticationName string, options *BrokerAuthenticationClientBeginDeleteOptions) (*runtime.Poller[BrokerAuthenticationClientDeleteResponse], error)

BeginDelete - Delete a BrokerAuthenticationResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • authenticationName - Name of Instance broker authentication resource
  • options - BrokerAuthenticationClientBeginDeleteOptions contains the optional parameters for the BrokerAuthenticationClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/BrokerAuthentication_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthenticationClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 (*BrokerAuthenticationClient) Get 

func (client *BrokerAuthenticationClient) Get(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, authenticationName string, options *BrokerAuthenticationClientGetOptions) (BrokerAuthenticationClientGetResponse, error)

Get - Get a BrokerAuthenticationResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • authenticationName - Name of Instance broker authentication resource
  • options - BrokerAuthenticationClientGetOptions contains the optional parameters for the BrokerAuthenticationClient.Get method.
Example

Generated from example definition: 2024-11-01/BrokerAuthentication_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBrokerAuthenticationClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerAuthenticationClientGetResponse{
	// 	BrokerAuthenticationResource: &armiotoperations.BrokerAuthenticationResource{
	// 		Properties: &armiotoperations.BrokerAuthenticationProperties{
	// 			AuthenticationMethods: []*armiotoperations.BrokerAuthenticatorMethods{
	// 				{
	// 					Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodCustom),
	// 					CustomSettings: &armiotoperations.BrokerAuthenticatorMethodCustom{
	// 						Auth: &armiotoperations.BrokerAuthenticatorCustomAuth{
	// 							X509: &armiotoperations.X509ManualCertificate{
	// 								SecretRef: to.Ptr("secret-name"),
	// 							},
	// 						},
	// 						CaCertConfigMap: to.Ptr("pdecudefqyolvncbus"),
	// 						Endpoint: to.Ptr("https://www.example.com"),
	// 						Headers: map[string]*string{
	// 							"key8518": to.Ptr("bwityjy"),
	// 						},
	// 					},
	// 					ServiceAccountTokenSettings: &armiotoperations.BrokerAuthenticatorMethodSat{
	// 						Audiences: []*string{
	// 							to.Ptr("jqyhyqatuydg"),
	// 						},
	// 					},
	// 					X509Settings: &armiotoperations.BrokerAuthenticatorMethodX509{
	// 						AuthorizationAttributes: map[string]*armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 							"key3384": &armiotoperations.BrokerAuthenticatorMethodX509Attributes{
	// 								Attributes: map[string]*string{
	// 									"key186": to.Ptr("ucpajramsz"),
	// 								},
	// 								Subject: to.Ptr("jpgwctfeixitptfgfnqhua"),
	// 							},
	// 						},
	// 						TrustedClientCaCert: to.Ptr("vlctsqddl"),
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authentications/resource-name123"),
	// 		Name: to.Ptr("lwucizfvtsdpx"),
	// 		Type: to.Ptr("kvtilkgcxanlfozrd"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerAuthenticationClient) NewListByResourceGroupPager 

func (client *BrokerAuthenticationClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, brokerName string, options *BrokerAuthenticationClientListByResourceGroupOptions) *runtime.Pager[BrokerAuthenticationClientListByResourceGroupResponse]

NewListByResourceGroupPager - List BrokerAuthenticationResource resources by BrokerResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • options - BrokerAuthenticationClientListByResourceGroupOptions contains the optional parameters for the BrokerAuthenticationClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/BrokerAuthentication_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBrokerAuthenticationClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerAuthenticationClientListByResourceGroupResponse{
		// 	BrokerAuthenticationResourceListResult: armiotoperations.BrokerAuthenticationResourceListResult{
		// 		Value: []*armiotoperations.BrokerAuthenticationResource{
		// 			{
		// 				Properties: &armiotoperations.BrokerAuthenticationProperties{
		// 					AuthenticationMethods: []*armiotoperations.BrokerAuthenticatorMethods{
		// 						{
		// 							Method: to.Ptr(armiotoperations.BrokerAuthenticationMethodCustom),
		// 							CustomSettings: &armiotoperations.BrokerAuthenticatorMethodCustom{
		// 								Auth: &armiotoperations.BrokerAuthenticatorCustomAuth{
		// 									X509: &armiotoperations.X509ManualCertificate{
		// 										SecretRef: to.Ptr("secret-name"),
		// 									},
		// 								},
		// 								CaCertConfigMap: to.Ptr("pdecudefqyolvncbus"),
		// 								Endpoint: to.Ptr("https://www.example.com"),
		// 								Headers: map[string]*string{
		// 									"key8518": to.Ptr("bwityjy"),
		// 								},
		// 							},
		// 							ServiceAccountTokenSettings: &armiotoperations.BrokerAuthenticatorMethodSat{
		// 								Audiences: []*string{
		// 									to.Ptr("jqyhyqatuydg"),
		// 								},
		// 							},
		// 							X509Settings: &armiotoperations.BrokerAuthenticatorMethodX509{
		// 								AuthorizationAttributes: map[string]*armiotoperations.BrokerAuthenticatorMethodX509Attributes{
		// 									"key3384": &armiotoperations.BrokerAuthenticatorMethodX509Attributes{
		// 										Attributes: map[string]*string{
		// 											"key186": to.Ptr("ucpajramsz"),
		// 										},
		// 										Subject: to.Ptr("jpgwctfeixitptfgfnqhua"),
		// 									},
		// 								},
		// 								TrustedClientCaCert: to.Ptr("vlctsqddl"),
		// 							},
		// 						},
		// 					},
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authentications/resource-name123"),
		// 				Name: to.Ptr("lwucizfvtsdpx"),
		// 				Type: to.Ptr("kvtilkgcxanlfozrd"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type BrokerAuthenticationClientBeginCreateOrUpdateOptions 

type BrokerAuthenticationClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerAuthenticationClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerAuthenticationClient.BeginCreateOrUpdate method.

type BrokerAuthenticationClientBeginDeleteOptions 

type BrokerAuthenticationClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerAuthenticationClientBeginDeleteOptions contains the optional parameters for the BrokerAuthenticationClient.BeginDelete method.

type BrokerAuthenticationClientCreateOrUpdateResponse 

type BrokerAuthenticationClientCreateOrUpdateResponse struct {
	// Instance broker authentication resource
	BrokerAuthenticationResource
}

BrokerAuthenticationClientCreateOrUpdateResponse contains the response from method BrokerAuthenticationClient.BeginCreateOrUpdate.

type BrokerAuthenticationClientDeleteResponse 

type BrokerAuthenticationClientDeleteResponse struct {
}

BrokerAuthenticationClientDeleteResponse contains the response from method BrokerAuthenticationClient.BeginDelete.

type BrokerAuthenticationClientGetOptions 

type BrokerAuthenticationClientGetOptions struct {
}

BrokerAuthenticationClientGetOptions contains the optional parameters for the BrokerAuthenticationClient.Get method.

type BrokerAuthenticationClientGetResponse 

type BrokerAuthenticationClientGetResponse struct {
	// Instance broker authentication resource
	BrokerAuthenticationResource
}

BrokerAuthenticationClientGetResponse contains the response from method BrokerAuthenticationClient.Get.

type BrokerAuthenticationClientListByResourceGroupOptions 

type BrokerAuthenticationClientListByResourceGroupOptions struct {
}

BrokerAuthenticationClientListByResourceGroupOptions contains the optional parameters for the BrokerAuthenticationClient.NewListByResourceGroupPager method.

type BrokerAuthenticationClientListByResourceGroupResponse 

type BrokerAuthenticationClientListByResourceGroupResponse struct {
	// The response of a BrokerAuthenticationResource list operation.
	BrokerAuthenticationResourceListResult
}

BrokerAuthenticationClientListByResourceGroupResponse contains the response from method BrokerAuthenticationClient.NewListByResourceGroupPager.

type BrokerAuthenticationMethod 

type BrokerAuthenticationMethod string

BrokerAuthenticationMethod - Broker Authentication Mode 

const (
	// BrokerAuthenticationMethodCustom - Custom authentication configuration.
	BrokerAuthenticationMethodCustom BrokerAuthenticationMethod = "Custom"
	// BrokerAuthenticationMethodServiceAccountToken - ServiceAccountToken authentication configuration.
	BrokerAuthenticationMethodServiceAccountToken BrokerAuthenticationMethod = "ServiceAccountToken"
	// BrokerAuthenticationMethodX509 - X.509 authentication configuration.
	BrokerAuthenticationMethodX509 BrokerAuthenticationMethod = "X509"
)

func PossibleBrokerAuthenticationMethodValues 

func PossibleBrokerAuthenticationMethodValues() []BrokerAuthenticationMethod

PossibleBrokerAuthenticationMethodValues returns the possible values for the BrokerAuthenticationMethod const type.

type BrokerAuthenticationProperties 

type BrokerAuthenticationProperties struct {
	// REQUIRED; Defines a set of Broker authentication methods to be used on `BrokerListeners`. For each array element one authenticator
	// type supported.
	AuthenticationMethods []*BrokerAuthenticatorMethods

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

BrokerAuthenticationProperties - BrokerAuthentication Resource properties

func (BrokerAuthenticationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticationProperties.

func (*BrokerAuthenticationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticationProperties.

type BrokerAuthenticationResource 

type BrokerAuthenticationResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *BrokerAuthenticationProperties

	// READ-ONLY; Name of Instance broker authentication resource
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

BrokerAuthenticationResource - Instance broker authentication resource

func (BrokerAuthenticationResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticationResource.

func (*BrokerAuthenticationResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticationResource.

type BrokerAuthenticationResourceListResult 

type BrokerAuthenticationResourceListResult struct {
	// REQUIRED; The BrokerAuthenticationResource items on this page
	Value []*BrokerAuthenticationResource

	// The link to the next page of items
	NextLink *string
}

BrokerAuthenticationResourceListResult - The response of a BrokerAuthenticationResource list operation.

func (BrokerAuthenticationResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticationResourceListResult.

func (*BrokerAuthenticationResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticationResourceListResult.

type BrokerAuthenticatorCustomAuth 

type BrokerAuthenticatorCustomAuth struct {
	// REQUIRED; X509 Custom Auth type details.
	X509 *X509ManualCertificate
}

BrokerAuthenticatorCustomAuth - Custom Authentication properties

func (BrokerAuthenticatorCustomAuth) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticatorCustomAuth.

func (*BrokerAuthenticatorCustomAuth) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticatorCustomAuth.

type BrokerAuthenticatorMethodCustom 

type BrokerAuthenticatorMethodCustom struct {
	// REQUIRED; Endpoint of the custom authentication server. Must be an HTTPS endpoint.
	Endpoint *string

	// Optional authentication needed for authenticating with the custom authentication server.
	Auth *BrokerAuthenticatorCustomAuth

	// Optional CA certificate for validating the custom authentication server's certificate.
	CaCertConfigMap *string

	// Additional HTTP headers to pass to the custom authentication server.
	Headers map[string]*string
}

BrokerAuthenticatorMethodCustom - Custom method for BrokerAuthentication

func (BrokerAuthenticatorMethodCustom) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticatorMethodCustom.

func (*BrokerAuthenticatorMethodCustom) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticatorMethodCustom.

type BrokerAuthenticatorMethodSat 

type BrokerAuthenticatorMethodSat struct {
	// REQUIRED; List of allowed audience.
	Audiences []*string
}

BrokerAuthenticatorMethodSat - Service Account Token for BrokerAuthentication

func (BrokerAuthenticatorMethodSat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticatorMethodSat.

func (*BrokerAuthenticatorMethodSat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticatorMethodSat.

type BrokerAuthenticatorMethodX509 

type BrokerAuthenticatorMethodX509 struct {
	// X509 authorization attributes properties.
	AuthorizationAttributes map[string]*BrokerAuthenticatorMethodX509Attributes

	// Name of the trusted client ca cert resource.
	TrustedClientCaCert *string
}

BrokerAuthenticatorMethodX509 - X509 for BrokerAuthentication.

func (BrokerAuthenticatorMethodX509) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticatorMethodX509.

func (*BrokerAuthenticatorMethodX509) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticatorMethodX509.

type BrokerAuthenticatorMethodX509Attributes 

type BrokerAuthenticatorMethodX509Attributes struct {
	// REQUIRED; Attributes object.
	Attributes map[string]*string

	// REQUIRED; Subject of the X509 attribute.
	Subject *string
}

BrokerAuthenticatorMethodX509Attributes properties.

func (BrokerAuthenticatorMethodX509Attributes) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticatorMethodX509Attributes.

func (*BrokerAuthenticatorMethodX509Attributes) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticatorMethodX509Attributes.

type BrokerAuthenticatorMethods 

type BrokerAuthenticatorMethods struct {
	// REQUIRED; Custom authentication configuration.
	Method *BrokerAuthenticationMethod

	// Custom authentication configuration.
	CustomSettings *BrokerAuthenticatorMethodCustom

	// ServiceAccountToken authentication configuration.
	ServiceAccountTokenSettings *BrokerAuthenticatorMethodSat

	// X.509 authentication configuration.
	X509Settings *BrokerAuthenticatorMethodX509
}

BrokerAuthenticatorMethods - Set of broker authentication policies. Only one method is supported for each entry.

func (BrokerAuthenticatorMethods) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthenticatorMethods.

func (*BrokerAuthenticatorMethods) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthenticatorMethods.

type BrokerAuthorizationClient 

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

BrokerAuthorizationClient contains the methods for the BrokerAuthorization group. Don't use this type directly, use NewBrokerAuthorizationClient() instead.

func NewBrokerAuthorizationClient 

func NewBrokerAuthorizationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BrokerAuthorizationClient, error)

NewBrokerAuthorizationClient creates a new instance of BrokerAuthorizationClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BrokerAuthorizationClient) BeginCreateOrUpdate 

func (client *BrokerAuthorizationClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, authorizationName string, resource BrokerAuthorizationResource, options *BrokerAuthorizationClientBeginCreateOrUpdateOptions) (*runtime.Poller[BrokerAuthorizationClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a BrokerAuthorizationResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • authorizationName - Name of Instance broker authorization resource
  • resource - Resource create parameters.
  • options - BrokerAuthorizationClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerAuthorizationClient.BeginCreateOrUpdate method.
Example (BrokerAuthorizationCreateOrUpdate)

Generated from example definition: 2024-11-01/BrokerAuthorization_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthorizationClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerAuthorizationResource{
		Properties: &armiotoperations.BrokerAuthorizationProperties{
			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
				Rules: []*armiotoperations.AuthorizationRule{
					{
						BrokerResources: []*armiotoperations.BrokerResourceRule{
							{
								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
								ClientIDs: []*string{
									to.Ptr("nlc"),
								},
								Topics: []*string{
									to.Ptr("wvuca"),
								},
							},
						},
						Principals: &armiotoperations.PrincipalDefinition{
							Attributes: []map[string]*string{
								{
									"key5526": to.Ptr("nydhzdhbldygqcn"),
								},
							},
							ClientIDs: []*string{
								to.Ptr("smopeaeddsygz"),
							},
							Usernames: []*string{
								to.Ptr("iozngyqndrteikszkbasinzdjtm"),
							},
						},
						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
							{
								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
								Keys: []*string{
									to.Ptr("tkounsqtwvzyaklxjqoerpu"),
								},
								Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsRead),
							},
						},
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerAuthorizationClientCreateOrUpdateResponse{
	// 	BrokerAuthorizationResource: &armiotoperations.BrokerAuthorizationResource{
	// 		Properties: &armiotoperations.BrokerAuthorizationProperties{
	// 			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
	// 				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				Rules: []*armiotoperations.AuthorizationRule{
	// 					{
	// 						BrokerResources: []*armiotoperations.BrokerResourceRule{
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
	// 								ClientIDs: []*string{
	// 									to.Ptr("nlc"),
	// 								},
	// 								Topics: []*string{
	// 									to.Ptr("wvuca"),
	// 								},
	// 							},
	// 						},
	// 						Principals: &armiotoperations.PrincipalDefinition{
	// 							Attributes: []map[string]*string{
	// 								map[string]*string{
	// 									"key5526": to.Ptr("nydhzdhbldygqcn"),
	// 								},
	// 							},
	// 							ClientIDs: []*string{
	// 								to.Ptr("smopeaeddsygz"),
	// 							},
	// 							Usernames: []*string{
	// 								to.Ptr("iozngyqndrteikszkbasinzdjtm"),
	// 							},
	// 						},
	// 						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
	// 							{
	// 								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
	// 								Keys: []*string{
	// 									to.Ptr("tkounsqtwvzyaklxjqoerpu"),
	// 								},
	// 								Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsRead),
	// 							},
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authorizations/resource-name123"),
	// 		Name: to.Ptr("anqrqsvrjmlvzkrbuav"),
	// 		Type: to.Ptr("yjlsfarshqoxojvgmy"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerAuthorizationCreateOrUpdateComplex)

Generated from example definition: 2024-11-01/BrokerAuthorization_CreateOrUpdate_Complex.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthorizationClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerAuthorizationResource{
		Properties: &armiotoperations.BrokerAuthorizationProperties{
			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
				Rules: []*armiotoperations.AuthorizationRule{
					{
						Principals: &armiotoperations.PrincipalDefinition{
							Usernames: []*string{
								to.Ptr("temperature-sensor"),
								to.Ptr("humidity-sensor"),
							},
							Attributes: []map[string]*string{
								{
									"building":     to.Ptr("17"),
									"organization": to.Ptr("contoso"),
								},
							},
						},
						BrokerResources: []*armiotoperations.BrokerResourceRule{
							{
								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
								ClientIDs: []*string{
									to.Ptr("{principal.attributes.building}*"),
								},
							},
							{
								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsPublish),
								Topics: []*string{
									to.Ptr("sensors/{principal.attributes.building}/{principal.clientId}/telemetry/*"),
								},
							},
							{
								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsSubscribe),
								Topics: []*string{
									to.Ptr("commands/{principal.attributes.organization}"),
								},
							},
						},
						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
							{
								Method:  to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsRead),
								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
								Keys: []*string{
									to.Ptr("myreadkey"),
									to.Ptr("myotherkey?"),
									to.Ptr("mynumerickeysuffix[0-9]"),
									to.Ptr("clients:{principal.clientId}:*"),
								},
							},
							{
								Method:  to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsReadWrite),
								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesBinary),
								Keys: []*string{
									to.Ptr("MTE2IDEwMSAxMTUgMTE2"),
								},
							},
						},
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerAuthorizationClientCreateOrUpdateResponse{
	// 	BrokerAuthorizationResource: &armiotoperations.BrokerAuthorizationResource{
	// 		Properties: &armiotoperations.BrokerAuthorizationProperties{
	// 			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
	// 				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				Rules: []*armiotoperations.AuthorizationRule{
	// 					{
	// 						Principals: &armiotoperations.PrincipalDefinition{
	// 							Usernames: []*string{
	// 								to.Ptr("temperature-sensor"),
	// 								to.Ptr("humidity-sensor"),
	// 							},
	// 							Attributes: []map[string]*string{
	// 								map[string]*string{
	// 									"building": to.Ptr("17"),
	// 									"organization": to.Ptr("contoso"),
	// 								},
	// 							},
	// 						},
	// 						BrokerResources: []*armiotoperations.BrokerResourceRule{
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
	// 								ClientIDs: []*string{
	// 									to.Ptr("{principal.attributes.building}*"),
	// 								},
	// 							},
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsPublish),
	// 								Topics: []*string{
	// 									to.Ptr("sensors/{principal.attributes.building}/{principal.clientId}/telemetry/*"),
	// 								},
	// 							},
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsSubscribe),
	// 								Topics: []*string{
	// 									to.Ptr("commands/{principal.attributes.organization}"),
	// 								},
	// 							},
	// 						},
	// 						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
	// 							{
	// 								Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsRead),
	// 								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
	// 								Keys: []*string{
	// 									to.Ptr("myreadkey"),
	// 									to.Ptr("myotherkey?"),
	// 									to.Ptr("mynumerickeysuffix[0-9]"),
	// 									to.Ptr("clients:{principal.clientId}:*"),
	// 								},
	// 							},
	// 							{
	// 								Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsReadWrite),
	// 								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesBinary),
	// 								Keys: []*string{
	// 									to.Ptr("MTE2IDEwMSAxMTUgMTE2"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authorizations/resource-name123"),
	// 		Name: to.Ptr("anqrqsvrjmlvzkrbuav"),
	// 		Type: to.Ptr("yjlsfarshqoxojvgmy"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerAuthorizationCreateOrUpdateSimple)

Generated from example definition: 2024-11-01/BrokerAuthorization_CreateOrUpdate_Simple.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthorizationClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerAuthorizationResource{
		Properties: &armiotoperations.BrokerAuthorizationProperties{
			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
				Rules: []*armiotoperations.AuthorizationRule{
					{
						Principals: &armiotoperations.PrincipalDefinition{
							ClientIDs: []*string{
								to.Ptr("my-client-id"),
							},
							Attributes: []map[string]*string{
								{
									"floor": to.Ptr("floor1"),
									"site":  to.Ptr("site1"),
								},
							},
						},
						BrokerResources: []*armiotoperations.BrokerResourceRule{
							{
								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
							},
							{
								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsSubscribe),
								Topics: []*string{
									to.Ptr("topic"),
									to.Ptr("topic/with/wildcard/#"),
								},
							},
						},
						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
							{
								Method:  to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsReadWrite),
								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
								Keys: []*string{
									to.Ptr("*"),
								},
							},
						},
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerAuthorizationClientCreateOrUpdateResponse{
	// 	BrokerAuthorizationResource: &armiotoperations.BrokerAuthorizationResource{
	// 		Properties: &armiotoperations.BrokerAuthorizationProperties{
	// 			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
	// 				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				Rules: []*armiotoperations.AuthorizationRule{
	// 					{
	// 						Principals: &armiotoperations.PrincipalDefinition{
	// 							ClientIDs: []*string{
	// 								to.Ptr("my-client-id"),
	// 							},
	// 							Attributes: []map[string]*string{
	// 								map[string]*string{
	// 									"floor": to.Ptr("floor1"),
	// 									"site": to.Ptr("site1"),
	// 								},
	// 							},
	// 						},
	// 						BrokerResources: []*armiotoperations.BrokerResourceRule{
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
	// 							},
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsSubscribe),
	// 								Topics: []*string{
	// 									to.Ptr("topic"),
	// 									to.Ptr("topic/with/wildcard/#"),
	// 								},
	// 							},
	// 						},
	// 						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
	// 							{
	// 								Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsReadWrite),
	// 								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
	// 								Keys: []*string{
	// 									to.Ptr("*"),
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authorizations/resource-name123"),
	// 		Name: to.Ptr("anqrqsvrjmlvzkrbuav"),
	// 		Type: to.Ptr("yjlsfarshqoxojvgmy"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerAuthorizationClient) BeginDelete 

func (client *BrokerAuthorizationClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, authorizationName string, options *BrokerAuthorizationClientBeginDeleteOptions) (*runtime.Poller[BrokerAuthorizationClientDeleteResponse], error)

BeginDelete - Delete a BrokerAuthorizationResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • authorizationName - Name of Instance broker authorization resource
  • options - BrokerAuthorizationClientBeginDeleteOptions contains the optional parameters for the BrokerAuthorizationClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/BrokerAuthorization_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerAuthorizationClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 (*BrokerAuthorizationClient) Get 

func (client *BrokerAuthorizationClient) Get(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, authorizationName string, options *BrokerAuthorizationClientGetOptions) (BrokerAuthorizationClientGetResponse, error)

Get - Get a BrokerAuthorizationResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • authorizationName - Name of Instance broker authorization resource
  • options - BrokerAuthorizationClientGetOptions contains the optional parameters for the BrokerAuthorizationClient.Get method.
Example

Generated from example definition: 2024-11-01/BrokerAuthorization_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBrokerAuthorizationClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerAuthorizationClientGetResponse{
	// 	BrokerAuthorizationResource: &armiotoperations.BrokerAuthorizationResource{
	// 		Properties: &armiotoperations.BrokerAuthorizationProperties{
	// 			AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
	// 				Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				Rules: []*armiotoperations.AuthorizationRule{
	// 					{
	// 						BrokerResources: []*armiotoperations.BrokerResourceRule{
	// 							{
	// 								Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
	// 								ClientIDs: []*string{
	// 									to.Ptr("nlc"),
	// 								},
	// 								Topics: []*string{
	// 									to.Ptr("wvuca"),
	// 								},
	// 							},
	// 						},
	// 						Principals: &armiotoperations.PrincipalDefinition{
	// 							Attributes: []map[string]*string{
	// 								map[string]*string{
	// 									"key5526": to.Ptr("nydhzdhbldygqcn"),
	// 								},
	// 							},
	// 							ClientIDs: []*string{
	// 								to.Ptr("smopeaeddsygz"),
	// 							},
	// 							Usernames: []*string{
	// 								to.Ptr("iozngyqndrteikszkbasinzdjtm"),
	// 							},
	// 						},
	// 						StateStoreResources: []*armiotoperations.StateStoreResourceRule{
	// 							{
	// 								KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
	// 								Keys: []*string{
	// 									to.Ptr("tkounsqtwvzyaklxjqoerpu"),
	// 								},
	// 								Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsRead),
	// 							},
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authorizations/resource-name123"),
	// 		Name: to.Ptr("anqrqsvrjmlvzkrbuav"),
	// 		Type: to.Ptr("yjlsfarshqoxojvgmy"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerAuthorizationClient) NewListByResourceGroupPager 

func (client *BrokerAuthorizationClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, brokerName string, options *BrokerAuthorizationClientListByResourceGroupOptions) *runtime.Pager[BrokerAuthorizationClientListByResourceGroupResponse]

NewListByResourceGroupPager - List BrokerAuthorizationResource resources by BrokerResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • options - BrokerAuthorizationClientListByResourceGroupOptions contains the optional parameters for the BrokerAuthorizationClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/BrokerAuthorization_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBrokerAuthorizationClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerAuthorizationClientListByResourceGroupResponse{
		// 	BrokerAuthorizationResourceListResult: armiotoperations.BrokerAuthorizationResourceListResult{
		// 		Value: []*armiotoperations.BrokerAuthorizationResource{
		// 			{
		// 				Properties: &armiotoperations.BrokerAuthorizationProperties{
		// 					AuthorizationPolicies: &armiotoperations.AuthorizationConfig{
		// 						Cache: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 						Rules: []*armiotoperations.AuthorizationRule{
		// 							{
		// 								BrokerResources: []*armiotoperations.BrokerResourceRule{
		// 									{
		// 										Method: to.Ptr(armiotoperations.BrokerResourceDefinitionMethodsConnect),
		// 										ClientIDs: []*string{
		// 											to.Ptr("nlc"),
		// 										},
		// 										Topics: []*string{
		// 											to.Ptr("wvuca"),
		// 										},
		// 									},
		// 								},
		// 								Principals: &armiotoperations.PrincipalDefinition{
		// 									Attributes: []map[string]*string{
		// 										map[string]*string{
		// 											"key5526": to.Ptr("nydhzdhbldygqcn"),
		// 										},
		// 									},
		// 									ClientIDs: []*string{
		// 										to.Ptr("smopeaeddsygz"),
		// 									},
		// 									Usernames: []*string{
		// 										to.Ptr("iozngyqndrteikszkbasinzdjtm"),
		// 									},
		// 								},
		// 								StateStoreResources: []*armiotoperations.StateStoreResourceRule{
		// 									{
		// 										KeyType: to.Ptr(armiotoperations.StateStoreResourceKeyTypesPattern),
		// 										Keys: []*string{
		// 											to.Ptr("tkounsqtwvzyaklxjqoerpu"),
		// 										},
		// 										Method: to.Ptr(armiotoperations.StateStoreResourceDefinitionMethodsRead),
		// 									},
		// 								},
		// 							},
		// 						},
		// 					},
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/authorizations/resource-name123"),
		// 				Name: to.Ptr("anqrqsvrjmlvzkrbuav"),
		// 				Type: to.Ptr("yjlsfarshqoxojvgmy"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type BrokerAuthorizationClientBeginCreateOrUpdateOptions 

type BrokerAuthorizationClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerAuthorizationClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerAuthorizationClient.BeginCreateOrUpdate method.

type BrokerAuthorizationClientBeginDeleteOptions 

type BrokerAuthorizationClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerAuthorizationClientBeginDeleteOptions contains the optional parameters for the BrokerAuthorizationClient.BeginDelete method.

type BrokerAuthorizationClientCreateOrUpdateResponse 

type BrokerAuthorizationClientCreateOrUpdateResponse struct {
	// Instance broker authorizations resource
	BrokerAuthorizationResource
}

BrokerAuthorizationClientCreateOrUpdateResponse contains the response from method BrokerAuthorizationClient.BeginCreateOrUpdate.

type BrokerAuthorizationClientDeleteResponse 

type BrokerAuthorizationClientDeleteResponse struct {
}

BrokerAuthorizationClientDeleteResponse contains the response from method BrokerAuthorizationClient.BeginDelete.

type BrokerAuthorizationClientGetOptions 

type BrokerAuthorizationClientGetOptions struct {
}

BrokerAuthorizationClientGetOptions contains the optional parameters for the BrokerAuthorizationClient.Get method.

type BrokerAuthorizationClientGetResponse 

type BrokerAuthorizationClientGetResponse struct {
	// Instance broker authorizations resource
	BrokerAuthorizationResource
}

BrokerAuthorizationClientGetResponse contains the response from method BrokerAuthorizationClient.Get.

type BrokerAuthorizationClientListByResourceGroupOptions 

type BrokerAuthorizationClientListByResourceGroupOptions struct {
}

BrokerAuthorizationClientListByResourceGroupOptions contains the optional parameters for the BrokerAuthorizationClient.NewListByResourceGroupPager method.

type BrokerAuthorizationClientListByResourceGroupResponse 

type BrokerAuthorizationClientListByResourceGroupResponse struct {
	// The response of a BrokerAuthorizationResource list operation.
	BrokerAuthorizationResourceListResult
}

BrokerAuthorizationClientListByResourceGroupResponse contains the response from method BrokerAuthorizationClient.NewListByResourceGroupPager.

type BrokerAuthorizationProperties 

type BrokerAuthorizationProperties struct {
	// REQUIRED; The list of authorization policies supported by the Authorization Resource.
	AuthorizationPolicies *AuthorizationConfig

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

BrokerAuthorizationProperties - BrokerAuthorization Resource properties

func (BrokerAuthorizationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthorizationProperties.

func (*BrokerAuthorizationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthorizationProperties.

type BrokerAuthorizationResource 

type BrokerAuthorizationResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *BrokerAuthorizationProperties

	// READ-ONLY; Name of Instance broker authorization resource
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

BrokerAuthorizationResource - Instance broker authorizations resource

func (BrokerAuthorizationResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthorizationResource.

func (*BrokerAuthorizationResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthorizationResource.

type BrokerAuthorizationResourceListResult 

type BrokerAuthorizationResourceListResult struct {
	// REQUIRED; The BrokerAuthorizationResource items on this page
	Value []*BrokerAuthorizationResource

	// The link to the next page of items
	NextLink *string
}

BrokerAuthorizationResourceListResult - The response of a BrokerAuthorizationResource list operation.

func (BrokerAuthorizationResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerAuthorizationResourceListResult.

func (*BrokerAuthorizationResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerAuthorizationResourceListResult.

type BrokerClient 

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

BrokerClient contains the methods for the Broker group. Don't use this type directly, use NewBrokerClient() instead.

func NewBrokerClient 

func NewBrokerClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BrokerClient, error)

NewBrokerClient creates a new instance of BrokerClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BrokerClient) BeginCreateOrUpdate 

func (client *BrokerClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, resource BrokerResource, options *BrokerClientBeginCreateOrUpdateOptions) (*runtime.Poller[BrokerClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a BrokerResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • resource - Resource create parameters.
  • options - BrokerClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerClient.BeginCreateOrUpdate method.
Example (BrokerCreateOrUpdate)

Generated from example definition: 2024-11-01/Broker_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", armiotoperations.BrokerResource{
		Properties: &armiotoperations.BrokerProperties{
			Advanced: &armiotoperations.AdvancedSettings{
				Clients: &armiotoperations.ClientConfig{
					MaxSessionExpirySeconds: to.Ptr[int32](3859),
					MaxMessageExpirySeconds: to.Ptr[int32](3263),
					MaxPacketSizeBytes:      to.Ptr[int32](3029),
					SubscriberQueueLimit: &armiotoperations.SubscriberQueueLimit{
						Length:   to.Ptr[int64](6),
						Strategy: to.Ptr(armiotoperations.SubscriberMessageDropStrategyNone),
					},
					MaxReceiveMaximum:   to.Ptr[int32](2365),
					MaxKeepAliveSeconds: to.Ptr[int32](3744),
				},
				EncryptInternalTraffic: to.Ptr(armiotoperations.OperationalModeEnabled),
				InternalCerts: &armiotoperations.CertManagerCertOptions{
					Duration:    to.Ptr("bchrc"),
					RenewBefore: to.Ptr("xkafmpgjfifkwwrhkswtopdnne"),
					PrivateKey: &armiotoperations.CertManagerPrivateKey{
						Algorithm:      to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
						RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
					},
				},
			},
			Cardinality: &armiotoperations.Cardinality{
				BackendChain: &armiotoperations.BackendChain{
					Partitions:       to.Ptr[int32](11),
					RedundancyFactor: to.Ptr[int32](5),
					Workers:          to.Ptr[int32](15),
				},
				Frontend: &armiotoperations.Frontend{
					Replicas: to.Ptr[int32](2),
					Workers:  to.Ptr[int32](6),
				},
			},
			Diagnostics: &armiotoperations.BrokerDiagnostics{
				Logs: &armiotoperations.DiagnosticsLogs{
					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
				},
				Metrics: &armiotoperations.Metrics{
					PrometheusPort: to.Ptr[int32](7581),
				},
				SelfCheck: &armiotoperations.SelfCheck{
					Mode:            to.Ptr(armiotoperations.OperationalModeEnabled),
					IntervalSeconds: to.Ptr[int32](158),
					TimeoutSeconds:  to.Ptr[int32](14),
				},
				Traces: &armiotoperations.Traces{
					Mode:               to.Ptr(armiotoperations.OperationalModeEnabled),
					CacheSizeMegabytes: to.Ptr[int32](28),
					SelfTracing: &armiotoperations.SelfTracing{
						Mode:            to.Ptr(armiotoperations.OperationalModeEnabled),
						IntervalSeconds: to.Ptr[int32](22),
					},
					SpanChannelCapacity: to.Ptr[int32](1000),
				},
			},
			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
				MaxSize: to.Ptr("500M"),
				EphemeralVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
					VolumeName:       to.Ptr("c"),
					VolumeMode:       to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
					AccessModes: []*string{
						to.Ptr("nuluhigrbb"),
					},
					DataSource: &armiotoperations.LocalKubernetesReference{
						APIGroup: to.Ptr("npqapyksvvpkohujx"),
						Kind:     to.Ptr("wazgyb"),
						Name:     to.Ptr("cwhsgxxcxsyppoefm"),
					},
					DataSourceRef: &armiotoperations.KubernetesReference{
						APIGroup:  to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
						Kind:      to.Ptr("odynqzekfzsnawrctaxg"),
						Name:      to.Ptr("envszivbbmixbyddzg"),
						Namespace: to.Ptr("etcfzvxqd"),
					},
					Resources: &armiotoperations.VolumeClaimResourceRequirements{
						Limits: map[string]*string{
							"key2719": to.Ptr("hmphcrgctu"),
						},
						Requests: map[string]*string{
							"key2909": to.Ptr("txocprnyrsgvhfrg"),
						},
					},
					Selector: &armiotoperations.VolumeClaimSpecSelector{
						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
							{
								Key:      to.Ptr("e"),
								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
								Values: []*string{
									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
								},
							},
						},
						MatchLabels: map[string]*string{
							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
						},
					},
				},
				PersistentVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
					VolumeName:       to.Ptr("c"),
					VolumeMode:       to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
					AccessModes: []*string{
						to.Ptr("nuluhigrbb"),
					},
					DataSource: &armiotoperations.LocalKubernetesReference{
						APIGroup: to.Ptr("npqapyksvvpkohujx"),
						Kind:     to.Ptr("wazgyb"),
						Name:     to.Ptr("cwhsgxxcxsyppoefm"),
					},
					DataSourceRef: &armiotoperations.KubernetesReference{
						APIGroup:  to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
						Kind:      to.Ptr("odynqzekfzsnawrctaxg"),
						Name:      to.Ptr("envszivbbmixbyddzg"),
						Namespace: to.Ptr("etcfzvxqd"),
					},
					Resources: &armiotoperations.VolumeClaimResourceRequirements{
						Limits: map[string]*string{
							"key2719": to.Ptr("hmphcrgctu"),
						},
						Requests: map[string]*string{
							"key2909": to.Ptr("txocprnyrsgvhfrg"),
						},
					},
					Selector: &armiotoperations.VolumeClaimSpecSelector{
						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
							{
								Key:      to.Ptr("e"),
								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
								Values: []*string{
									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
								},
							},
						},
						MatchLabels: map[string]*string{
							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
						},
					},
				},
			},
			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
			},
			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerClientCreateOrUpdateResponse{
	// 	BrokerResource: &armiotoperations.BrokerResource{
	// 		Properties: &armiotoperations.BrokerProperties{
	// 			Advanced: &armiotoperations.AdvancedSettings{
	// 				Clients: &armiotoperations.ClientConfig{
	// 					MaxSessionExpirySeconds: to.Ptr[int32](3859),
	// 					MaxMessageExpirySeconds: to.Ptr[int32](3263),
	// 					MaxPacketSizeBytes: to.Ptr[int32](3029),
	// 					SubscriberQueueLimit: &armiotoperations.SubscriberQueueLimit{
	// 						Length: to.Ptr[int64](6),
	// 						Strategy: to.Ptr(armiotoperations.SubscriberMessageDropStrategyNone),
	// 					},
	// 					MaxReceiveMaximum: to.Ptr[int32](2365),
	// 					MaxKeepAliveSeconds: to.Ptr[int32](3744),
	// 				},
	// 				EncryptInternalTraffic: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				InternalCerts: &armiotoperations.CertManagerCertOptions{
	// 					Duration: to.Ptr("bchrc"),
	// 					RenewBefore: to.Ptr("xkafmpgjfifkwwrhkswtopdnne"),
	// 					PrivateKey: &armiotoperations.CertManagerPrivateKey{
	// 						Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
	// 						RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
	// 					},
	// 				},
	// 			},
	// 			Cardinality: &armiotoperations.Cardinality{
	// 				BackendChain: &armiotoperations.BackendChain{
	// 					Partitions: to.Ptr[int32](11),
	// 					RedundancyFactor: to.Ptr[int32](5),
	// 					Workers: to.Ptr[int32](15),
	// 				},
	// 				Frontend: &armiotoperations.Frontend{
	// 					Replicas: to.Ptr[int32](2),
	// 					Workers: to.Ptr[int32](6),
	// 				},
	// 			},
	// 			Diagnostics: &armiotoperations.BrokerDiagnostics{
	// 				Logs: &armiotoperations.DiagnosticsLogs{
	// 					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
	// 				},
	// 				Metrics: &armiotoperations.Metrics{
	// 					PrometheusPort: to.Ptr[int32](7581),
	// 				},
	// 				SelfCheck: &armiotoperations.SelfCheck{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					IntervalSeconds: to.Ptr[int32](158),
	// 					TimeoutSeconds: to.Ptr[int32](14),
	// 				},
	// 				Traces: &armiotoperations.Traces{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					CacheSizeMegabytes: to.Ptr[int32](28),
	// 					SelfTracing: &armiotoperations.SelfTracing{
	// 						Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 						IntervalSeconds: to.Ptr[int32](22),
	// 					},
	// 					SpanChannelCapacity: to.Ptr[int32](1000),
	// 				},
	// 			},
	// 			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
	// 				MaxSize: to.Ptr("500M"),
	// 				EphemeralVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 				PersistentVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
	// 				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			},
	// 			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123"),
	// 		Name: to.Ptr("dowrkel"),
	// 		Type: to.Ptr("xshjnsdgadygb"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerCreateOrUpdateComplex)

Generated from example definition: 2024-11-01/Broker_CreateOrUpdate_Complex.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", armiotoperations.BrokerResource{
		Properties: &armiotoperations.BrokerProperties{
			Cardinality: &armiotoperations.Cardinality{
				BackendChain: &armiotoperations.BackendChain{
					Partitions:       to.Ptr[int32](2),
					RedundancyFactor: to.Ptr[int32](2),
					Workers:          to.Ptr[int32](2),
				},
				Frontend: &armiotoperations.Frontend{
					Replicas: to.Ptr[int32](2),
					Workers:  to.Ptr[int32](2),
				},
			},
			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
				MaxSize: to.Ptr("50M"),
			},
			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
			},
			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileMedium),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerClientCreateOrUpdateResponse{
	// 	BrokerResource: &armiotoperations.BrokerResource{
	// 		Properties: &armiotoperations.BrokerProperties{
	// 			Cardinality: &armiotoperations.Cardinality{
	// 				BackendChain: &armiotoperations.BackendChain{
	// 					Partitions: to.Ptr[int32](2),
	// 					RedundancyFactor: to.Ptr[int32](2),
	// 					Workers: to.Ptr[int32](2),
	// 				},
	// 				Frontend: &armiotoperations.Frontend{
	// 					Replicas: to.Ptr[int32](2),
	// 					Workers: to.Ptr[int32](2),
	// 				},
	// 			},
	// 			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
	// 				MaxSize: to.Ptr("50M"),
	// 			},
	// 			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
	// 				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			},
	// 			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileMedium),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123"),
	// 		Name: to.Ptr("llptmlifnqqwairx"),
	// 		Type: to.Ptr("qwrfzxjfxvismlqvigot"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerCreateOrUpdateMinimal)

Generated from example definition: 2024-11-01/Broker_CreateOrUpdate_Minimal.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", armiotoperations.BrokerResource{
		Properties: &armiotoperations.BrokerProperties{
			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerClientCreateOrUpdateResponse{
	// 	BrokerResource: &armiotoperations.BrokerResource{
	// 		Properties: &armiotoperations.BrokerProperties{
	// 			Advanced: &armiotoperations.AdvancedSettings{
	// 				Clients: &armiotoperations.ClientConfig{
	// 					MaxSessionExpirySeconds: to.Ptr[int32](3859),
	// 					MaxMessageExpirySeconds: to.Ptr[int32](3263),
	// 					MaxPacketSizeBytes: to.Ptr[int32](3029),
	// 					SubscriberQueueLimit: &armiotoperations.SubscriberQueueLimit{
	// 						Length: to.Ptr[int64](6),
	// 						Strategy: to.Ptr(armiotoperations.SubscriberMessageDropStrategyNone),
	// 					},
	// 					MaxReceiveMaximum: to.Ptr[int32](2365),
	// 					MaxKeepAliveSeconds: to.Ptr[int32](3744),
	// 				},
	// 				EncryptInternalTraffic: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				InternalCerts: &armiotoperations.CertManagerCertOptions{
	// 					Duration: to.Ptr("bchrc"),
	// 					RenewBefore: to.Ptr("xkafmpgjfifkwwrhkswtopdnne"),
	// 					PrivateKey: &armiotoperations.CertManagerPrivateKey{
	// 						Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
	// 						RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
	// 					},
	// 				},
	// 			},
	// 			Cardinality: &armiotoperations.Cardinality{
	// 				BackendChain: &armiotoperations.BackendChain{
	// 					Partitions: to.Ptr[int32](11),
	// 					RedundancyFactor: to.Ptr[int32](5),
	// 					Workers: to.Ptr[int32](15),
	// 				},
	// 				Frontend: &armiotoperations.Frontend{
	// 					Replicas: to.Ptr[int32](2),
	// 					Workers: to.Ptr[int32](6),
	// 				},
	// 			},
	// 			Diagnostics: &armiotoperations.BrokerDiagnostics{
	// 				Logs: &armiotoperations.DiagnosticsLogs{
	// 					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
	// 				},
	// 				Metrics: &armiotoperations.Metrics{
	// 					PrometheusPort: to.Ptr[int32](7581),
	// 				},
	// 				SelfCheck: &armiotoperations.SelfCheck{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					IntervalSeconds: to.Ptr[int32](158),
	// 					TimeoutSeconds: to.Ptr[int32](14),
	// 				},
	// 				Traces: &armiotoperations.Traces{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					CacheSizeMegabytes: to.Ptr[int32](28),
	// 					SelfTracing: &armiotoperations.SelfTracing{
	// 						Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 						IntervalSeconds: to.Ptr[int32](22),
	// 					},
	// 					SpanChannelCapacity: to.Ptr[int32](1000),
	// 				},
	// 			},
	// 			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
	// 				MaxSize: to.Ptr("500M"),
	// 				EphemeralVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 				PersistentVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
	// 				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			},
	// 			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123"),
	// 		Name: to.Ptr("dowrkel"),
	// 		Type: to.Ptr("xshjnsdgadygb"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerCreateOrUpdateSimple)

Generated from example definition: 2024-11-01/Broker_CreateOrUpdate_Simple.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", armiotoperations.BrokerResource{
		Properties: &armiotoperations.BrokerProperties{
			Cardinality: &armiotoperations.Cardinality{
				BackendChain: &armiotoperations.BackendChain{
					Partitions:       to.Ptr[int32](2),
					RedundancyFactor: to.Ptr[int32](2),
					Workers:          to.Ptr[int32](2),
				},
				Frontend: &armiotoperations.Frontend{
					Replicas: to.Ptr[int32](2),
					Workers:  to.Ptr[int32](2),
				},
			},
			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
			},
			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileLow),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerClientCreateOrUpdateResponse{
	// 	BrokerResource: &armiotoperations.BrokerResource{
	// 		Properties: &armiotoperations.BrokerProperties{
	// 			Advanced: &armiotoperations.AdvancedSettings{
	// 				Clients: &armiotoperations.ClientConfig{
	// 					MaxSessionExpirySeconds: to.Ptr[int32](3859),
	// 					MaxMessageExpirySeconds: to.Ptr[int32](3263),
	// 					MaxPacketSizeBytes: to.Ptr[int32](3029),
	// 					SubscriberQueueLimit: &armiotoperations.SubscriberQueueLimit{
	// 						Length: to.Ptr[int64](6),
	// 						Strategy: to.Ptr(armiotoperations.SubscriberMessageDropStrategyNone),
	// 					},
	// 					MaxReceiveMaximum: to.Ptr[int32](2365),
	// 					MaxKeepAliveSeconds: to.Ptr[int32](3744),
	// 				},
	// 				EncryptInternalTraffic: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				InternalCerts: &armiotoperations.CertManagerCertOptions{
	// 					Duration: to.Ptr("bchrc"),
	// 					RenewBefore: to.Ptr("xkafmpgjfifkwwrhkswtopdnne"),
	// 					PrivateKey: &armiotoperations.CertManagerPrivateKey{
	// 						Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
	// 						RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
	// 					},
	// 				},
	// 			},
	// 			Cardinality: &armiotoperations.Cardinality{
	// 				BackendChain: &armiotoperations.BackendChain{
	// 					Partitions: to.Ptr[int32](11),
	// 					RedundancyFactor: to.Ptr[int32](5),
	// 					Workers: to.Ptr[int32](15),
	// 				},
	// 				Frontend: &armiotoperations.Frontend{
	// 					Replicas: to.Ptr[int32](2),
	// 					Workers: to.Ptr[int32](6),
	// 				},
	// 			},
	// 			Diagnostics: &armiotoperations.BrokerDiagnostics{
	// 				Logs: &armiotoperations.DiagnosticsLogs{
	// 					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
	// 				},
	// 				Metrics: &armiotoperations.Metrics{
	// 					PrometheusPort: to.Ptr[int32](7581),
	// 				},
	// 				SelfCheck: &armiotoperations.SelfCheck{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					IntervalSeconds: to.Ptr[int32](158),
	// 					TimeoutSeconds: to.Ptr[int32](14),
	// 				},
	// 				Traces: &armiotoperations.Traces{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					CacheSizeMegabytes: to.Ptr[int32](28),
	// 					SelfTracing: &armiotoperations.SelfTracing{
	// 						Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 						IntervalSeconds: to.Ptr[int32](22),
	// 					},
	// 					SpanChannelCapacity: to.Ptr[int32](1000),
	// 				},
	// 			},
	// 			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
	// 				MaxSize: to.Ptr("500M"),
	// 				EphemeralVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 				PersistentVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
	// 				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			},
	// 			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123"),
	// 		Name: to.Ptr("dowrkel"),
	// 		Type: to.Ptr("xshjnsdgadygb"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerClient) BeginDelete 

func (client *BrokerClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, options *BrokerClientBeginDeleteOptions) (*runtime.Poller[BrokerClientDeleteResponse], error)

BeginDelete - Delete a BrokerResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • options - BrokerClientBeginDeleteOptions contains the optional parameters for the BrokerClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/Broker_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", 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 (*BrokerClient) Get 

func (client *BrokerClient) Get(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, options *BrokerClientGetOptions) (BrokerClientGetResponse, error)

Get - Get a BrokerResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • options - BrokerClientGetOptions contains the optional parameters for the BrokerClient.Get method.
Example

Generated from example definition: 2024-11-01/Broker_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBrokerClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerClientGetResponse{
	// 	BrokerResource: &armiotoperations.BrokerResource{
	// 		Properties: &armiotoperations.BrokerProperties{
	// 			Advanced: &armiotoperations.AdvancedSettings{
	// 				Clients: &armiotoperations.ClientConfig{
	// 					MaxSessionExpirySeconds: to.Ptr[int32](3859),
	// 					MaxMessageExpirySeconds: to.Ptr[int32](3263),
	// 					MaxPacketSizeBytes: to.Ptr[int32](3029),
	// 					SubscriberQueueLimit: &armiotoperations.SubscriberQueueLimit{
	// 						Length: to.Ptr[int64](6),
	// 						Strategy: to.Ptr(armiotoperations.SubscriberMessageDropStrategyNone),
	// 					},
	// 					MaxReceiveMaximum: to.Ptr[int32](2365),
	// 					MaxKeepAliveSeconds: to.Ptr[int32](3744),
	// 				},
	// 				EncryptInternalTraffic: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				InternalCerts: &armiotoperations.CertManagerCertOptions{
	// 					Duration: to.Ptr("bchrc"),
	// 					RenewBefore: to.Ptr("xkafmpgjfifkwwrhkswtopdnne"),
	// 					PrivateKey: &armiotoperations.CertManagerPrivateKey{
	// 						Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
	// 						RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
	// 					},
	// 				},
	// 			},
	// 			Cardinality: &armiotoperations.Cardinality{
	// 				BackendChain: &armiotoperations.BackendChain{
	// 					Partitions: to.Ptr[int32](11),
	// 					RedundancyFactor: to.Ptr[int32](5),
	// 					Workers: to.Ptr[int32](15),
	// 				},
	// 				Frontend: &armiotoperations.Frontend{
	// 					Replicas: to.Ptr[int32](2),
	// 					Workers: to.Ptr[int32](6),
	// 				},
	// 			},
	// 			Diagnostics: &armiotoperations.BrokerDiagnostics{
	// 				Logs: &armiotoperations.DiagnosticsLogs{
	// 					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
	// 				},
	// 				Metrics: &armiotoperations.Metrics{
	// 					PrometheusPort: to.Ptr[int32](7581),
	// 				},
	// 				SelfCheck: &armiotoperations.SelfCheck{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					IntervalSeconds: to.Ptr[int32](158),
	// 					TimeoutSeconds: to.Ptr[int32](14),
	// 				},
	// 				Traces: &armiotoperations.Traces{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					CacheSizeMegabytes: to.Ptr[int32](28),
	// 					SelfTracing: &armiotoperations.SelfTracing{
	// 						Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 						IntervalSeconds: to.Ptr[int32](22),
	// 					},
	// 					SpanChannelCapacity: to.Ptr[int32](1000),
	// 				},
	// 			},
	// 			DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
	// 				MaxSize: to.Ptr("500M"),
	// 				EphemeralVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 				PersistentVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
	// 					VolumeName: to.Ptr("c"),
	// 					VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
	// 					StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
	// 					AccessModes: []*string{
	// 						to.Ptr("nuluhigrbb"),
	// 					},
	// 					DataSource: &armiotoperations.LocalKubernetesReference{
	// 						APIGroup: to.Ptr("npqapyksvvpkohujx"),
	// 						Kind: to.Ptr("wazgyb"),
	// 						Name: to.Ptr("cwhsgxxcxsyppoefm"),
	// 					},
	// 					DataSourceRef: &armiotoperations.KubernetesReference{
	// 						APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
	// 						Kind: to.Ptr("odynqzekfzsnawrctaxg"),
	// 						Name: to.Ptr("envszivbbmixbyddzg"),
	// 						Namespace: to.Ptr("etcfzvxqd"),
	// 					},
	// 					Resources: &armiotoperations.VolumeClaimResourceRequirements{
	// 						Limits: map[string]*string{
	// 							"key2719": to.Ptr("hmphcrgctu"),
	// 						},
	// 						Requests: map[string]*string{
	// 							"key2909": to.Ptr("txocprnyrsgvhfrg"),
	// 						},
	// 					},
	// 					Selector: &armiotoperations.VolumeClaimSpecSelector{
	// 						MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
	// 							{
	// 								Key: to.Ptr("e"),
	// 								Operator: to.Ptr(armiotoperations.OperatorValuesIn),
	// 								Values: []*string{
	// 									to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
	// 								},
	// 							},
	// 						},
	// 						MatchLabels: map[string]*string{
	// 							"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
	// 				CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			},
	// 			MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123"),
	// 		Name: to.Ptr("dowrkel"),
	// 		Type: to.Ptr("xshjnsdgadygb"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerClient) NewListByResourceGroupPager 

func (client *BrokerClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, options *BrokerClientListByResourceGroupOptions) *runtime.Pager[BrokerClientListByResourceGroupResponse]

NewListByResourceGroupPager - List BrokerResource resources by InstanceResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • options - BrokerClientListByResourceGroupOptions contains the optional parameters for the BrokerClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/Broker_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBrokerClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", 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 = armiotoperations.BrokerClientListByResourceGroupResponse{
		// 	BrokerResourceListResult: armiotoperations.BrokerResourceListResult{
		// 		Value: []*armiotoperations.BrokerResource{
		// 			{
		// 				Properties: &armiotoperations.BrokerProperties{
		// 					Advanced: &armiotoperations.AdvancedSettings{
		// 						Clients: &armiotoperations.ClientConfig{
		// 							MaxSessionExpirySeconds: to.Ptr[int32](3859),
		// 							MaxMessageExpirySeconds: to.Ptr[int32](3263),
		// 							MaxPacketSizeBytes: to.Ptr[int32](3029),
		// 							SubscriberQueueLimit: &armiotoperations.SubscriberQueueLimit{
		// 								Length: to.Ptr[int64](6),
		// 								Strategy: to.Ptr(armiotoperations.SubscriberMessageDropStrategyNone),
		// 							},
		// 							MaxReceiveMaximum: to.Ptr[int32](2365),
		// 							MaxKeepAliveSeconds: to.Ptr[int32](3744),
		// 						},
		// 						EncryptInternalTraffic: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 						InternalCerts: &armiotoperations.CertManagerCertOptions{
		// 							Duration: to.Ptr("bchrc"),
		// 							RenewBefore: to.Ptr("xkafmpgjfifkwwrhkswtopdnne"),
		// 							PrivateKey: &armiotoperations.CertManagerPrivateKey{
		// 								Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
		// 								RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
		// 							},
		// 						},
		// 					},
		// 					Cardinality: &armiotoperations.Cardinality{
		// 						BackendChain: &armiotoperations.BackendChain{
		// 							Partitions: to.Ptr[int32](11),
		// 							RedundancyFactor: to.Ptr[int32](5),
		// 							Workers: to.Ptr[int32](15),
		// 						},
		// 						Frontend: &armiotoperations.Frontend{
		// 							Replicas: to.Ptr[int32](2),
		// 							Workers: to.Ptr[int32](6),
		// 						},
		// 					},
		// 					Diagnostics: &armiotoperations.BrokerDiagnostics{
		// 						Logs: &armiotoperations.DiagnosticsLogs{
		// 							Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
		// 						},
		// 						Metrics: &armiotoperations.Metrics{
		// 							PrometheusPort: to.Ptr[int32](7581),
		// 						},
		// 						SelfCheck: &armiotoperations.SelfCheck{
		// 							Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 							IntervalSeconds: to.Ptr[int32](158),
		// 							TimeoutSeconds: to.Ptr[int32](14),
		// 						},
		// 						Traces: &armiotoperations.Traces{
		// 							Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 							CacheSizeMegabytes: to.Ptr[int32](28),
		// 							SelfTracing: &armiotoperations.SelfTracing{
		// 								Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 								IntervalSeconds: to.Ptr[int32](22),
		// 							},
		// 							SpanChannelCapacity: to.Ptr[int32](1000),
		// 						},
		// 					},
		// 					DiskBackedMessageBuffer: &armiotoperations.DiskBackedMessageBuffer{
		// 						MaxSize: to.Ptr("500M"),
		// 						EphemeralVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
		// 							VolumeName: to.Ptr("c"),
		// 							VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
		// 							StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
		// 							AccessModes: []*string{
		// 								to.Ptr("nuluhigrbb"),
		// 							},
		// 							DataSource: &armiotoperations.LocalKubernetesReference{
		// 								APIGroup: to.Ptr("npqapyksvvpkohujx"),
		// 								Kind: to.Ptr("wazgyb"),
		// 								Name: to.Ptr("cwhsgxxcxsyppoefm"),
		// 							},
		// 							DataSourceRef: &armiotoperations.KubernetesReference{
		// 								APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
		// 								Kind: to.Ptr("odynqzekfzsnawrctaxg"),
		// 								Name: to.Ptr("envszivbbmixbyddzg"),
		// 								Namespace: to.Ptr("etcfzvxqd"),
		// 							},
		// 							Resources: &armiotoperations.VolumeClaimResourceRequirements{
		// 								Limits: map[string]*string{
		// 									"key2719": to.Ptr("hmphcrgctu"),
		// 								},
		// 								Requests: map[string]*string{
		// 									"key2909": to.Ptr("txocprnyrsgvhfrg"),
		// 								},
		// 							},
		// 							Selector: &armiotoperations.VolumeClaimSpecSelector{
		// 								MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
		// 									{
		// 										Key: to.Ptr("e"),
		// 										Operator: to.Ptr(armiotoperations.OperatorValuesIn),
		// 										Values: []*string{
		// 											to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
		// 										},
		// 									},
		// 								},
		// 								MatchLabels: map[string]*string{
		// 									"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
		// 								},
		// 							},
		// 						},
		// 						PersistentVolumeClaimSpec: &armiotoperations.VolumeClaimSpec{
		// 							VolumeName: to.Ptr("c"),
		// 							VolumeMode: to.Ptr("rxvpksjuuugqnqzeiprocknbn"),
		// 							StorageClassName: to.Ptr("sseyhrjptkhrqvpdpjmornkqvon"),
		// 							AccessModes: []*string{
		// 								to.Ptr("nuluhigrbb"),
		// 							},
		// 							DataSource: &armiotoperations.LocalKubernetesReference{
		// 								APIGroup: to.Ptr("npqapyksvvpkohujx"),
		// 								Kind: to.Ptr("wazgyb"),
		// 								Name: to.Ptr("cwhsgxxcxsyppoefm"),
		// 							},
		// 							DataSourceRef: &armiotoperations.KubernetesReference{
		// 								APIGroup: to.Ptr("mnfnykznjjsoqpfsgdqioupt"),
		// 								Kind: to.Ptr("odynqzekfzsnawrctaxg"),
		// 								Name: to.Ptr("envszivbbmixbyddzg"),
		// 								Namespace: to.Ptr("etcfzvxqd"),
		// 							},
		// 							Resources: &armiotoperations.VolumeClaimResourceRequirements{
		// 								Limits: map[string]*string{
		// 									"key2719": to.Ptr("hmphcrgctu"),
		// 								},
		// 								Requests: map[string]*string{
		// 									"key2909": to.Ptr("txocprnyrsgvhfrg"),
		// 								},
		// 							},
		// 							Selector: &armiotoperations.VolumeClaimSpecSelector{
		// 								MatchExpressions: []*armiotoperations.VolumeClaimSpecSelectorMatchExpressions{
		// 									{
		// 										Key: to.Ptr("e"),
		// 										Operator: to.Ptr(armiotoperations.OperatorValuesIn),
		// 										Values: []*string{
		// 											to.Ptr("slmpajlywqvuyknipgztsonqyybt"),
		// 										},
		// 									},
		// 								},
		// 								MatchLabels: map[string]*string{
		// 									"key6673": to.Ptr("wlngfalznwxnurzpgxomcxhbqefpr"),
		// 								},
		// 							},
		// 						},
		// 					},
		// 					GenerateResourceLimits: &armiotoperations.GenerateResourceLimits{
		// 						CPU: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 					},
		// 					MemoryProfile: to.Ptr(armiotoperations.BrokerMemoryProfileTiny),
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123"),
		// 				Name: to.Ptr("dowrkel"),
		// 				Type: to.Ptr("xshjnsdgadygb"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type BrokerClientBeginCreateOrUpdateOptions 

type BrokerClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerClient.BeginCreateOrUpdate method.

type BrokerClientBeginDeleteOptions 

type BrokerClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerClientBeginDeleteOptions contains the optional parameters for the BrokerClient.BeginDelete method.

type BrokerClientCreateOrUpdateResponse 

type BrokerClientCreateOrUpdateResponse struct {
	// Instance broker resource
	BrokerResource
}

BrokerClientCreateOrUpdateResponse contains the response from method BrokerClient.BeginCreateOrUpdate.

type BrokerClientDeleteResponse 

type BrokerClientDeleteResponse struct {
}

BrokerClientDeleteResponse contains the response from method BrokerClient.BeginDelete.

type BrokerClientGetOptions 

type BrokerClientGetOptions struct {
}

BrokerClientGetOptions contains the optional parameters for the BrokerClient.Get method.

type BrokerClientGetResponse 

type BrokerClientGetResponse struct {
	// Instance broker resource
	BrokerResource
}

BrokerClientGetResponse contains the response from method BrokerClient.Get.

type BrokerClientListByResourceGroupOptions 

type BrokerClientListByResourceGroupOptions struct {
}

BrokerClientListByResourceGroupOptions contains the optional parameters for the BrokerClient.NewListByResourceGroupPager method.

type BrokerClientListByResourceGroupResponse 

type BrokerClientListByResourceGroupResponse struct {
	// The response of a BrokerResource list operation.
	BrokerResourceListResult
}

BrokerClientListByResourceGroupResponse contains the response from method BrokerClient.NewListByResourceGroupPager.

type BrokerDiagnostics 

type BrokerDiagnostics struct {
	// Diagnostic log settings for the resource.
	Logs *DiagnosticsLogs

	// The metrics settings for the resource.
	Metrics *Metrics

	// The self check properties.
	SelfCheck *SelfCheck

	// The trace properties.
	Traces *Traces
}

BrokerDiagnostics - Broker Diagnostic Setting properties

func (BrokerDiagnostics) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerDiagnostics.

func (*BrokerDiagnostics) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerDiagnostics.

type BrokerListenerClient 

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

BrokerListenerClient contains the methods for the BrokerListener group. Don't use this type directly, use NewBrokerListenerClient() instead.

func NewBrokerListenerClient 

func NewBrokerListenerClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BrokerListenerClient, error)

NewBrokerListenerClient creates a new instance of BrokerListenerClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BrokerListenerClient) BeginCreateOrUpdate 

func (client *BrokerListenerClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, listenerName string, resource BrokerListenerResource, options *BrokerListenerClientBeginCreateOrUpdateOptions) (*runtime.Poller[BrokerListenerClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a BrokerListenerResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • listenerName - Name of Instance broker listener resource
  • resource - Resource create parameters.
  • options - BrokerListenerClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerListenerClient.BeginCreateOrUpdate method.
Example (BrokerListenerCreateOrUpdate)

Generated from example definition: 2024-11-01/BrokerListener_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerListenerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerListenerResource{
		Properties: &armiotoperations.BrokerListenerProperties{
			ServiceName: to.Ptr("tpfiszlapdpxktx"),
			Ports: []*armiotoperations.ListenerPort{
				{
					AuthenticationRef: to.Ptr("tjvdroaqqy"),
					AuthorizationRef:  to.Ptr("inxhvxnwswyrvt"),
					NodePort:          to.Ptr[int32](7281),
					Port:              to.Ptr[int32](1268),
					Protocol:          to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
					TLS: &armiotoperations.TLSCertMethod{
						Mode: to.Ptr(armiotoperations.TLSCertMethodModeAutomatic),
						CertManagerCertificateSpec: &armiotoperations.CertManagerCertificateSpec{
							Duration:    to.Ptr("qmpeffoksron"),
							SecretName:  to.Ptr("oagi"),
							RenewBefore: to.Ptr("hutno"),
							IssuerRef: &armiotoperations.CertManagerIssuerRef{
								Group: to.Ptr("jtmuladdkpasfpoyvewekmiy"),
								Kind:  to.Ptr(armiotoperations.CertManagerIssuerKindIssuer),
								Name:  to.Ptr("ocwoqpgucvjrsuudtjhb"),
							},
							PrivateKey: &armiotoperations.CertManagerPrivateKey{
								Algorithm:      to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
								RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
							},
							San: &armiotoperations.SanForCert{
								DNS: []*string{
									to.Ptr("xhvmhrrhgfsapocjeebqtnzarlj"),
								},
								IP: []*string{
									to.Ptr("zbgugfzcgsmegevzktsnibyuyp"),
								},
							},
						},
						Manual: &armiotoperations.X509ManualCertificate{
							SecretRef: to.Ptr("secret-name"),
						},
					},
				},
			},
			ServiceType: to.Ptr(armiotoperations.ServiceTypeClusterIP),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerListenerClientCreateOrUpdateResponse{
	// 	BrokerListenerResource: &armiotoperations.BrokerListenerResource{
	// 		Properties: &armiotoperations.BrokerListenerProperties{
	// 			ServiceName: to.Ptr("tpfiszlapdpxktx"),
	// 			Ports: []*armiotoperations.ListenerPort{
	// 				{
	// 					AuthenticationRef: to.Ptr("tjvdroaqqy"),
	// 					AuthorizationRef: to.Ptr("inxhvxnwswyrvt"),
	// 					NodePort: to.Ptr[int32](7281),
	// 					Port: to.Ptr[int32](1268),
	// 					Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
	// 					TLS: &armiotoperations.TLSCertMethod{
	// 						Mode: to.Ptr(armiotoperations.TLSCertMethodModeAutomatic),
	// 						CertManagerCertificateSpec: &armiotoperations.CertManagerCertificateSpec{
	// 							Duration: to.Ptr("qmpeffoksron"),
	// 							SecretName: to.Ptr("oagi"),
	// 							RenewBefore: to.Ptr("hutno"),
	// 							IssuerRef: &armiotoperations.CertManagerIssuerRef{
	// 								Group: to.Ptr("jtmuladdkpasfpoyvewekmiy"),
	// 								Kind: to.Ptr(armiotoperations.CertManagerIssuerKindIssuer),
	// 								Name: to.Ptr("ocwoqpgucvjrsuudtjhb"),
	// 							},
	// 							PrivateKey: &armiotoperations.CertManagerPrivateKey{
	// 								Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
	// 								RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
	// 							},
	// 							San: &armiotoperations.SanForCert{
	// 								DNS: []*string{
	// 									to.Ptr("xhvmhrrhgfsapocjeebqtnzarlj"),
	// 								},
	// 								IP: []*string{
	// 									to.Ptr("zbgugfzcgsmegevzktsnibyuyp"),
	// 								},
	// 							},
	// 						},
	// 						Manual: &armiotoperations.X509ManualCertificate{
	// 							SecretRef: to.Ptr("secret-name"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ServiceType: to.Ptr(armiotoperations.ServiceTypeClusterIP),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/listeners/resource-name123"),
	// 		Name: to.Ptr("hoqjaachratt"),
	// 		Type: to.Ptr("hizbknwegcdaeh"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerListenerCreateOrUpdateComplex)

Generated from example definition: 2024-11-01/BrokerListener_CreateOrUpdate_Complex.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerListenerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerListenerResource{
		Properties: &armiotoperations.BrokerListenerProperties{
			ServiceType: to.Ptr(armiotoperations.ServiceTypeLoadBalancer),
			Ports: []*armiotoperations.ListenerPort{
				{
					Port:              to.Ptr[int32](8080),
					AuthenticationRef: to.Ptr("example-authentication"),
					Protocol:          to.Ptr(armiotoperations.BrokerProtocolTypeWebSockets),
				},
				{
					Port:              to.Ptr[int32](8443),
					AuthenticationRef: to.Ptr("example-authentication"),
					Protocol:          to.Ptr(armiotoperations.BrokerProtocolTypeWebSockets),
					TLS: &armiotoperations.TLSCertMethod{
						Mode: to.Ptr(armiotoperations.TLSCertMethodModeAutomatic),
						CertManagerCertificateSpec: &armiotoperations.CertManagerCertificateSpec{
							IssuerRef: &armiotoperations.CertManagerIssuerRef{
								Group: to.Ptr("jtmuladdkpasfpoyvewekmiy"),
								Name:  to.Ptr("example-issuer"),
								Kind:  to.Ptr(armiotoperations.CertManagerIssuerKindIssuer),
							},
						},
					},
				},
				{
					Port:              to.Ptr[int32](1883),
					AuthenticationRef: to.Ptr("example-authentication"),
				},
				{
					Port:              to.Ptr[int32](8883),
					AuthenticationRef: to.Ptr("example-authentication"),
					TLS: &armiotoperations.TLSCertMethod{
						Mode: to.Ptr(armiotoperations.TLSCertMethodModeManual),
						Manual: &armiotoperations.X509ManualCertificate{
							SecretRef: to.Ptr("example-secret"),
						},
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerListenerClientCreateOrUpdateResponse{
	// 	BrokerListenerResource: &armiotoperations.BrokerListenerResource{
	// 		Properties: &armiotoperations.BrokerListenerProperties{
	// 			ServiceName: to.Ptr("tpfiszlapdpxktx"),
	// 			ServiceType: to.Ptr(armiotoperations.ServiceTypeLoadBalancer),
	// 			Ports: []*armiotoperations.ListenerPort{
	// 				{
	// 					Port: to.Ptr[int32](8080),
	// 					AuthenticationRef: to.Ptr("example-authentication"),
	// 					Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeWebSockets),
	// 				},
	// 				{
	// 					Port: to.Ptr[int32](8443),
	// 					AuthenticationRef: to.Ptr("example-authentication"),
	// 					Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeWebSockets),
	// 					TLS: &armiotoperations.TLSCertMethod{
	// 						Mode: to.Ptr(armiotoperations.TLSCertMethodModeAutomatic),
	// 						CertManagerCertificateSpec: &armiotoperations.CertManagerCertificateSpec{
	// 							IssuerRef: &armiotoperations.CertManagerIssuerRef{
	// 								Group: to.Ptr("jtmuladdkpasfpoyvewekmiy"),
	// 								Name: to.Ptr("example-issuer"),
	// 								Kind: to.Ptr(armiotoperations.CertManagerIssuerKindIssuer),
	// 							},
	// 						},
	// 					},
	// 				},
	// 				{
	// 					Port: to.Ptr[int32](1883),
	// 					AuthenticationRef: to.Ptr("example-authentication"),
	// 				},
	// 				{
	// 					Port: to.Ptr[int32](8883),
	// 					AuthenticationRef: to.Ptr("example-authentication"),
	// 					TLS: &armiotoperations.TLSCertMethod{
	// 						Mode: to.Ptr(armiotoperations.TLSCertMethodModeManual),
	// 						Manual: &armiotoperations.X509ManualCertificate{
	// 							SecretRef: to.Ptr("example-secret"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/listeners/resource-name123"),
	// 		Name: to.Ptr("hoqjaachratt"),
	// 		Type: to.Ptr("hizbknwegcdaeh"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (BrokerListenerCreateOrUpdateSimple)

Generated from example definition: 2024-11-01/BrokerListener_CreateOrUpdate_Simple.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerListenerClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.BrokerListenerResource{
		Properties: &armiotoperations.BrokerListenerProperties{
			Ports: []*armiotoperations.ListenerPort{
				{
					Port: to.Ptr[int32](1883),
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.BrokerListenerClientCreateOrUpdateResponse{
	// 	BrokerListenerResource: &armiotoperations.BrokerListenerResource{
	// 		Properties: &armiotoperations.BrokerListenerProperties{
	// 			ServiceName: to.Ptr("tpfiszlapdpxktx"),
	// 			ServiceType: to.Ptr(armiotoperations.ServiceTypeLoadBalancer),
	// 			Ports: []*armiotoperations.ListenerPort{
	// 				{
	// 					Port: to.Ptr[int32](1883),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/listeners/resource-name123"),
	// 		Name: to.Ptr("hoqjaachratt"),
	// 		Type: to.Ptr("hizbknwegcdaeh"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerListenerClient) BeginDelete 

func (client *BrokerListenerClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, listenerName string, options *BrokerListenerClientBeginDeleteOptions) (*runtime.Poller[BrokerListenerClientDeleteResponse], error)

BeginDelete - Delete a BrokerListenerResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • listenerName - Name of Instance broker listener resource
  • options - BrokerListenerClientBeginDeleteOptions contains the optional parameters for the BrokerListenerClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/BrokerListener_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewBrokerListenerClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 (*BrokerListenerClient) Get 

func (client *BrokerListenerClient) Get(ctx context.Context, resourceGroupName string, instanceName string, brokerName string, listenerName string, options *BrokerListenerClientGetOptions) (BrokerListenerClientGetResponse, error)

Get - Get a BrokerListenerResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • listenerName - Name of Instance broker listener resource
  • options - BrokerListenerClientGetOptions contains the optional parameters for the BrokerListenerClient.Get method.
Example

Generated from example definition: 2024-11-01/BrokerListener_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBrokerListenerClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerListenerClientGetResponse{
	// 	BrokerListenerResource: &armiotoperations.BrokerListenerResource{
	// 		Properties: &armiotoperations.BrokerListenerProperties{
	// 			ServiceName: to.Ptr("tpfiszlapdpxktx"),
	// 			Ports: []*armiotoperations.ListenerPort{
	// 				{
	// 					AuthenticationRef: to.Ptr("tjvdroaqqy"),
	// 					AuthorizationRef: to.Ptr("inxhvxnwswyrvt"),
	// 					NodePort: to.Ptr[int32](7281),
	// 					Port: to.Ptr[int32](1268),
	// 					Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
	// 					TLS: &armiotoperations.TLSCertMethod{
	// 						Mode: to.Ptr(armiotoperations.TLSCertMethodModeAutomatic),
	// 						CertManagerCertificateSpec: &armiotoperations.CertManagerCertificateSpec{
	// 							Duration: to.Ptr("qmpeffoksron"),
	// 							SecretName: to.Ptr("oagi"),
	// 							RenewBefore: to.Ptr("hutno"),
	// 							IssuerRef: &armiotoperations.CertManagerIssuerRef{
	// 								Group: to.Ptr("jtmuladdkpasfpoyvewekmiy"),
	// 								Kind: to.Ptr(armiotoperations.CertManagerIssuerKindIssuer),
	// 								Name: to.Ptr("ocwoqpgucvjrsuudtjhb"),
	// 							},
	// 							PrivateKey: &armiotoperations.CertManagerPrivateKey{
	// 								Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
	// 								RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
	// 							},
	// 							San: &armiotoperations.SanForCert{
	// 								DNS: []*string{
	// 									to.Ptr("xhvmhrrhgfsapocjeebqtnzarlj"),
	// 								},
	// 								IP: []*string{
	// 									to.Ptr("zbgugfzcgsmegevzktsnibyuyp"),
	// 								},
	// 							},
	// 						},
	// 						Manual: &armiotoperations.X509ManualCertificate{
	// 							SecretRef: to.Ptr("secret-name"),
	// 						},
	// 					},
	// 				},
	// 			},
	// 			ServiceType: to.Ptr(armiotoperations.ServiceTypeClusterIP),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/listeners/resource-name123"),
	// 		Name: to.Ptr("hoqjaachratt"),
	// 		Type: to.Ptr("hizbknwegcdaeh"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*BrokerListenerClient) NewListByResourceGroupPager 

func (client *BrokerListenerClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, brokerName string, options *BrokerListenerClientListByResourceGroupOptions) *runtime.Pager[BrokerListenerClientListByResourceGroupResponse]

NewListByResourceGroupPager - List BrokerListenerResource resources by BrokerResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • brokerName - Name of broker.
  • options - BrokerListenerClientListByResourceGroupOptions contains the optional parameters for the BrokerListenerClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/BrokerListener_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewBrokerListenerClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.BrokerListenerClientListByResourceGroupResponse{
		// 	BrokerListenerResourceListResult: armiotoperations.BrokerListenerResourceListResult{
		// 		Value: []*armiotoperations.BrokerListenerResource{
		// 			{
		// 				Properties: &armiotoperations.BrokerListenerProperties{
		// 					ServiceName: to.Ptr("tpfiszlapdpxktx"),
		// 					Ports: []*armiotoperations.ListenerPort{
		// 						{
		// 							AuthenticationRef: to.Ptr("tjvdroaqqy"),
		// 							AuthorizationRef: to.Ptr("inxhvxnwswyrvt"),
		// 							NodePort: to.Ptr[int32](7281),
		// 							Port: to.Ptr[int32](1268),
		// 							Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
		// 							TLS: &armiotoperations.TLSCertMethod{
		// 								Mode: to.Ptr(armiotoperations.TLSCertMethodModeAutomatic),
		// 								CertManagerCertificateSpec: &armiotoperations.CertManagerCertificateSpec{
		// 									Duration: to.Ptr("qmpeffoksron"),
		// 									SecretName: to.Ptr("oagi"),
		// 									RenewBefore: to.Ptr("hutno"),
		// 									IssuerRef: &armiotoperations.CertManagerIssuerRef{
		// 										Group: to.Ptr("jtmuladdkpasfpoyvewekmiy"),
		// 										Kind: to.Ptr(armiotoperations.CertManagerIssuerKindIssuer),
		// 										Name: to.Ptr("ocwoqpgucvjrsuudtjhb"),
		// 									},
		// 									PrivateKey: &armiotoperations.CertManagerPrivateKey{
		// 										Algorithm: to.Ptr(armiotoperations.PrivateKeyAlgorithmEc256),
		// 										RotationPolicy: to.Ptr(armiotoperations.PrivateKeyRotationPolicyAlways),
		// 									},
		// 									San: &armiotoperations.SanForCert{
		// 										DNS: []*string{
		// 											to.Ptr("xhvmhrrhgfsapocjeebqtnzarlj"),
		// 										},
		// 										IP: []*string{
		// 											to.Ptr("zbgugfzcgsmegevzktsnibyuyp"),
		// 										},
		// 									},
		// 								},
		// 								Manual: &armiotoperations.X509ManualCertificate{
		// 									SecretRef: to.Ptr("secret-name"),
		// 								},
		// 							},
		// 						},
		// 					},
		// 					ServiceType: to.Ptr(armiotoperations.ServiceTypeClusterIP),
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/brokers/resource-name123/listeners/resource-name123"),
		// 				Name: to.Ptr("hoqjaachratt"),
		// 				Type: to.Ptr("hizbknwegcdaeh"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type BrokerListenerClientBeginCreateOrUpdateOptions 

type BrokerListenerClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerListenerClientBeginCreateOrUpdateOptions contains the optional parameters for the BrokerListenerClient.BeginCreateOrUpdate method.

type BrokerListenerClientBeginDeleteOptions 

type BrokerListenerClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

BrokerListenerClientBeginDeleteOptions contains the optional parameters for the BrokerListenerClient.BeginDelete method.

type BrokerListenerClientCreateOrUpdateResponse 

type BrokerListenerClientCreateOrUpdateResponse struct {
	// Instance broker resource
	BrokerListenerResource
}

BrokerListenerClientCreateOrUpdateResponse contains the response from method BrokerListenerClient.BeginCreateOrUpdate.

type BrokerListenerClientDeleteResponse 

type BrokerListenerClientDeleteResponse struct {
}

BrokerListenerClientDeleteResponse contains the response from method BrokerListenerClient.BeginDelete.

type BrokerListenerClientGetOptions 

type BrokerListenerClientGetOptions struct {
}

BrokerListenerClientGetOptions contains the optional parameters for the BrokerListenerClient.Get method.

type BrokerListenerClientGetResponse 

type BrokerListenerClientGetResponse struct {
	// Instance broker resource
	BrokerListenerResource
}

BrokerListenerClientGetResponse contains the response from method BrokerListenerClient.Get.

type BrokerListenerClientListByResourceGroupOptions 

type BrokerListenerClientListByResourceGroupOptions struct {
}

BrokerListenerClientListByResourceGroupOptions contains the optional parameters for the BrokerListenerClient.NewListByResourceGroupPager method.

type BrokerListenerClientListByResourceGroupResponse 

type BrokerListenerClientListByResourceGroupResponse struct {
	// The response of a BrokerListenerResource list operation.
	BrokerListenerResourceListResult
}

BrokerListenerClientListByResourceGroupResponse contains the response from method BrokerListenerClient.NewListByResourceGroupPager.

type BrokerListenerProperties 

type BrokerListenerProperties struct {
	// REQUIRED; Ports on which this listener accepts client connections.
	Ports []*ListenerPort

	// Kubernetes Service name of this listener.
	ServiceName *string

	// Kubernetes Service type of this listener.
	ServiceType *ServiceType

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

BrokerListenerProperties - Defines a Broker listener. A listener is a collection of ports on which the broker accepts connections from clients.

func (BrokerListenerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerListenerProperties.

func (*BrokerListenerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerListenerProperties.

type BrokerListenerResource 

type BrokerListenerResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *BrokerListenerProperties

	// READ-ONLY; Name of Instance broker listener resource
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

BrokerListenerResource - Instance broker resource

func (BrokerListenerResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerListenerResource.

func (*BrokerListenerResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerListenerResource.

type BrokerListenerResourceListResult 

type BrokerListenerResourceListResult struct {
	// REQUIRED; The BrokerListenerResource items on this page
	Value []*BrokerListenerResource

	// The link to the next page of items
	NextLink *string
}

BrokerListenerResourceListResult - The response of a BrokerListenerResource list operation.

func (BrokerListenerResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerListenerResourceListResult.

func (*BrokerListenerResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerListenerResourceListResult.

type BrokerMemoryProfile 

type BrokerMemoryProfile string

BrokerMemoryProfile - The memory profile settings of the Broker 

const (
	// BrokerMemoryProfileHigh - High memory profile.
	BrokerMemoryProfileHigh BrokerMemoryProfile = "High"
	// BrokerMemoryProfileLow - Low memory profile.
	BrokerMemoryProfileLow BrokerMemoryProfile = "Low"
	// BrokerMemoryProfileMedium - Medium memory profile.
	BrokerMemoryProfileMedium BrokerMemoryProfile = "Medium"
	// BrokerMemoryProfileTiny - Tiny memory profile.
	BrokerMemoryProfileTiny BrokerMemoryProfile = "Tiny"
)

func PossibleBrokerMemoryProfileValues 

func PossibleBrokerMemoryProfileValues() []BrokerMemoryProfile

PossibleBrokerMemoryProfileValues returns the possible values for the BrokerMemoryProfile const type.

type BrokerProperties 

type BrokerProperties struct {
	// Advanced settings of Broker.
	Advanced *AdvancedSettings

	// The cardinality details of the broker.
	Cardinality *Cardinality

	// Spec defines the desired identities of Broker diagnostics settings.
	Diagnostics *BrokerDiagnostics

	// Settings of Disk Backed Message Buffer.
	DiskBackedMessageBuffer *DiskBackedMessageBuffer

	// This setting controls whether Kubernetes CPU resource limits are requested. Increasing the number of replicas or workers
	// proportionally increases the amount of CPU resources requested. If this setting is enabled and there are insufficient CPU
	// resources, an error will be emitted.
	GenerateResourceLimits *GenerateResourceLimits

	// Memory profile of Broker.
	MemoryProfile *BrokerMemoryProfile

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

BrokerProperties - Broker Resource properties

func (BrokerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerProperties.

func (*BrokerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerProperties.

type BrokerProtocolType 

type BrokerProtocolType string

BrokerProtocolType - Broker Protocol types 

const (
	// BrokerProtocolTypeMqtt - protocol broker
	BrokerProtocolTypeMqtt BrokerProtocolType = "Mqtt"
	// BrokerProtocolTypeWebSockets - protocol websocket
	BrokerProtocolTypeWebSockets BrokerProtocolType = "WebSockets"
)

func PossibleBrokerProtocolTypeValues 

func PossibleBrokerProtocolTypeValues() []BrokerProtocolType

PossibleBrokerProtocolTypeValues returns the possible values for the BrokerProtocolType const type.

type BrokerResource 

type BrokerResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *BrokerProperties

	// READ-ONLY; Name of broker.
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

BrokerResource - Instance broker resource

func (BrokerResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerResource.

func (*BrokerResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerResource.

type BrokerResourceDefinitionMethods 

type BrokerResourceDefinitionMethods string

BrokerResourceDefinitionMethods - BrokerResourceDefinitionMethods methods allowed 

const (
	// BrokerResourceDefinitionMethodsConnect - Allowed Connecting to Broker
	BrokerResourceDefinitionMethodsConnect BrokerResourceDefinitionMethods = "Connect"
	// BrokerResourceDefinitionMethodsPublish - Allowed Publishing to Broker
	BrokerResourceDefinitionMethodsPublish BrokerResourceDefinitionMethods = "Publish"
	// BrokerResourceDefinitionMethodsSubscribe - Allowed Subscribing to Broker
	BrokerResourceDefinitionMethodsSubscribe BrokerResourceDefinitionMethods = "Subscribe"
)

func PossibleBrokerResourceDefinitionMethodsValues 

func PossibleBrokerResourceDefinitionMethodsValues() []BrokerResourceDefinitionMethods

PossibleBrokerResourceDefinitionMethodsValues returns the possible values for the BrokerResourceDefinitionMethods const type.

type BrokerResourceListResult 

type BrokerResourceListResult struct {
	// REQUIRED; The BrokerResource items on this page
	Value []*BrokerResource

	// The link to the next page of items
	NextLink *string
}

BrokerResourceListResult - The response of a BrokerResource list operation.

func (BrokerResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerResourceListResult.

func (*BrokerResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerResourceListResult.

type BrokerResourceRule 

type BrokerResourceRule struct {
	// REQUIRED; Give access for a Broker method (i.e., Connect, Subscribe, or Publish).
	Method *BrokerResourceDefinitionMethods

	// A list of client IDs that match the clients. The client IDs are case-sensitive and must match the client IDs provided by
	// the clients during connection. This subfield may be set if the method is Connect.
	ClientIDs []*string

	// A list of topics or topic patterns that match the topics that the clients can publish or subscribe to. This subfield is
	// required if the method is Publish or Subscribe.
	Topics []*string
}

BrokerResourceRule - Broker Resource Rule properties. This defines the objects that represent the actions or topics, such as - method.Connect, method.Publish, etc.

func (BrokerResourceRule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BrokerResourceRule.

func (*BrokerResourceRule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BrokerResourceRule.

type Cardinality 

type Cardinality struct {
	// REQUIRED; The backend broker desired properties
	BackendChain *BackendChain

	// REQUIRED; The frontend desired properties
	Frontend *Frontend
}

Cardinality properties

func (Cardinality) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Cardinality.

func (*Cardinality) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Cardinality.

type CertManagerCertOptions 

type CertManagerCertOptions struct {
	// REQUIRED; Lifetime of certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours and
	// 45m for 45 minutes.
	Duration *string

	// REQUIRED; Configuration of certificate private key.
	PrivateKey *CertManagerPrivateKey

	// REQUIRED; When to begin renewing certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for
	// 240 hours and 45m for 45 minutes.
	RenewBefore *string
}

CertManagerCertOptions - Cert Manager Cert properties

func (CertManagerCertOptions) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertManagerCertOptions.

func (*CertManagerCertOptions) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertManagerCertOptions.

type CertManagerCertificateSpec 

type CertManagerCertificateSpec struct {
	// REQUIRED; cert-manager issuerRef.
	IssuerRef *CertManagerIssuerRef

	// Lifetime of certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours and 45m for
	// 45 minutes.
	Duration *string

	// Type of certificate private key.
	PrivateKey *CertManagerPrivateKey

	// When to begin renewing certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours
	// and 45m for 45 minutes.
	RenewBefore *string

	// Additional Subject Alternative Names (SANs) to include in the certificate.
	San *SanForCert

	// Secret for storing server certificate. Any existing data will be overwritten. This is a reference to the secret through
	// an identifying name, not the secret itself.
	SecretName *string
}

CertManagerCertificateSpec - Automatic TLS server certificate management with cert-manager

func (CertManagerCertificateSpec) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertManagerCertificateSpec.

func (*CertManagerCertificateSpec) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertManagerCertificateSpec.

type CertManagerIssuerKind 

type CertManagerIssuerKind string

CertManagerIssuerKind - CertManagerIssuerKind properties 

const (
	// CertManagerIssuerKindClusterIssuer - ClusterIssuer kind.
	CertManagerIssuerKindClusterIssuer CertManagerIssuerKind = "ClusterIssuer"
	// CertManagerIssuerKindIssuer - Issuer kind.
	CertManagerIssuerKindIssuer CertManagerIssuerKind = "Issuer"
)

func PossibleCertManagerIssuerKindValues 

func PossibleCertManagerIssuerKindValues() []CertManagerIssuerKind

PossibleCertManagerIssuerKindValues returns the possible values for the CertManagerIssuerKind const type.

type CertManagerIssuerRef 

type CertManagerIssuerRef struct {
	// REQUIRED; group of issuer.
	Group *string

	// REQUIRED; kind of issuer (Issuer or ClusterIssuer).
	Kind *CertManagerIssuerKind

	// REQUIRED; name of issuer.
	Name *string
}

CertManagerIssuerRef - Cert-Manager issuerRef properties

func (CertManagerIssuerRef) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertManagerIssuerRef.

func (*CertManagerIssuerRef) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertManagerIssuerRef.

type CertManagerPrivateKey 

type CertManagerPrivateKey struct {
	// REQUIRED; algorithm for private key.
	Algorithm *PrivateKeyAlgorithm

	// REQUIRED; cert-manager private key rotationPolicy.
	RotationPolicy *PrivateKeyRotationPolicy
}

CertManagerPrivateKey - Cert Manager private key properties

func (CertManagerPrivateKey) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertManagerPrivateKey.

func (*CertManagerPrivateKey) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertManagerPrivateKey.

type ClientConfig 

type ClientConfig struct {
	// Upper bound of a client's Keep Alive, in seconds.
	MaxKeepAliveSeconds *int32

	// Upper bound of Message Expiry Interval, in seconds.
	MaxMessageExpirySeconds *int32

	// Max message size for a packet in Bytes.
	MaxPacketSizeBytes *int32

	// Upper bound of Receive Maximum that a client can request in the CONNECT packet.
	MaxReceiveMaximum *int32

	// Upper bound of Session Expiry Interval, in seconds.
	MaxSessionExpirySeconds *int32

	// The limit on the number of queued messages for a subscriber.
	SubscriberQueueLimit *SubscriberQueueLimit
}

ClientConfig - The settings of Client Config.

func (ClientConfig) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ClientConfig.

func (*ClientConfig) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClientConfig.

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 ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewBrokerAuthenticationClient 

func (c *ClientFactory) NewBrokerAuthenticationClient() *BrokerAuthenticationClient

NewBrokerAuthenticationClient creates a new instance of BrokerAuthenticationClient.

func (*ClientFactory) NewBrokerAuthorizationClient 

func (c *ClientFactory) NewBrokerAuthorizationClient() *BrokerAuthorizationClient

NewBrokerAuthorizationClient creates a new instance of BrokerAuthorizationClient.

func (*ClientFactory) NewBrokerClient 

func (c *ClientFactory) NewBrokerClient() *BrokerClient

NewBrokerClient creates a new instance of BrokerClient.

func (*ClientFactory) NewBrokerListenerClient 

func (c *ClientFactory) NewBrokerListenerClient() *BrokerListenerClient

NewBrokerListenerClient creates a new instance of BrokerListenerClient.

func (*ClientFactory) NewDataflowClient 

func (c *ClientFactory) NewDataflowClient() *DataflowClient

NewDataflowClient creates a new instance of DataflowClient.

func (*ClientFactory) NewDataflowEndpointClient 

func (c *ClientFactory) NewDataflowEndpointClient() *DataflowEndpointClient

NewDataflowEndpointClient creates a new instance of DataflowEndpointClient.

func (*ClientFactory) NewDataflowProfileClient 

func (c *ClientFactory) NewDataflowProfileClient() *DataflowProfileClient

NewDataflowProfileClient creates a new instance of DataflowProfileClient.

func (*ClientFactory) NewInstanceClient 

func (c *ClientFactory) NewInstanceClient() *InstanceClient

NewInstanceClient creates a new instance of InstanceClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type CloudEventAttributeType 

type CloudEventAttributeType string

CloudEventAttributeType - How to map events to the cloud. 

const (
	// CloudEventAttributeTypeCreateOrRemap - CreateOrRemap type
	CloudEventAttributeTypeCreateOrRemap CloudEventAttributeType = "CreateOrRemap"
	// CloudEventAttributeTypePropagate - Propagate type
	CloudEventAttributeTypePropagate CloudEventAttributeType = "Propagate"
)

func PossibleCloudEventAttributeTypeValues 

func PossibleCloudEventAttributeTypeValues() []CloudEventAttributeType

PossibleCloudEventAttributeTypeValues returns the possible values for the CloudEventAttributeType const type.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

const (
	// CreatedByTypeApplication - The entity was created by an application.
	CreatedByTypeApplication CreatedByType = "Application"
	// CreatedByTypeKey - The entity was created by a key.
	CreatedByTypeKey CreatedByType = "Key"
	// CreatedByTypeManagedIdentity - The entity was created by a managed identity.
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	// CreatedByTypeUser - The entity was created by a user.
	CreatedByTypeUser CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DataExplorerAuthMethod 

type DataExplorerAuthMethod string

DataExplorerAuthMethod - DataflowEndpoint Data Explorer Authentication Method properties 

const (
	// DataExplorerAuthMethodSystemAssignedManagedIdentity - SystemAssignedManagedIdentity type
	DataExplorerAuthMethodSystemAssignedManagedIdentity DataExplorerAuthMethod = "SystemAssignedManagedIdentity"
	// DataExplorerAuthMethodUserAssignedManagedIdentity - UserAssignedManagedIdentity type
	DataExplorerAuthMethodUserAssignedManagedIdentity DataExplorerAuthMethod = "UserAssignedManagedIdentity"
)

func PossibleDataExplorerAuthMethodValues 

func PossibleDataExplorerAuthMethodValues() []DataExplorerAuthMethod

PossibleDataExplorerAuthMethodValues returns the possible values for the DataExplorerAuthMethod const type.

type DataLakeStorageAuthMethod 

type DataLakeStorageAuthMethod string

DataLakeStorageAuthMethod - DataflowEndpoint Data Lake Storage Authentication Method properties 

const (
	// DataLakeStorageAuthMethodAccessToken - AccessToken Option
	DataLakeStorageAuthMethodAccessToken DataLakeStorageAuthMethod = "AccessToken"
	// DataLakeStorageAuthMethodSystemAssignedManagedIdentity - SystemAssignedManagedIdentity type
	DataLakeStorageAuthMethodSystemAssignedManagedIdentity DataLakeStorageAuthMethod = "SystemAssignedManagedIdentity"
	// DataLakeStorageAuthMethodUserAssignedManagedIdentity - UserAssignedManagedIdentity type
	DataLakeStorageAuthMethodUserAssignedManagedIdentity DataLakeStorageAuthMethod = "UserAssignedManagedIdentity"
)

func PossibleDataLakeStorageAuthMethodValues 

func PossibleDataLakeStorageAuthMethodValues() []DataLakeStorageAuthMethod

PossibleDataLakeStorageAuthMethodValues returns the possible values for the DataLakeStorageAuthMethod const type.

type DataflowBuiltInTransformationDataset 

type DataflowBuiltInTransformationDataset struct {
	// REQUIRED; List of fields for enriching from the Broker State Store.
	Inputs []*string

	// REQUIRED; The key of the dataset.
	Key *string

	// A user provided optional description of the dataset.
	Description *string

	// Condition to enrich data from Broker State Store. Example: $1 < 0 || $1 > $2 (Assuming inputs section $1 and $2 are provided)
	Expression *string

	// The reference to the schema that describes the dataset. Allowed: JSON Schema/draft-7.
	SchemaRef *string
}

DataflowBuiltInTransformationDataset - Dataflow BuiltIn Transformation dataset properties

func (DataflowBuiltInTransformationDataset) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowBuiltInTransformationDataset.

func (*DataflowBuiltInTransformationDataset) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowBuiltInTransformationDataset.

type DataflowBuiltInTransformationFilter 

type DataflowBuiltInTransformationFilter struct {
	// REQUIRED; Condition to filter data. Can reference input fields with {n} where n is the index of the input field starting
	// from 1. Example: $1 < 0 || $1 > $2 (Assuming inputs section $1 and $2 are provided)
	Expression *string

	// REQUIRED; List of fields for filtering in JSON path expression.
	Inputs []*string

	// A user provided optional description of the filter.
	Description *string

	// The type of dataflow operation.
	Type *FilterType
}

DataflowBuiltInTransformationFilter - Dataflow BuiltIn Transformation filter properties

func (DataflowBuiltInTransformationFilter) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowBuiltInTransformationFilter.

func (*DataflowBuiltInTransformationFilter) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowBuiltInTransformationFilter.

type DataflowBuiltInTransformationMap 

type DataflowBuiltInTransformationMap struct {
	// REQUIRED; List of fields for mapping in JSON path expression.
	Inputs []*string

	// REQUIRED; Where and how the input fields to be organized in the output record.
	Output *string

	// A user provided optional description of the mapping function.
	Description *string

	// Modify the inputs field(s) to the final output field. Example: $1 * 2.2 (Assuming inputs section $1 is provided)
	Expression *string

	// Type of transformation.
	Type *DataflowMappingType
}

DataflowBuiltInTransformationMap - Dataflow BuiltIn Transformation map properties

func (DataflowBuiltInTransformationMap) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowBuiltInTransformationMap.

func (*DataflowBuiltInTransformationMap) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowBuiltInTransformationMap.

type DataflowBuiltInTransformationSettings 

type DataflowBuiltInTransformationSettings struct {
	// Enrich data from Broker State Store. Dataset references a key in Broker State Store.
	Datasets []*DataflowBuiltInTransformationDataset

	// Filters input record or datapoints based on condition.
	Filter []*DataflowBuiltInTransformationFilter

	// Maps input to output message.
	Map []*DataflowBuiltInTransformationMap

	// Reference to the schema that describes the output of the transformation.
	SchemaRef *string

	// Serialization format. Optional; defaults to JSON. Allowed value JSON Schema/draft-7, Parquet. Default: Json
	SerializationFormat *TransformationSerializationFormat
}

DataflowBuiltInTransformationSettings - Dataflow BuiltIn Transformation properties

func (DataflowBuiltInTransformationSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowBuiltInTransformationSettings.

func (*DataflowBuiltInTransformationSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowBuiltInTransformationSettings.

type DataflowClient 

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

DataflowClient contains the methods for the Dataflow group. Don't use this type directly, use NewDataflowClient() instead.

func NewDataflowClient 

func NewDataflowClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DataflowClient, error)

NewDataflowClient creates a new instance of DataflowClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DataflowClient) BeginCreateOrUpdate 

func (client *DataflowClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, dataflowProfileName string, dataflowName string, resource DataflowResource, options *DataflowClientBeginCreateOrUpdateOptions) (*runtime.Poller[DataflowClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a DataflowResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • dataflowName - Name of Instance dataflowProfile dataflow resource
  • resource - Resource create parameters.
  • options - DataflowClientBeginCreateOrUpdateOptions contains the optional parameters for the DataflowClient.BeginCreateOrUpdate method.
Example (DataflowCreateOrUpdate)

Generated from example definition: 2024-11-01/Dataflow_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", armiotoperations.DataflowResource{
		Properties: &armiotoperations.DataflowProperties{
			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
			Operations: []*armiotoperations.DataflowOperation{
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
					Name:          to.Ptr("knnafvkwoeakm"),
					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
						EndpointRef:         to.Ptr("iixotodhvhkkfcfyrkoveslqig"),
						AssetRef:            to.Ptr("zayyykwmckaocywdkohmu"),
						SerializationFormat: to.Ptr(armiotoperations.SourceSerializationFormatJSON),
						SchemaRef:           to.Ptr("pknmdzqll"),
						DataSources: []*string{
							to.Ptr("chkkpymxhp"),
						},
					},
					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
						SerializationFormat: to.Ptr(armiotoperations.TransformationSerializationFormatDelta),
						SchemaRef:           to.Ptr("mcdc"),
						Datasets: []*armiotoperations.DataflowBuiltInTransformationDataset{
							{
								Key:         to.Ptr("qsfqcgxaxnhfumrsdsokwyv"),
								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
								SchemaRef:   to.Ptr("n"),
								Inputs: []*string{
									to.Ptr("mosffpsslifkq"),
								},
								Expression: to.Ptr("aatbwomvflemsxialv"),
							},
						},
						Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
							{
								Type:        to.Ptr(armiotoperations.FilterTypeFilter),
								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
								Inputs: []*string{
									to.Ptr("sxmjkbntgb"),
								},
								Expression: to.Ptr("n"),
							},
						},
						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
							{
								Type:        to.Ptr(armiotoperations.DataflowMappingTypeNewProperties),
								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
								Inputs: []*string{
									to.Ptr("xsbxuk"),
								},
								Expression: to.Ptr("txoiltogsarwkzalsphvlmt"),
								Output:     to.Ptr("nvgtmkfl"),
							},
						},
					},
					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
						EndpointRef:     to.Ptr("kybkchnzimerguekuvqlqiqdvvrt"),
						DataDestination: to.Ptr("cbrh"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowClientCreateOrUpdateResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("knnafvkwoeakm"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("iixotodhvhkkfcfyrkoveslqig"),
	// 						AssetRef: to.Ptr("zayyykwmckaocywdkohmu"),
	// 						SerializationFormat: to.Ptr(armiotoperations.SourceSerializationFormatJSON),
	// 						SchemaRef: to.Ptr("pknmdzqll"),
	// 						DataSources: []*string{
	// 							to.Ptr("chkkpymxhp"),
	// 						},
	// 					},
	// 					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
	// 						SerializationFormat: to.Ptr(armiotoperations.TransformationSerializationFormatDelta),
	// 						SchemaRef: to.Ptr("mcdc"),
	// 						Datasets: []*armiotoperations.DataflowBuiltInTransformationDataset{
	// 							{
	// 								Key: to.Ptr("qsfqcgxaxnhfumrsdsokwyv"),
	// 								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
	// 								SchemaRef: to.Ptr("n"),
	// 								Inputs: []*string{
	// 									to.Ptr("mosffpsslifkq"),
	// 								},
	// 								Expression: to.Ptr("aatbwomvflemsxialv"),
	// 							},
	// 						},
	// 						Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
	// 							{
	// 								Type: to.Ptr(armiotoperations.FilterTypeFilter),
	// 								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
	// 								Inputs: []*string{
	// 									to.Ptr("sxmjkbntgb"),
	// 								},
	// 								Expression: to.Ptr("n"),
	// 							},
	// 						},
	// 						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
	// 							{
	// 								Type: to.Ptr(armiotoperations.DataflowMappingTypeNewProperties),
	// 								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
	// 								Inputs: []*string{
	// 									to.Ptr("xsbxuk"),
	// 								},
	// 								Expression: to.Ptr("txoiltogsarwkzalsphvlmt"),
	

Output:
Example (DataflowCreateOrUpdateComplexContextualization)

Generated from example definition: 2024-11-01/Dataflow_CreateOrUpdate_ComplexContextualization.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "aio-to-adx-contexualized", armiotoperations.DataflowResource{
		Properties: &armiotoperations.DataflowProperties{
			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
			Operations: []*armiotoperations.DataflowOperation{
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
					Name:          to.Ptr("source1"),
					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
						DataSources: []*string{
							to.Ptr("azure-iot-operations/data/thermostat"),
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
					Name:          to.Ptr("transformation1"),
					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
							{
								Inputs: []*string{
									to.Ptr("*"),
								},
								Output: to.Ptr("*"),
							},
							{
								Inputs: []*string{
									to.Ptr("$context(quality).*"),
								},
								Output: to.Ptr("enriched.*"),
							},
						},
						Datasets: []*armiotoperations.DataflowBuiltInTransformationDataset{
							{
								Key: to.Ptr("quality"),
								Inputs: []*string{
									to.Ptr("$source.country"),
									to.Ptr("$context.country"),
								},
								Expression: to.Ptr("$1 == $2"),
							},
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
					Name:          to.Ptr("destination1"),
					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
						EndpointRef:     to.Ptr("adx-endpoint"),
						DataDestination: to.Ptr("mytable"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowClientCreateOrUpdateResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("source1"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
	// 						DataSources: []*string{
	// 							to.Ptr("azure-iot-operations/data/thermostat"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
	// 					Name: to.Ptr("transformation1"),
	// 					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
	// 						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
	// 							{
	// 								Inputs: []*string{
	// 									to.Ptr("*"),
	// 								},
	// 								Output: to.Ptr("*"),
	// 							},
	// 							{
	// 								Inputs: []*string{
	// 									to.Ptr("$context(quality).*"),
	// 								},
	

Output:
Example (DataflowCreateOrUpdateComplexEventHub)

Generated from example definition: 2024-11-01/Dataflow_CreateOrUpdate_ComplexEventHub.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "aio-to-event-hub-transformed", armiotoperations.DataflowResource{
		Properties: &armiotoperations.DataflowProperties{
			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
			Operations: []*armiotoperations.DataflowOperation{
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
					Name:          to.Ptr("source1"),
					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
						DataSources: []*string{
							to.Ptr("azure-iot-operations/data/thermostat"),
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
						Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
							{
								Inputs: []*string{
									to.Ptr("temperature.Value"),
									to.Ptr("\"Tag 10\".Value"),
								},
								Expression: to.Ptr("$1 > 9000 && $2 >= 8000"),
							},
						},
						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
							{
								Inputs: []*string{
									to.Ptr("*"),
								},
								Output: to.Ptr("*"),
							},
							{
								Inputs: []*string{
									to.Ptr("temperature.Value"),
									to.Ptr("\"Tag 10\".Value"),
								},
								Expression: to.Ptr("($1+$2)/2"),
								Output:     to.Ptr("AvgTemp.Value"),
							},
							{
								Inputs:     []*string{},
								Expression: to.Ptr("true"),
								Output:     to.Ptr("dataflow-processed"),
							},
							{
								Inputs: []*string{
									to.Ptr("temperature.SourceTimestamp"),
								},
								Expression: to.Ptr(""),
								Output:     to.Ptr(""),
							},
							{
								Inputs: []*string{
									to.Ptr("\"Tag 10\""),
								},
								Expression: to.Ptr(""),
								Output:     to.Ptr("pressure"),
							},
							{
								Inputs: []*string{
									to.Ptr("temperature.Value"),
								},
								Expression: to.Ptr("cToF($1)"),
								Output:     to.Ptr("temperatureF.Value"),
							},
							{
								Inputs: []*string{
									to.Ptr("\"Tag 10\".Value"),
								},
								Expression: to.Ptr("scale ($1,0,10,0,100)"),
								Output:     to.Ptr("\"Scale Tag 10\".Value"),
							},
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
					Name:          to.Ptr("destination1"),
					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
						EndpointRef:     to.Ptr("event-hub-endpoint"),
						DataDestination: to.Ptr("myuniqueeventhub"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowClientCreateOrUpdateResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("source1"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
	// 						DataSources: []*string{
	// 							to.Ptr("azure-iot-operations/data/thermostat"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
	// 					Name: to.Ptr("transformation1"),
	// 					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
	// 						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
	// 							{
	// 								Inputs: []*string{
	// 									to.Ptr("*"),
	// 								},
	// 								Output: to.Ptr("*"),
	// 							},
	// 							{
	// 								Inputs: []*string{
	// 									to.Ptr("$context(quality).*"),
	// 								},
	

Output:
Example (DataflowCreateOrUpdateFilterToTopic)

Generated from example definition: 2024-11-01/Dataflow_CreateOrUpdate_FilterToTopic.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "mqtt-filter-to-topic", armiotoperations.DataflowResource{
		Properties: &armiotoperations.DataflowProperties{
			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
			Operations: []*armiotoperations.DataflowOperation{
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
					Name:          to.Ptr("source1"),
					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
						DataSources: []*string{
							to.Ptr("azure-iot-operations/data/thermostat"),
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
					Name:          to.Ptr("transformation1"),
					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
						Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
							{
								Type:        to.Ptr(armiotoperations.FilterTypeFilter),
								Description: to.Ptr("filter-datapoint"),
								Inputs: []*string{
									to.Ptr("temperature.Value"),
									to.Ptr("\"Tag 10\".Value"),
								},
								Expression: to.Ptr("$1 > 9000 && $2 >= 8000"),
							},
						},
						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
							{
								Type: to.Ptr(armiotoperations.DataflowMappingTypePassThrough),
								Inputs: []*string{
									to.Ptr("*"),
								},
								Output: to.Ptr("*"),
							},
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
					Name:          to.Ptr("destination1"),
					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
						EndpointRef:     to.Ptr("aio-builtin-broker-endpoint"),
						DataDestination: to.Ptr("data/filtered/thermostat"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowClientCreateOrUpdateResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("source1"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
	// 						DataSources: []*string{
	// 							to.Ptr("azure-iot-operations/data/thermostat"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
	// 					Name: to.Ptr("transformation1"),
	// 					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
	// 						Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
	// 							{
	// 								Type: to.Ptr(armiotoperations.FilterTypeFilter),
	// 								Description: to.Ptr("filter-datapoint"),
	// 								Inputs: []*string{
	// 									to.Ptr("temperature.Value"),
	// 									to.Ptr("\"Tag 10\".Value"),
	// 								},
	// 								Expression: to.Ptr("$1 > 9000 && $2 >= 8000"),
	// 							},
	// 						},
	// 						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
	// 							{
	// 								Type: to.Ptr(armiotoperations.DataflowMappingTypePassThrough),
	// 								Inputs: []*string{
	// 									to.Ptr("*"),
	// 								},
	

Output:
Example (DataflowCreateOrUpdateSimpleEventGrid)

Generated from example definition: 2024-11-01/Dataflow_CreateOrUpdate_SimpleEventGrid.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "aio-to-event-grid", armiotoperations.DataflowResource{
		Properties: &armiotoperations.DataflowProperties{
			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
			Operations: []*armiotoperations.DataflowOperation{
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
					Name:          to.Ptr("source1"),
					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
						DataSources: []*string{
							to.Ptr("thermostats/+/telemetry/temperature/#"),
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
					Name:          to.Ptr("destination1"),
					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
						EndpointRef:     to.Ptr("event-grid-endpoint"),
						DataDestination: to.Ptr("factory/telemetry"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowClientCreateOrUpdateResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("source1"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
	// 						DataSources: []*string{
	// 							to.Ptr("thermostats/+/telemetry/temperature/#"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
	// 					Name: to.Ptr("destination1"),
	// 					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
	// 						EndpointRef: to.Ptr("event-grid-endpoint"),
	// 						DataDestination: to.Ptr("factory/telemetry"),
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123/dataflows/resource-name123"),
	// 		Name: to.Ptr("jxhcpwgfkxqasbexkookvxk"),
	// 		Type: to.Ptr("zkuozvgjseokfchkscoswthzjdry"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowCreateOrUpdateSimpleFabric)

Generated from example definition: 2024-11-01/Dataflow_CreateOrUpdate_SimpleFabric.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", "aio-to-fabric", armiotoperations.DataflowResource{
		Properties: &armiotoperations.DataflowProperties{
			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
			Operations: []*armiotoperations.DataflowOperation{
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
					Name:          to.Ptr("source1"),
					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
						DataSources: []*string{
							to.Ptr("azure-iot-operations/data/thermostat"),
						},
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
						SerializationFormat: to.Ptr(armiotoperations.TransformationSerializationFormatParquet),
						SchemaRef:           to.Ptr("aio-sr://exampleNamespace/exmapleParquetSchema:1.0.0"),
					},
				},
				{
					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
					Name:          to.Ptr("destination1"),
					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
						EndpointRef:     to.Ptr("fabric-endpoint"),
						DataDestination: to.Ptr("telemetryTable"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowClientCreateOrUpdateResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("source1"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("aio-builtin-broker-endpoint"),
	// 						DataSources: []*string{
	// 							to.Ptr("azure-iot-operations/data/thermostat"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeBuiltInTransformation),
	// 					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
	// 						SerializationFormat: to.Ptr(armiotoperations.TransformationSerializationFormatParquet),
	// 						SchemaRef: to.Ptr("aio-sr://exampleNamespace/exmapleParquetSchema:1.0.0"),
	// 					},
	// 				},
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeDestination),
	// 					Name: to.Ptr("destination1"),
	// 					DestinationSettings: &armiotoperations.DataflowDestinationOperationSettings{
	// 						EndpointRef: to.Ptr("fabric-endpoint"),
	// 						DataDestination: to.Ptr("telemetryTable"),
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123/dataflows/resource-name123"),
	// 		Name: to.Ptr("jxhcpwgfkxqasbexkookvxk"),
	// 		Type: to.Ptr("zkuozvgjseokfchkscoswthzjdry"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DataflowClient) BeginDelete 

func (client *DataflowClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, dataflowProfileName string, dataflowName string, options *DataflowClientBeginDeleteOptions) (*runtime.Poller[DataflowClientDeleteResponse], error)

BeginDelete - Delete a DataflowResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • dataflowName - Name of Instance dataflowProfile dataflow resource
  • options - DataflowClientBeginDeleteOptions contains the optional parameters for the DataflowClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/Dataflow_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 (*DataflowClient) Get 

func (client *DataflowClient) Get(ctx context.Context, resourceGroupName string, instanceName string, dataflowProfileName string, dataflowName string, options *DataflowClientGetOptions) (DataflowClientGetResponse, error)

Get - Get a DataflowResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • dataflowName - Name of Instance dataflowProfile dataflow resource
  • options - DataflowClientGetOptions contains the optional parameters for the DataflowClient.Get method.
Example

Generated from example definition: 2024-11-01/Dataflow_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDataflowClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", "resource-name123", 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 = armiotoperations.DataflowClientGetResponse{
	// 	DataflowResource: &armiotoperations.DataflowResource{
	// 		Properties: &armiotoperations.DataflowProperties{
	// 			Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 			Operations: []*armiotoperations.DataflowOperation{
	// 				{
	// 					OperationType: to.Ptr(armiotoperations.OperationTypeSource),
	// 					Name: to.Ptr("knnafvkwoeakm"),
	// 					SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
	// 						EndpointRef: to.Ptr("iixotodhvhkkfcfyrkoveslqig"),
	// 						AssetRef: to.Ptr("zayyykwmckaocywdkohmu"),
	// 						SerializationFormat: to.Ptr(armiotoperations.SourceSerializationFormatJSON),
	// 						SchemaRef: to.Ptr("pknmdzqll"),
	// 						DataSources: []*string{
	// 							to.Ptr("chkkpymxhp"),
	// 						},
	// 					},
	// 					BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
	// 						SerializationFormat: to.Ptr(armiotoperations.TransformationSerializationFormatDelta),
	// 						SchemaRef: to.Ptr("mcdc"),
	// 						Datasets: []*armiotoperations.DataflowBuiltInTransformationDataset{
	// 							{
	// 								Key: to.Ptr("qsfqcgxaxnhfumrsdsokwyv"),
	// 								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
	// 								SchemaRef: to.Ptr("n"),
	// 								Inputs: []*string{
	// 									to.Ptr("mosffpsslifkq"),
	// 								},
	// 								Expression: to.Ptr("aatbwomvflemsxialv"),
	// 							},
	// 						},
	// 						Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
	// 							{
	// 								Type: to.Ptr(armiotoperations.FilterTypeFilter),
	// 								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
	// 								Inputs: []*string{
	// 									to.Ptr("sxmjkbntgb"),
	// 								},
	// 								Expression: to.Ptr("n"),
	// 							},
	// 						},
	// 						Map: []*armiotoperations.DataflowBuiltInTransformationMap{
	// 							{
	// 								Type: to.Ptr(armiotoperations.DataflowMappingTypeNewProperties),
	// 								Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
	// 								Inputs: []*string{
	// 									to.Ptr("xsbxuk"),
	// 								},
	// 								Expression: to.Ptr("txoiltogsarwkzalsphvlmt"),
	

Output:

func (*DataflowClient) NewListByResourceGroupPager 

func (client *DataflowClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, dataflowProfileName string, options *DataflowClientListByResourceGroupOptions) *runtime.Pager[DataflowClientListByResourceGroupResponse]

NewListByResourceGroupPager - List DataflowResource resources by DataflowProfileResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • options - DataflowClientListByResourceGroupOptions contains the optional parameters for the DataflowClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/Dataflow_ListByProfileResource_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDataflowClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.DataflowClientListByResourceGroupResponse{
		// 	DataflowResourceListResult: armiotoperations.DataflowResourceListResult{
		// 		Value: []*armiotoperations.DataflowResource{
		// 			{
		// 				Properties: &armiotoperations.DataflowProperties{
		// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 					Operations: []*armiotoperations.DataflowOperation{
		// 						{
		// 							OperationType: to.Ptr(armiotoperations.OperationTypeSource),
		// 							Name: to.Ptr("knnafvkwoeakm"),
		// 							SourceSettings: &armiotoperations.DataflowSourceOperationSettings{
		// 								EndpointRef: to.Ptr("iixotodhvhkkfcfyrkoveslqig"),
		// 								AssetRef: to.Ptr("zayyykwmckaocywdkohmu"),
		// 								SerializationFormat: to.Ptr(armiotoperations.SourceSerializationFormatJSON),
		// 								SchemaRef: to.Ptr("pknmdzqll"),
		// 								DataSources: []*string{
		// 									to.Ptr("chkkpymxhp"),
		// 								},
		// 							},
		// 							BuiltInTransformationSettings: &armiotoperations.DataflowBuiltInTransformationSettings{
		// 								SerializationFormat: to.Ptr(armiotoperations.TransformationSerializationFormatDelta),
		// 								SchemaRef: to.Ptr("mcdc"),
		// 								Datasets: []*armiotoperations.DataflowBuiltInTransformationDataset{
		// 									{
		// 										Key: to.Ptr("qsfqcgxaxnhfumrsdsokwyv"),
		// 										Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
		// 										SchemaRef: to.Ptr("n"),
		// 										Inputs: []*string{
		// 											to.Ptr("mosffpsslifkq"),
		// 										},
		// 										Expression: to.Ptr("aatbwomvflemsxialv"),
		// 									},
		// 								},
		// 								Filter: []*armiotoperations.DataflowBuiltInTransformationFilter{
		// 									{
		// 										Type: to.Ptr(armiotoperations.FilterTypeFilter),
		// 										Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
		// 										Inputs: []*string{
		// 											to.Ptr("sxmjkbntgb"),
		// 										},
		// 										Expression: to.Ptr("n"),
		// 									},
		// 								},
		// 								Map: []*armiotoperations.DataflowBuiltInTransformationMap{
		// 									{
		// 										Type: to.Ptr(armiotoperations.DataflowMappingTypeNewProperties),
		// 										Description: to.Ptr("Lorem ipsum odor amet, consectetuer adipiscing elit."),
		// 										Inputs: []*string{
		// 											to.Ptr("xsbxuk"),
		// 										},
		// 										Expression: to.Ptr("txoiltogsarwkzalsphvlmt"),
		

Output:

type DataflowClientBeginCreateOrUpdateOptions 

type DataflowClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DataflowClientBeginCreateOrUpdateOptions contains the optional parameters for the DataflowClient.BeginCreateOrUpdate method.

type DataflowClientBeginDeleteOptions 

type DataflowClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DataflowClientBeginDeleteOptions contains the optional parameters for the DataflowClient.BeginDelete method.

type DataflowClientCreateOrUpdateResponse 

type DataflowClientCreateOrUpdateResponse struct {
	// Instance dataflowProfile dataflow resource
	DataflowResource
}

DataflowClientCreateOrUpdateResponse contains the response from method DataflowClient.BeginCreateOrUpdate.

type DataflowClientDeleteResponse 

type DataflowClientDeleteResponse struct {
}

DataflowClientDeleteResponse contains the response from method DataflowClient.BeginDelete.

type DataflowClientGetOptions 

type DataflowClientGetOptions struct {
}

DataflowClientGetOptions contains the optional parameters for the DataflowClient.Get method.

type DataflowClientGetResponse 

type DataflowClientGetResponse struct {
	// Instance dataflowProfile dataflow resource
	DataflowResource
}

DataflowClientGetResponse contains the response from method DataflowClient.Get.

type DataflowClientListByResourceGroupOptions 

type DataflowClientListByResourceGroupOptions struct {
}

DataflowClientListByResourceGroupOptions contains the optional parameters for the DataflowClient.NewListByResourceGroupPager method.

type DataflowClientListByResourceGroupResponse 

type DataflowClientListByResourceGroupResponse struct {
	// The response of a DataflowResource list operation.
	DataflowResourceListResult
}

DataflowClientListByResourceGroupResponse contains the response from method DataflowClient.NewListByResourceGroupPager.

type DataflowDestinationOperationSettings 

type DataflowDestinationOperationSettings struct {
	// REQUIRED; Destination location, can be a topic or table name. Supports dynamic values with $topic, $systemProperties, $userProperties,
	// $payload, $context, and $subscription.
	DataDestination *string

	// REQUIRED; Reference to the Endpoint CR. Can be of Broker, Kafka, Fabric, ADLS, ADX type.
	EndpointRef *string
}

DataflowDestinationOperationSettings - Dataflow Destination Operation properties

func (DataflowDestinationOperationSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowDestinationOperationSettings.

func (*DataflowDestinationOperationSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowDestinationOperationSettings.

type DataflowEndpointAuthenticationAccessToken 

type DataflowEndpointAuthenticationAccessToken struct {
	// REQUIRED; Token secret name.
	SecretRef *string
}

DataflowEndpointAuthenticationAccessToken - DataflowEndpoint Authentication Access Token properties

func (DataflowEndpointAuthenticationAccessToken) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointAuthenticationAccessToken.

func (*DataflowEndpointAuthenticationAccessToken) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointAuthenticationAccessToken.

type DataflowEndpointAuthenticationSasl 

type DataflowEndpointAuthenticationSasl struct {
	// REQUIRED; Type of SASL authentication. Can be PLAIN, SCRAM-SHA-256, or SCRAM-SHA-512.
	SaslType *DataflowEndpointAuthenticationSaslType

	// REQUIRED; Token secret name.
	SecretRef *string
}

DataflowEndpointAuthenticationSasl - DataflowEndpoint Authentication Sasl properties

func (DataflowEndpointAuthenticationSasl) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointAuthenticationSasl.

func (*DataflowEndpointAuthenticationSasl) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointAuthenticationSasl.

type DataflowEndpointAuthenticationSaslType 

type DataflowEndpointAuthenticationSaslType string

DataflowEndpointAuthenticationSaslType - DataflowEndpoint Authentication Sasl Type properties 

const (
	// DataflowEndpointAuthenticationSaslTypePlain - PLAIN Type
	DataflowEndpointAuthenticationSaslTypePlain DataflowEndpointAuthenticationSaslType = "Plain"
	// DataflowEndpointAuthenticationSaslTypeScramSHA256 - SCRAM_SHA_256 Type
	DataflowEndpointAuthenticationSaslTypeScramSHA256 DataflowEndpointAuthenticationSaslType = "ScramSha256"
	// DataflowEndpointAuthenticationSaslTypeScramSHA512 - SCRAM_SHA_512 Type
	DataflowEndpointAuthenticationSaslTypeScramSHA512 DataflowEndpointAuthenticationSaslType = "ScramSha512"
)

func PossibleDataflowEndpointAuthenticationSaslTypeValues 

func PossibleDataflowEndpointAuthenticationSaslTypeValues() []DataflowEndpointAuthenticationSaslType

PossibleDataflowEndpointAuthenticationSaslTypeValues returns the possible values for the DataflowEndpointAuthenticationSaslType const type.

type DataflowEndpointAuthenticationServiceAccountToken 

type DataflowEndpointAuthenticationServiceAccountToken struct {
	// REQUIRED; Audience of the service account. Optional, defaults to the broker internal service account audience.
	Audience *string
}

DataflowEndpointAuthenticationServiceAccountToken - Service Account Token for BrokerAuthentication

func (DataflowEndpointAuthenticationServiceAccountToken) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointAuthenticationServiceAccountToken.

func (*DataflowEndpointAuthenticationServiceAccountToken) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointAuthenticationServiceAccountToken.

type DataflowEndpointAuthenticationSystemAssignedManagedIdentity 

type DataflowEndpointAuthenticationSystemAssignedManagedIdentity struct {
	// Audience of the service to authenticate against. Optional; defaults to the audience for Service host configuration.
	Audience *string
}

DataflowEndpointAuthenticationSystemAssignedManagedIdentity - DataflowEndpoint Authentication SystemAssignedManagedIdentity properties

func (DataflowEndpointAuthenticationSystemAssignedManagedIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointAuthenticationSystemAssignedManagedIdentity.

func (*DataflowEndpointAuthenticationSystemAssignedManagedIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointAuthenticationSystemAssignedManagedIdentity.

type DataflowEndpointAuthenticationUserAssignedManagedIdentity 

type DataflowEndpointAuthenticationUserAssignedManagedIdentity struct {
	// REQUIRED; Client ID for the user-assigned managed identity.
	ClientID *string

	// REQUIRED; Tenant ID.
	TenantID *string

	// Resource identifier (application ID URI) of the resource, affixed with the .default suffix.
	Scope *string
}

DataflowEndpointAuthenticationUserAssignedManagedIdentity - DataflowEndpoint Authentication UserAssignedManagedIdentity properties

func (DataflowEndpointAuthenticationUserAssignedManagedIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointAuthenticationUserAssignedManagedIdentity.

func (*DataflowEndpointAuthenticationUserAssignedManagedIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointAuthenticationUserAssignedManagedIdentity.

type DataflowEndpointAuthenticationX509 

type DataflowEndpointAuthenticationX509 struct {
	// REQUIRED; Secret reference of the X.509 certificate.
	SecretRef *string
}

DataflowEndpointAuthenticationX509 - DataflowEndpoint Authentication X509 properties

func (DataflowEndpointAuthenticationX509) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointAuthenticationX509.

func (*DataflowEndpointAuthenticationX509) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointAuthenticationX509.

type DataflowEndpointClient 

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

DataflowEndpointClient contains the methods for the DataflowEndpoint group. Don't use this type directly, use NewDataflowEndpointClient() instead.

func NewDataflowEndpointClient 

func NewDataflowEndpointClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DataflowEndpointClient, error)

NewDataflowEndpointClient creates a new instance of DataflowEndpointClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DataflowEndpointClient) BeginCreateOrUpdate 

func (client *DataflowEndpointClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, dataflowEndpointName string, resource DataflowEndpointResource, options *DataflowEndpointClientBeginCreateOrUpdateOptions) (*runtime.Poller[DataflowEndpointClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a DataflowEndpointResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowEndpointName - Name of Instance dataflowEndpoint resource
  • resource - Resource create parameters.
  • options - DataflowEndpointClientBeginCreateOrUpdateOptions contains the optional parameters for the DataflowEndpointClient.BeginCreateOrUpdate method.
Example (DataflowEndpointCreateOrUpdate)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataExplorer),
			DataExplorerSettings: &armiotoperations.DataflowEndpointDataExplorer{
				Authentication: &armiotoperations.DataflowEndpointDataExplorerAuthentication{
					Method: to.Ptr(armiotoperations.DataExplorerAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
						Audience: to.Ptr("psxomrfbhoflycm"),
					},
					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
						Scope:    to.Ptr("zop"),
						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
					},
				},
				Database: to.Ptr("yqcdpjsifm"),
				Host:     to.Ptr("<cluster>.<region>.kusto.windows.net"),
				Batching: &armiotoperations.BatchingConfiguration{
					LatencySeconds: to.Ptr[int32](9312),
					MaxMessages:    to.Ptr[int32](9028),
				},
			},
			DataLakeStorageSettings: &armiotoperations.DataflowEndpointDataLakeStorage{
				Authentication: &armiotoperations.DataflowEndpointDataLakeStorageAuthentication{
					Method: to.Ptr(armiotoperations.DataLakeStorageAuthMethodSystemAssignedManagedIdentity),
					AccessTokenSettings: &armiotoperations.DataflowEndpointAuthenticationAccessToken{
						SecretRef: to.Ptr("sevriyphcvnlrnfudqzejecwa"),
					},
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
						Audience: to.Ptr("psxomrfbhoflycm"),
					},
					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
						Scope:    to.Ptr("zop"),
						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
					},
				},
				Host: to.Ptr("<account>.blob.core.windows.net"),
				Batching: &armiotoperations.BatchingConfiguration{
					LatencySeconds: to.Ptr[int32](9312),
					MaxMessages:    to.Ptr[int32](9028),
				},
			},
			FabricOneLakeSettings: &armiotoperations.DataflowEndpointFabricOneLake{
				Authentication: &armiotoperations.DataflowEndpointFabricOneLakeAuthentication{
					Method: to.Ptr(armiotoperations.FabricOneLakeAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
						Audience: to.Ptr("psxomrfbhoflycm"),
					},
					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
						Scope:    to.Ptr("zop"),
						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
					},
				},
				Names: &armiotoperations.DataflowEndpointFabricOneLakeNames{
					LakehouseName: to.Ptr("wpeathi"),
					WorkspaceName: to.Ptr("nwgmitkbljztgms"),
				},
				OneLakePathType: to.Ptr(armiotoperations.DataflowEndpointFabricPathTypeFiles),
				Host:            to.Ptr("https://<host>.fabric.microsoft.com"),
				Batching: &armiotoperations.BatchingConfiguration{
					LatencySeconds: to.Ptr[int32](9312),
					MaxMessages:    to.Ptr[int32](9028),
				},
			},
			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
					Method: to.Ptr(armiotoperations.KafkaAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
						Audience: to.Ptr("psxomrfbhoflycm"),
					},
					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
						Scope:    to.Ptr("zop"),
						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
					},
					SaslSettings: &armiotoperations.DataflowEndpointAuthenticationSasl{
						SaslType:  to.Ptr(armiotoperations.DataflowEndpointAuthenticationSaslTypePlain),
						SecretRef: to.Ptr("visyxoztqnylvbyokhtmpdkwes"),
					},
					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
						SecretRef: to.Ptr("afwizrystfslkfqd"),
					},
				},
				ConsumerGroupID: to.Ptr("ukkzcjiyenhxokat"),
				Host:            to.Ptr("pwcqfiqclcgneolpewnyavoulbip"),
				Batching: &armiotoperations.DataflowEndpointKafkaBatching{
					Mode:        to.Ptr(armiotoperations.OperationalModeEnabled),
					LatencyMs:   to.Ptr[int32](3679),
					MaxBytes:    to.Ptr[int32](8887),
					MaxMessages: to.Ptr[int32](2174),
				},
				CopyMqttProperties: to.Ptr(armiotoperations.OperationalModeEnabled),
				Compression:        to.Ptr(armiotoperations.DataflowEndpointKafkaCompressionNone),
				KafkaAcks:          to.Ptr(armiotoperations.DataflowEndpointKafkaAcksZero),
				PartitionStrategy:  to.Ptr(armiotoperations.DataflowEndpointKafkaPartitionStrategyDefault),
				TLS: &armiotoperations.TLSProperties{
					Mode:                             to.Ptr(armiotoperations.OperationalModeEnabled),
					TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
				},
			},
			LocalStorageSettings: &armiotoperations.DataflowEndpointLocalStorage{
				PersistentVolumeClaimRef: to.Ptr("jjwqwvd"),
			},
			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
					Method: to.Ptr(armiotoperations.MqttAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
						Audience: to.Ptr("psxomrfbhoflycm"),
					},
					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
						Scope:    to.Ptr("zop"),
						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
					},
					ServiceAccountTokenSettings: &armiotoperations.DataflowEndpointAuthenticationServiceAccountToken{
						Audience: to.Ptr("ejbklrbxgjaqleoycgpje"),
					},
					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
						SecretRef: to.Ptr("afwizrystfslkfqd"),
					},
				},
				ClientIDPrefix:       to.Ptr("kkljsdxdirfhwxtkavldekeqhv"),
				Host:                 to.Ptr("nyhnxqnbspstctl"),
				Protocol:             to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
				KeepAliveSeconds:     to.Ptr[int32](0),
				Retain:               to.Ptr(armiotoperations.MqttRetainTypeKeep),
				MaxInflightMessages:  to.Ptr[int32](0),
				Qos:                  to.Ptr[int32](1),
				SessionExpirySeconds: to.Ptr[int32](0),
				TLS: &armiotoperations.TLSProperties{
					Mode:                             to.Ptr(armiotoperations.OperationalModeEnabled),
					TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataExplorer),
	// 			DataExplorerSettings: &armiotoperations.DataflowEndpointDataExplorer{
	// 				Authentication: &armiotoperations.DataflowEndpointDataExplorerAuthentication{
	// 					Method: to.Ptr(armiotoperations.DataExplorerAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 				},
	// 				Database: to.Ptr("yqcdpjsifm"),
	// 				Host: to.Ptr("<cluster>.<region>.kusto.windows.net"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](1228),
	// 					MaxMessages: to.Ptr[int32](171),
	// 				},
	// 			},
	// 			DataLakeStorageSettings: &armiotoperations.DataflowEndpointDataLakeStorage{
	// 				Authentication: &armiotoperations.DataflowEndpointDataLakeStorageAuthentication{
	// 					Method: to.Ptr(armiotoperations.DataLakeStorageAuthMethodSystemAssignedManagedIdentity),
	// 					AccessTokenSettings: &armiotoperations.DataflowEndpointAuthenticationAccessToken{
	// 						SecretRef: to.Ptr("sevriyphcvnlrnfudqzejecwa"),
	// 					},
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 				},
	// 				Host: to.Ptr("<account>.blob.core.windows.net"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](1228),
	// 					MaxMessages: to.Ptr[int32](171),
	// 				},
	// 			},
	// 			FabricOneLakeSettings: &armiotoperations.DataflowEndpointFabricOneLake{
	// 				Authentication: &armiotoperations.DataflowEndpointFabricOneLakeAuthentication{
	// 					Method: to.Ptr(armiotoperations.FabricOneLakeAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 				},
	// 				Names: &armiotoperations.DataflowEndpointFabricOneLakeNames{
	// 					LakehouseName: to.Ptr("wpeathi"),
	// 					WorkspaceName: to.Ptr("nwgmitkbljztgms"),
	// 				},
	// 				OneLakePathType: to.Ptr(armiotoperations.DataflowEndpointFabricPathTypeFiles),
	// 				Host: to.Ptr("https://<host>.fabric.microsoft.com"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](1228),
	// 					MaxMessages: to.Ptr[int32](171),
	// 				},
	// 			},
	// 			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
	// 				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
	// 					Method: to.Ptr(armiotoperations.KafkaAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 					SaslSettings: &armiotoperations.DataflowEndpointAuthenticationSasl{
	// 						SaslType: to.Ptr(armiotoperations.DataflowEndpointAuthenticationSaslTypePlain),
	// 						SecretRef: to.Ptr("visyxoztqnylvbyokhtmpdkwes"),
	// 					},
	// 					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
	// 						SecretRef: to.Ptr("afwizrystfslkfqd"),
	// 					},
	// 				},
	// 				ConsumerGroupID: to.Ptr("ukkzcjiyenhxokat"),
	// 				Host: to.Ptr("pwcqfiqclcgneolpewnyavoulbip"),
	// 				Batching: &armiotoperations.DataflowEndpointKafkaBatching{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					LatencyMs: to.Ptr[int32](3679),
	// 					MaxBytes: to.Ptr[int32](8887),
	// 					MaxMessages: to.Ptr[int32](2174),
	// 				},
	// 				CopyMqttProperties: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				Compression: to.Ptr(armiotoperations.DataflowEndpointKafkaCompressionNone),
	// 				KafkaAcks: to.Ptr(armiotoperations.DataflowEndpointKafkaAcksZero),
	// 				PartitionStrategy: to.Ptr(armiotoperations.DataflowEndpointKafkaPartitionStrategyDefault),
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
	// 				},
	// 			},
	// 			LocalStorageSettings: &armiotoperations.DataflowEndpointLocalStorage{
	// 				PersistentVolumeClaimRef: to.Ptr("jjwqwvd"),
	// 			},
	// 			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
	// 				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
	// 					Method: to.Ptr(armiotoperations.MqttAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 					ServiceAccountTokenSettings: &armiotoperations.DataflowEndpointAuthenticationServiceAccountToken{
	// 						Audience: to.Ptr("ejbklrbxgjaqleoycgpje"),
	// 					},
	// 					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
	// 						SecretRef: to.Ptr("afwizrystfslkfqd"),
	// 					},
	// 				},
	// 				ClientIDPrefix: to.Ptr("kkljsdxdirfhwxtkavldekeqhv"),
	// 				Host: to.Ptr("nyhnxqnbspstctl"),
	// 				Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
	// 				KeepAliveSeconds: to.Ptr[int32](0),
	// 				Retain: to.Ptr(armiotoperations.MqttRetainTypeKeep),
	// 				MaxInflightMessages: to.Ptr[int32](0),
	// 				Qos: to.Ptr[int32](1),
	// 				SessionExpirySeconds: to.Ptr[int32](0),
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateAdlsv2)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_ADLSv2.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "adlsv2-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataLakeStorage),
			DataLakeStorageSettings: &armiotoperations.DataflowEndpointDataLakeStorage{
				Host: to.Ptr("example.blob.core.windows.net"),
				Authentication: &armiotoperations.DataflowEndpointDataLakeStorageAuthentication{
					Method: to.Ptr(armiotoperations.DataLakeStorageAuthMethodAccessToken),
					AccessTokenSettings: &armiotoperations.DataflowEndpointAuthenticationAccessToken{
						SecretRef: to.Ptr("my-secret"),
					},
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataLakeStorage),
	// 			DataLakeStorageSettings: &armiotoperations.DataflowEndpointDataLakeStorage{
	// 				Host: to.Ptr("example.blob.core.windows.net"),
	// 				Authentication: &armiotoperations.DataflowEndpointDataLakeStorageAuthentication{
	// 					Method: to.Ptr(armiotoperations.DataLakeStorageAuthMethodAccessToken),
	// 					AccessTokenSettings: &armiotoperations.DataflowEndpointAuthenticationAccessToken{
	// 						SecretRef: to.Ptr("my-secret"),
	// 					},
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateAdx)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_ADX.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "adx-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataExplorer),
			DataExplorerSettings: &armiotoperations.DataflowEndpointDataExplorer{
				Host: to.Ptr("example.westeurope.kusto.windows.net"),
				Authentication: &armiotoperations.DataflowEndpointDataExplorerAuthentication{
					Method:                                to.Ptr(armiotoperations.DataExplorerAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{},
				},
				Database: to.Ptr("example-database"),
				Batching: &armiotoperations.BatchingConfiguration{
					LatencySeconds: to.Ptr[int32](9312),
					MaxMessages:    to.Ptr[int32](9028),
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataExplorer),
	// 			DataExplorerSettings: &armiotoperations.DataflowEndpointDataExplorer{
	// 				Host: to.Ptr("example.westeurope.kusto.windows.net"),
	// 				Authentication: &armiotoperations.DataflowEndpointDataExplorerAuthentication{
	// 					Method: to.Ptr(armiotoperations.DataExplorerAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 					},
	// 				},
	// 				Database: to.Ptr("example-database"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](9312),
	// 					MaxMessages: to.Ptr[int32](9028),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateAio)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_AIO.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "aio-builtin-broker-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeMqtt),
			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
				Host: to.Ptr("aio-broker:18883"),
				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
					ServiceAccountTokenSettings: &armiotoperations.DataflowEndpointAuthenticationServiceAccountToken{
						Audience: to.Ptr("aio-internal"),
					},
				},
				TLS: &armiotoperations.TLSProperties{
					Mode:                             to.Ptr(armiotoperations.OperationalModeEnabled),
					TrustedCaCertificateConfigMapRef: to.Ptr("aio-ca-trust-bundle-test-only"),
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeMqtt),
	// 			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
	// 				Host: to.Ptr("aio-broker:18883"),
	// 				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
	// 					ServiceAccountTokenSettings: &armiotoperations.DataflowEndpointAuthenticationServiceAccountToken{
	// 						Audience: to.Ptr("aio-internal"),
	// 					},
	// 				},
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					TrustedCaCertificateConfigMapRef: to.Ptr("aio-ca-trust-bundle-test-only"),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateEventGrid)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_EventGrid.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "event-grid-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeMqtt),
			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
				Host: to.Ptr("example.westeurope-1.ts.eventgrid.azure.net:8883"),
				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
					Method:                                to.Ptr(armiotoperations.MqttAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{},
				},
				TLS: &armiotoperations.TLSProperties{
					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
				},
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeMqtt),
	// 			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
	// 				Host: to.Ptr("example.westeurope-1.ts.eventgrid.azure.net:8883"),
	// 				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
	// 					Method: to.Ptr(armiotoperations.MqttAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 					},
	// 				},
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateEventHub)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_EventHub.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "event-hub-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeKafka),
			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
				Host: to.Ptr("example.servicebus.windows.net:9093"),
				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
					Method:                                to.Ptr(armiotoperations.KafkaAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{},
				},
				TLS: &armiotoperations.TLSProperties{
					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
				},
				ConsumerGroupID: to.Ptr("aiodataflows"),
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeKafka),
	// 			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
	// 				Host: to.Ptr("example.servicebus.windows.net:9093"),
	// 				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
	// 					Method: to.Ptr(armiotoperations.KafkaAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 					},
	// 				},
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				},
	// 				ConsumerGroupID: to.Ptr("aiodataflows"),
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateFabric)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_Fabric.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "fabric-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeFabricOneLake),
			FabricOneLakeSettings: &armiotoperations.DataflowEndpointFabricOneLake{
				Host: to.Ptr("onelake.dfs.fabric.microsoft.com"),
				Authentication: &armiotoperations.DataflowEndpointFabricOneLakeAuthentication{
					Method:                                to.Ptr(armiotoperations.FabricOneLakeAuthMethodSystemAssignedManagedIdentity),
					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{},
				},
				Names: &armiotoperations.DataflowEndpointFabricOneLakeNames{
					WorkspaceName: to.Ptr("example-workspace"),
					LakehouseName: to.Ptr("example-lakehouse"),
				},
				OneLakePathType: to.Ptr(armiotoperations.DataflowEndpointFabricPathTypeTables),
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeFabricOneLake),
	// 			FabricOneLakeSettings: &armiotoperations.DataflowEndpointFabricOneLake{
	// 				Host: to.Ptr("onelake.dfs.fabric.microsoft.com"),
	// 				Authentication: &armiotoperations.DataflowEndpointFabricOneLakeAuthentication{
	// 					Method: to.Ptr(armiotoperations.FabricOneLakeAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 					},
	// 				},
	// 				Names: &armiotoperations.DataflowEndpointFabricOneLakeNames{
	// 					WorkspaceName: to.Ptr("example-workspace"),
	// 					LakehouseName: to.Ptr("example-lakehouse"),
	// 				},
	// 				OneLakePathType: to.Ptr(armiotoperations.DataflowEndpointFabricPathTypeTables),
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateKafka)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_Kafka.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "generic-kafka-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeKafka),
			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
				Host: to.Ptr("example.kafka.local:9093"),
				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
					Method: to.Ptr(armiotoperations.KafkaAuthMethodSasl),
					SaslSettings: &armiotoperations.DataflowEndpointAuthenticationSasl{
						SaslType:  to.Ptr(armiotoperations.DataflowEndpointAuthenticationSaslTypePlain),
						SecretRef: to.Ptr("my-secret"),
					},
				},
				TLS: &armiotoperations.TLSProperties{
					Mode:                             to.Ptr(armiotoperations.OperationalModeEnabled),
					TrustedCaCertificateConfigMapRef: to.Ptr("ca-certificates"),
				},
				ConsumerGroupID: to.Ptr("dataflows"),
				Compression:     to.Ptr(armiotoperations.DataflowEndpointKafkaCompressionGzip),
				Batching: &armiotoperations.DataflowEndpointKafkaBatching{
					Mode:        to.Ptr(armiotoperations.OperationalModeEnabled),
					LatencyMs:   to.Ptr[int32](5),
					MaxBytes:    to.Ptr[int32](1000000),
					MaxMessages: to.Ptr[int32](100000),
				},
				PartitionStrategy:    to.Ptr(armiotoperations.DataflowEndpointKafkaPartitionStrategyDefault),
				KafkaAcks:            to.Ptr(armiotoperations.DataflowEndpointKafkaAcksAll),
				CopyMqttProperties:   to.Ptr(armiotoperations.OperationalModeEnabled),
				CloudEventAttributes: to.Ptr(armiotoperations.CloudEventAttributeTypePropagate),
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeKafka),
	// 			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
	// 				Host: to.Ptr("example.kafka.local:9093"),
	// 				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
	// 					Method: to.Ptr(armiotoperations.KafkaAuthMethodSasl),
	// 					SaslSettings: &armiotoperations.DataflowEndpointAuthenticationSasl{
	// 						SaslType: to.Ptr(armiotoperations.DataflowEndpointAuthenticationSaslTypePlain),
	// 						SecretRef: to.Ptr("my-secret"),
	// 					},
	// 				},
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					TrustedCaCertificateConfigMapRef: to.Ptr("ca-certificates"),
	// 				},
	// 				ConsumerGroupID: to.Ptr("dataflows"),
	// 				Compression: to.Ptr(armiotoperations.DataflowEndpointKafkaCompressionGzip),
	// 				Batching: &armiotoperations.DataflowEndpointKafkaBatching{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					LatencyMs: to.Ptr[int32](5),
	// 					MaxBytes: to.Ptr[int32](1000000),
	// 					MaxMessages: to.Ptr[int32](100000),
	// 				},
	// 				PartitionStrategy: to.Ptr(armiotoperations.DataflowEndpointKafkaPartitionStrategyDefault),
	// 				KafkaAcks: to.Ptr(armiotoperations.DataflowEndpointKafkaAcksAll),
	// 				CopyMqttProperties: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				CloudEventAttributes: to.Ptr(armiotoperations.CloudEventAttributeTypePropagate),
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateLocalStorage)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_LocalStorage.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "local-storage-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeLocalStorage),
			LocalStorageSettings: &armiotoperations.DataflowEndpointLocalStorage{
				PersistentVolumeClaimRef: to.Ptr("example-pvc"),
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeLocalStorage),
	// 			LocalStorageSettings: &armiotoperations.DataflowEndpointLocalStorage{
	// 				PersistentVolumeClaimRef: to.Ptr("example-pvc"),
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowEndpointCreateOrUpdateMqtt)

Generated from example definition: 2024-11-01/DataflowEndpoint_CreateOrUpdate_MQTT.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "generic-mqtt-broker-endpoint", armiotoperations.DataflowEndpointResource{
		Properties: &armiotoperations.DataflowEndpointProperties{
			EndpointType: to.Ptr(armiotoperations.EndpointTypeMqtt),
			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
				Host: to.Ptr("example.broker.local:1883"),
				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
					Method: to.Ptr(armiotoperations.MqttAuthMethodX509Certificate),
					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
						SecretRef: to.Ptr("example-secret"),
					},
				},
				TLS: &armiotoperations.TLSProperties{
					Mode: to.Ptr(armiotoperations.OperationalModeDisabled),
				},
				ClientIDPrefix:       to.Ptr("factory-gateway"),
				Retain:               to.Ptr(armiotoperations.MqttRetainTypeKeep),
				SessionExpirySeconds: to.Ptr[int32](3600),
				Qos:                  to.Ptr[int32](1),
				Protocol:             to.Ptr(armiotoperations.BrokerProtocolTypeWebSockets),
				MaxInflightMessages:  to.Ptr[int32](100),
				KeepAliveSeconds:     to.Ptr[int32](60),
			},
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowEndpointClientCreateOrUpdateResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeMqtt),
	// 			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
	// 				Host: to.Ptr("example.broker.local:1883"),
	// 				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
	// 					Method: to.Ptr(armiotoperations.MqttAuthMethodX509Certificate),
	// 					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
	// 						SecretRef: to.Ptr("example-secret"),
	// 					},
	// 				},
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeDisabled),
	// 				},
	// 				ClientIDPrefix: to.Ptr("factory-gateway"),
	// 				Retain: to.Ptr(armiotoperations.MqttRetainTypeKeep),
	// 				SessionExpirySeconds: to.Ptr[int32](3600),
	// 				Qos: to.Ptr[int32](1),
	// 				Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeWebSockets),
	// 				MaxInflightMessages: to.Ptr[int32](100),
	// 				KeepAliveSeconds: to.Ptr[int32](60),
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DataflowEndpointClient) BeginDelete 

func (client *DataflowEndpointClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, dataflowEndpointName string, options *DataflowEndpointClientBeginDeleteOptions) (*runtime.Poller[DataflowEndpointClientDeleteResponse], error)

BeginDelete - Delete a DataflowEndpointResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowEndpointName - Name of Instance dataflowEndpoint resource
  • options - DataflowEndpointClientBeginDeleteOptions contains the optional parameters for the DataflowEndpointClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/DataflowEndpoint_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowEndpointClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", 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 (*DataflowEndpointClient) Get 

func (client *DataflowEndpointClient) Get(ctx context.Context, resourceGroupName string, instanceName string, dataflowEndpointName string, options *DataflowEndpointClientGetOptions) (DataflowEndpointClientGetResponse, error)

Get - Get a DataflowEndpointResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowEndpointName - Name of Instance dataflowEndpoint resource
  • options - DataflowEndpointClientGetOptions contains the optional parameters for the DataflowEndpointClient.Get method.
Example

Generated from example definition: 2024-11-01/DataflowEndpoint_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDataflowEndpointClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.DataflowEndpointClientGetResponse{
	// 	DataflowEndpointResource: &armiotoperations.DataflowEndpointResource{
	// 		Properties: &armiotoperations.DataflowEndpointProperties{
	// 			EndpointType: to.Ptr(armiotoperations.EndpointTypeDataExplorer),
	// 			DataExplorerSettings: &armiotoperations.DataflowEndpointDataExplorer{
	// 				Authentication: &armiotoperations.DataflowEndpointDataExplorerAuthentication{
	// 					Method: to.Ptr(armiotoperations.DataExplorerAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 				},
	// 				Database: to.Ptr("yqcdpjsifm"),
	// 				Host: to.Ptr("<cluster>.<region>.kusto.windows.net"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](1228),
	// 					MaxMessages: to.Ptr[int32](171),
	// 				},
	// 			},
	// 			DataLakeStorageSettings: &armiotoperations.DataflowEndpointDataLakeStorage{
	// 				Authentication: &armiotoperations.DataflowEndpointDataLakeStorageAuthentication{
	// 					Method: to.Ptr(armiotoperations.DataLakeStorageAuthMethodSystemAssignedManagedIdentity),
	// 					AccessTokenSettings: &armiotoperations.DataflowEndpointAuthenticationAccessToken{
	// 						SecretRef: to.Ptr("sevriyphcvnlrnfudqzejecwa"),
	// 					},
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 				},
	// 				Host: to.Ptr("<account>.blob.core.windows.net"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](1228),
	// 					MaxMessages: to.Ptr[int32](171),
	// 				},
	// 			},
	// 			FabricOneLakeSettings: &armiotoperations.DataflowEndpointFabricOneLake{
	// 				Authentication: &armiotoperations.DataflowEndpointFabricOneLakeAuthentication{
	// 					Method: to.Ptr(armiotoperations.FabricOneLakeAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 				},
	// 				Names: &armiotoperations.DataflowEndpointFabricOneLakeNames{
	// 					LakehouseName: to.Ptr("wpeathi"),
	// 					WorkspaceName: to.Ptr("nwgmitkbljztgms"),
	// 				},
	// 				OneLakePathType: to.Ptr(armiotoperations.DataflowEndpointFabricPathTypeFiles),
	// 				Host: to.Ptr("https://<host>.fabric.microsoft.com"),
	// 				Batching: &armiotoperations.BatchingConfiguration{
	// 					LatencySeconds: to.Ptr[int32](1228),
	// 					MaxMessages: to.Ptr[int32](171),
	// 				},
	// 			},
	// 			KafkaSettings: &armiotoperations.DataflowEndpointKafka{
	// 				Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
	// 					Method: to.Ptr(armiotoperations.KafkaAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 					SaslSettings: &armiotoperations.DataflowEndpointAuthenticationSasl{
	// 						SaslType: to.Ptr(armiotoperations.DataflowEndpointAuthenticationSaslTypePlain),
	// 						SecretRef: to.Ptr("visyxoztqnylvbyokhtmpdkwes"),
	// 					},
	// 					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
	// 						SecretRef: to.Ptr("afwizrystfslkfqd"),
	// 					},
	// 				},
	// 				ConsumerGroupID: to.Ptr("ukkzcjiyenhxokat"),
	// 				Host: to.Ptr("pwcqfiqclcgneolpewnyavoulbip"),
	// 				Batching: &armiotoperations.DataflowEndpointKafkaBatching{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					LatencyMs: to.Ptr[int32](3679),
	// 					MaxBytes: to.Ptr[int32](8887),
	// 					MaxMessages: to.Ptr[int32](2174),
	// 				},
	// 				CopyMqttProperties: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 				Compression: to.Ptr(armiotoperations.DataflowEndpointKafkaCompressionNone),
	// 				KafkaAcks: to.Ptr(armiotoperations.DataflowEndpointKafkaAcksZero),
	// 				PartitionStrategy: to.Ptr(armiotoperations.DataflowEndpointKafkaPartitionStrategyDefault),
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
	// 				},
	// 			},
	// 			LocalStorageSettings: &armiotoperations.DataflowEndpointLocalStorage{
	// 				PersistentVolumeClaimRef: to.Ptr("jjwqwvd"),
	// 			},
	// 			MqttSettings: &armiotoperations.DataflowEndpointMqtt{
	// 				Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
	// 					Method: to.Ptr(armiotoperations.MqttAuthMethodSystemAssignedManagedIdentity),
	// 					SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
	// 						Audience: to.Ptr("psxomrfbhoflycm"),
	// 					},
	// 					UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
	// 						ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
	// 						Scope: to.Ptr("zop"),
	// 						TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 					},
	// 					ServiceAccountTokenSettings: &armiotoperations.DataflowEndpointAuthenticationServiceAccountToken{
	// 						Audience: to.Ptr("ejbklrbxgjaqleoycgpje"),
	// 					},
	// 					X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
	// 						SecretRef: to.Ptr("afwizrystfslkfqd"),
	// 					},
	// 				},
	// 				ClientIDPrefix: to.Ptr("kkljsdxdirfhwxtkavldekeqhv"),
	// 				Host: to.Ptr("nyhnxqnbspstctl"),
	// 				Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
	// 				KeepAliveSeconds: to.Ptr[int32](0),
	// 				Retain: to.Ptr(armiotoperations.MqttRetainTypeKeep),
	// 				MaxInflightMessages: to.Ptr[int32](0),
	// 				Qos: to.Ptr[int32](1),
	// 				SessionExpirySeconds: to.Ptr[int32](0),
	// 				TLS: &armiotoperations.TLSProperties{
	// 					Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
	// 					TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
	// 		Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
	// 		Type: to.Ptr("iay"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DataflowEndpointClient) NewListByResourceGroupPager 

func (client *DataflowEndpointClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, options *DataflowEndpointClientListByResourceGroupOptions) *runtime.Pager[DataflowEndpointClientListByResourceGroupResponse]

NewListByResourceGroupPager - List DataflowEndpointResource resources by InstanceResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • options - DataflowEndpointClientListByResourceGroupOptions contains the optional parameters for the DataflowEndpointClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/DataflowEndpoint_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDataflowEndpointClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", 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 = armiotoperations.DataflowEndpointClientListByResourceGroupResponse{
		// 	DataflowEndpointResourceListResult: armiotoperations.DataflowEndpointResourceListResult{
		// 		Value: []*armiotoperations.DataflowEndpointResource{
		// 			{
		// 				Properties: &armiotoperations.DataflowEndpointProperties{
		// 					EndpointType: to.Ptr(armiotoperations.EndpointTypeDataExplorer),
		// 					DataExplorerSettings: &armiotoperations.DataflowEndpointDataExplorer{
		// 						Authentication: &armiotoperations.DataflowEndpointDataExplorerAuthentication{
		// 							Method: to.Ptr(armiotoperations.DataExplorerAuthMethodSystemAssignedManagedIdentity),
		// 							SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
		// 								Audience: to.Ptr("psxomrfbhoflycm"),
		// 							},
		// 							UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
		// 								ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
		// 								Scope: to.Ptr("zop"),
		// 								TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 							},
		// 						},
		// 						Database: to.Ptr("yqcdpjsifm"),
		// 						Host: to.Ptr("<cluster>.<region>.kusto.windows.net"),
		// 						Batching: &armiotoperations.BatchingConfiguration{
		// 							LatencySeconds: to.Ptr[int32](1228),
		// 							MaxMessages: to.Ptr[int32](171),
		// 						},
		// 					},
		// 					DataLakeStorageSettings: &armiotoperations.DataflowEndpointDataLakeStorage{
		// 						Authentication: &armiotoperations.DataflowEndpointDataLakeStorageAuthentication{
		// 							Method: to.Ptr(armiotoperations.DataLakeStorageAuthMethodSystemAssignedManagedIdentity),
		// 							AccessTokenSettings: &armiotoperations.DataflowEndpointAuthenticationAccessToken{
		// 								SecretRef: to.Ptr("sevriyphcvnlrnfudqzejecwa"),
		// 							},
		// 							SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
		// 								Audience: to.Ptr("psxomrfbhoflycm"),
		// 							},
		// 							UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
		// 								ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
		// 								Scope: to.Ptr("zop"),
		// 								TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 							},
		// 						},
		// 						Host: to.Ptr("<account>.blob.core.windows.net"),
		// 						Batching: &armiotoperations.BatchingConfiguration{
		// 							LatencySeconds: to.Ptr[int32](1228),
		// 							MaxMessages: to.Ptr[int32](171),
		// 						},
		// 					},
		// 					FabricOneLakeSettings: &armiotoperations.DataflowEndpointFabricOneLake{
		// 						Authentication: &armiotoperations.DataflowEndpointFabricOneLakeAuthentication{
		// 							Method: to.Ptr(armiotoperations.FabricOneLakeAuthMethodSystemAssignedManagedIdentity),
		// 							SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
		// 								Audience: to.Ptr("psxomrfbhoflycm"),
		// 							},
		// 							UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
		// 								ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
		// 								Scope: to.Ptr("zop"),
		// 								TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 							},
		// 						},
		// 						Names: &armiotoperations.DataflowEndpointFabricOneLakeNames{
		// 							LakehouseName: to.Ptr("wpeathi"),
		// 							WorkspaceName: to.Ptr("nwgmitkbljztgms"),
		// 						},
		// 						OneLakePathType: to.Ptr(armiotoperations.DataflowEndpointFabricPathTypeFiles),
		// 						Host: to.Ptr("https://<host>.fabric.microsoft.com"),
		// 						Batching: &armiotoperations.BatchingConfiguration{
		// 							LatencySeconds: to.Ptr[int32](1228),
		// 							MaxMessages: to.Ptr[int32](171),
		// 						},
		// 					},
		// 					KafkaSettings: &armiotoperations.DataflowEndpointKafka{
		// 						Authentication: &armiotoperations.DataflowEndpointKafkaAuthentication{
		// 							Method: to.Ptr(armiotoperations.KafkaAuthMethodSystemAssignedManagedIdentity),
		// 							SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
		// 								Audience: to.Ptr("psxomrfbhoflycm"),
		// 							},
		// 							UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
		// 								ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
		// 								Scope: to.Ptr("zop"),
		// 								TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 							},
		// 							SaslSettings: &armiotoperations.DataflowEndpointAuthenticationSasl{
		// 								SaslType: to.Ptr(armiotoperations.DataflowEndpointAuthenticationSaslTypePlain),
		// 								SecretRef: to.Ptr("visyxoztqnylvbyokhtmpdkwes"),
		// 							},
		// 							X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
		// 								SecretRef: to.Ptr("afwizrystfslkfqd"),
		// 							},
		// 						},
		// 						ConsumerGroupID: to.Ptr("ukkzcjiyenhxokat"),
		// 						Host: to.Ptr("pwcqfiqclcgneolpewnyavoulbip"),
		// 						Batching: &armiotoperations.DataflowEndpointKafkaBatching{
		// 							Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 							LatencyMs: to.Ptr[int32](3679),
		// 							MaxBytes: to.Ptr[int32](8887),
		// 							MaxMessages: to.Ptr[int32](2174),
		// 						},
		// 						CopyMqttProperties: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 						Compression: to.Ptr(armiotoperations.DataflowEndpointKafkaCompressionNone),
		// 						KafkaAcks: to.Ptr(armiotoperations.DataflowEndpointKafkaAcksZero),
		// 						PartitionStrategy: to.Ptr(armiotoperations.DataflowEndpointKafkaPartitionStrategyDefault),
		// 						TLS: &armiotoperations.TLSProperties{
		// 							Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 							TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
		// 						},
		// 					},
		// 					LocalStorageSettings: &armiotoperations.DataflowEndpointLocalStorage{
		// 						PersistentVolumeClaimRef: to.Ptr("jjwqwvd"),
		// 					},
		// 					MqttSettings: &armiotoperations.DataflowEndpointMqtt{
		// 						Authentication: &armiotoperations.DataflowEndpointMqttAuthentication{
		// 							Method: to.Ptr(armiotoperations.MqttAuthMethodSystemAssignedManagedIdentity),
		// 							SystemAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationSystemAssignedManagedIdentity{
		// 								Audience: to.Ptr("psxomrfbhoflycm"),
		// 							},
		// 							UserAssignedManagedIdentitySettings: &armiotoperations.DataflowEndpointAuthenticationUserAssignedManagedIdentity{
		// 								ClientID: to.Ptr("fb90f267-8872-431a-a76a-a1cec5d3c4d2"),
		// 								Scope: to.Ptr("zop"),
		// 								TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 							},
		// 							ServiceAccountTokenSettings: &armiotoperations.DataflowEndpointAuthenticationServiceAccountToken{
		// 								Audience: to.Ptr("ejbklrbxgjaqleoycgpje"),
		// 							},
		// 							X509CertificateSettings: &armiotoperations.DataflowEndpointAuthenticationX509{
		// 								SecretRef: to.Ptr("afwizrystfslkfqd"),
		// 							},
		// 						},
		// 						ClientIDPrefix: to.Ptr("kkljsdxdirfhwxtkavldekeqhv"),
		// 						Host: to.Ptr("nyhnxqnbspstctl"),
		// 						Protocol: to.Ptr(armiotoperations.BrokerProtocolTypeMqtt),
		// 						KeepAliveSeconds: to.Ptr[int32](0),
		// 						Retain: to.Ptr(armiotoperations.MqttRetainTypeKeep),
		// 						MaxInflightMessages: to.Ptr[int32](0),
		// 						Qos: to.Ptr[int32](1),
		// 						SessionExpirySeconds: to.Ptr[int32](0),
		// 						TLS: &armiotoperations.TLSProperties{
		// 							Mode: to.Ptr(armiotoperations.OperationalModeEnabled),
		// 							TrustedCaCertificateConfigMapRef: to.Ptr("tectjjvukvelsreihwadh"),
		// 						},
		// 					},
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowEndpoints/resource-name123"),
		// 				Name: to.Ptr("zyhxscudobzfacetvgyjiav"),
		// 				Type: to.Ptr("iay"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type DataflowEndpointClientBeginCreateOrUpdateOptions 

type DataflowEndpointClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DataflowEndpointClientBeginCreateOrUpdateOptions contains the optional parameters for the DataflowEndpointClient.BeginCreateOrUpdate method.

type DataflowEndpointClientBeginDeleteOptions 

type DataflowEndpointClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DataflowEndpointClientBeginDeleteOptions contains the optional parameters for the DataflowEndpointClient.BeginDelete method.

type DataflowEndpointClientCreateOrUpdateResponse 

type DataflowEndpointClientCreateOrUpdateResponse struct {
	// Instance dataflowEndpoint resource
	DataflowEndpointResource
}

DataflowEndpointClientCreateOrUpdateResponse contains the response from method DataflowEndpointClient.BeginCreateOrUpdate.

type DataflowEndpointClientDeleteResponse 

type DataflowEndpointClientDeleteResponse struct {
}

DataflowEndpointClientDeleteResponse contains the response from method DataflowEndpointClient.BeginDelete.

type DataflowEndpointClientGetOptions 

type DataflowEndpointClientGetOptions struct {
}

DataflowEndpointClientGetOptions contains the optional parameters for the DataflowEndpointClient.Get method.

type DataflowEndpointClientGetResponse 

type DataflowEndpointClientGetResponse struct {
	// Instance dataflowEndpoint resource
	DataflowEndpointResource
}

DataflowEndpointClientGetResponse contains the response from method DataflowEndpointClient.Get.

type DataflowEndpointClientListByResourceGroupOptions 

type DataflowEndpointClientListByResourceGroupOptions struct {
}

DataflowEndpointClientListByResourceGroupOptions contains the optional parameters for the DataflowEndpointClient.NewListByResourceGroupPager method.

type DataflowEndpointClientListByResourceGroupResponse 

type DataflowEndpointClientListByResourceGroupResponse struct {
	// The response of a DataflowEndpointResource list operation.
	DataflowEndpointResourceListResult
}

DataflowEndpointClientListByResourceGroupResponse contains the response from method DataflowEndpointClient.NewListByResourceGroupPager.

type DataflowEndpointDataExplorer 

type DataflowEndpointDataExplorer struct {
	// REQUIRED; Authentication configuration. NOTE - only authentication property is allowed per entry.
	Authentication *DataflowEndpointDataExplorerAuthentication

	// REQUIRED; Database name.
	Database *string

	// REQUIRED; Host of the Azure Data Explorer in the form of <cluster>.<region>.kusto.windows.net .
	Host *string

	// Azure Data Explorer endpoint batching configuration.
	Batching *BatchingConfiguration
}

DataflowEndpointDataExplorer - Azure Data Explorer endpoint properties

func (DataflowEndpointDataExplorer) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointDataExplorer.

func (*DataflowEndpointDataExplorer) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointDataExplorer.

type DataflowEndpointDataExplorerAuthentication 

type DataflowEndpointDataExplorerAuthentication struct {
	// REQUIRED; Mode of Authentication.
	Method *DataExplorerAuthMethod

	// System-assigned managed identity authentication.
	SystemAssignedManagedIdentitySettings *DataflowEndpointAuthenticationSystemAssignedManagedIdentity

	// User-assigned managed identity authentication.
	UserAssignedManagedIdentitySettings *DataflowEndpointAuthenticationUserAssignedManagedIdentity
}

DataflowEndpointDataExplorerAuthentication - Azure Data Explorer Authentication properties. NOTE - only authentication property is allowed per entry.

func (DataflowEndpointDataExplorerAuthentication) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointDataExplorerAuthentication.

func (*DataflowEndpointDataExplorerAuthentication) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointDataExplorerAuthentication.

type DataflowEndpointDataLakeStorage 

type DataflowEndpointDataLakeStorage struct {
	// REQUIRED; Authentication configuration. NOTE - only authentication property is allowed per entry.
	Authentication *DataflowEndpointDataLakeStorageAuthentication

	// REQUIRED; Host of the Azure Data Lake in the form of <account>.blob.core.windows.net .
	Host *string

	// Azure Data Lake endpoint batching configuration.
	Batching *BatchingConfiguration
}

DataflowEndpointDataLakeStorage - Azure Data Lake endpoint properties

func (DataflowEndpointDataLakeStorage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointDataLakeStorage.

func (*DataflowEndpointDataLakeStorage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointDataLakeStorage.

type DataflowEndpointDataLakeStorageAuthentication 

type DataflowEndpointDataLakeStorageAuthentication struct {
	// REQUIRED; Mode of Authentication.
	Method *DataLakeStorageAuthMethod

	// SAS token authentication.
	AccessTokenSettings *DataflowEndpointAuthenticationAccessToken

	// System-assigned managed identity authentication.
	SystemAssignedManagedIdentitySettings *DataflowEndpointAuthenticationSystemAssignedManagedIdentity

	// User-assigned managed identity authentication.
	UserAssignedManagedIdentitySettings *DataflowEndpointAuthenticationUserAssignedManagedIdentity
}

DataflowEndpointDataLakeStorageAuthentication - Azure Data Lake endpoint Authentication properties. NOTE Enum - Only one method is supported for one entry

func (DataflowEndpointDataLakeStorageAuthentication) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointDataLakeStorageAuthentication.

func (*DataflowEndpointDataLakeStorageAuthentication) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointDataLakeStorageAuthentication.

type DataflowEndpointFabricOneLake 

type DataflowEndpointFabricOneLake struct {
	// REQUIRED; Authentication configuration. NOTE - only one authentication property is allowed per entry.
	Authentication *DataflowEndpointFabricOneLakeAuthentication

	// REQUIRED; Host of the Microsoft Fabric in the form of https://<host>.fabric.microsoft.com.
	Host *string

	// REQUIRED; Names of the workspace and lakehouse.
	Names *DataflowEndpointFabricOneLakeNames

	// REQUIRED; Type of location of the data in the workspace. Can be either tables or files.
	OneLakePathType *DataflowEndpointFabricPathType

	// Batching configuration.
	Batching *BatchingConfiguration
}

DataflowEndpointFabricOneLake - Microsoft Fabric endpoint properties

func (DataflowEndpointFabricOneLake) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointFabricOneLake.

func (*DataflowEndpointFabricOneLake) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointFabricOneLake.

type DataflowEndpointFabricOneLakeAuthentication 

type DataflowEndpointFabricOneLakeAuthentication struct {
	// REQUIRED; Mode of Authentication.
	Method *FabricOneLakeAuthMethod

	// System-assigned managed identity authentication.
	SystemAssignedManagedIdentitySettings *DataflowEndpointAuthenticationSystemAssignedManagedIdentity

	// User-assigned managed identity authentication.
	UserAssignedManagedIdentitySettings *DataflowEndpointAuthenticationUserAssignedManagedIdentity
}

DataflowEndpointFabricOneLakeAuthentication - Microsoft Fabric endpoint. Authentication properties. NOTE - Only one method is supported for one entry

func (DataflowEndpointFabricOneLakeAuthentication) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointFabricOneLakeAuthentication.

func (*DataflowEndpointFabricOneLakeAuthentication) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointFabricOneLakeAuthentication.

type DataflowEndpointFabricOneLakeNames 

type DataflowEndpointFabricOneLakeNames struct {
	// REQUIRED; Lakehouse name.
	LakehouseName *string

	// REQUIRED; Workspace name.
	WorkspaceName *string
}

DataflowEndpointFabricOneLakeNames - Microsoft Fabric endpoint Names properties

func (DataflowEndpointFabricOneLakeNames) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointFabricOneLakeNames.

func (*DataflowEndpointFabricOneLakeNames) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointFabricOneLakeNames.

type DataflowEndpointFabricPathType 

type DataflowEndpointFabricPathType string

DataflowEndpointFabricPathType - DataflowEndpoint Fabric Path Type properties 

const (
	// DataflowEndpointFabricPathTypeFiles - FILES Type
	DataflowEndpointFabricPathTypeFiles DataflowEndpointFabricPathType = "Files"
	// DataflowEndpointFabricPathTypeTables - TABLES Type
	DataflowEndpointFabricPathTypeTables DataflowEndpointFabricPathType = "Tables"
)

func PossibleDataflowEndpointFabricPathTypeValues 

func PossibleDataflowEndpointFabricPathTypeValues() []DataflowEndpointFabricPathType

PossibleDataflowEndpointFabricPathTypeValues returns the possible values for the DataflowEndpointFabricPathType const type.

type DataflowEndpointKafka 

type DataflowEndpointKafka struct {
	// REQUIRED; Authentication configuration. NOTE - only authentication property is allowed per entry.
	Authentication *DataflowEndpointKafkaAuthentication

	// REQUIRED; Kafka endpoint host.
	Host *string

	// Batching configuration.
	Batching *DataflowEndpointKafkaBatching

	// Cloud event mapping config.
	CloudEventAttributes *CloudEventAttributeType

	// Compression. Can be none, gzip, lz4, or snappy. No effect if the endpoint is used as a source.
	Compression *DataflowEndpointKafkaCompression

	// Consumer group ID.
	ConsumerGroupID *string

	// Copy Broker properties. No effect if the endpoint is used as a source or if the dataflow doesn't have an Broker source.
	CopyMqttProperties *OperationalMode

	// Kafka acks. Can be all, one, or zero. No effect if the endpoint is used as a source.
	KafkaAcks *DataflowEndpointKafkaAcks

	// Partition handling strategy. Can be default or static. No effect if the endpoint is used as a source.
	PartitionStrategy *DataflowEndpointKafkaPartitionStrategy

	// TLS configuration.
	TLS *TLSProperties
}

DataflowEndpointKafka - Kafka endpoint properties

func (DataflowEndpointKafka) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointKafka.

func (*DataflowEndpointKafka) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointKafka.

type DataflowEndpointKafkaAcks 

type DataflowEndpointKafkaAcks string

DataflowEndpointKafkaAcks - DataflowEndpoint Kafka Acks properties 

const (
	// DataflowEndpointKafkaAcksAll - ALL Option
	DataflowEndpointKafkaAcksAll DataflowEndpointKafkaAcks = "All"
	// DataflowEndpointKafkaAcksOne - ONE Option
	DataflowEndpointKafkaAcksOne DataflowEndpointKafkaAcks = "One"
	// DataflowEndpointKafkaAcksZero - ZERO Option
	DataflowEndpointKafkaAcksZero DataflowEndpointKafkaAcks = "Zero"
)

func PossibleDataflowEndpointKafkaAcksValues 

func PossibleDataflowEndpointKafkaAcksValues() []DataflowEndpointKafkaAcks

PossibleDataflowEndpointKafkaAcksValues returns the possible values for the DataflowEndpointKafkaAcks const type.

type DataflowEndpointKafkaAuthentication 

type DataflowEndpointKafkaAuthentication struct {
	// REQUIRED; Mode of Authentication.
	Method *KafkaAuthMethod

	// SASL authentication.
	SaslSettings *DataflowEndpointAuthenticationSasl

	// System-assigned managed identity authentication.
	SystemAssignedManagedIdentitySettings *DataflowEndpointAuthenticationSystemAssignedManagedIdentity

	// User-assigned managed identity authentication.
	UserAssignedManagedIdentitySettings *DataflowEndpointAuthenticationUserAssignedManagedIdentity

	// X.509 certificate authentication.
	X509CertificateSettings *DataflowEndpointAuthenticationX509
}

DataflowEndpointKafkaAuthentication - Kafka endpoint Authentication properties. NOTE - only authentication property is allowed per entry

func (DataflowEndpointKafkaAuthentication) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointKafkaAuthentication.

func (*DataflowEndpointKafkaAuthentication) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointKafkaAuthentication.

type DataflowEndpointKafkaBatching 

type DataflowEndpointKafkaBatching struct {
	// Batching latency in milliseconds.
	LatencyMs *int32

	// Maximum number of bytes in a batch.
	MaxBytes *int32

	// Maximum number of messages in a batch.
	MaxMessages *int32

	// Mode for batching.
	Mode *OperationalMode
}

DataflowEndpointKafkaBatching - Kafka endpoint Batching properties

func (DataflowEndpointKafkaBatching) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointKafkaBatching.

func (*DataflowEndpointKafkaBatching) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointKafkaBatching.

type DataflowEndpointKafkaCompression 

type DataflowEndpointKafkaCompression string

DataflowEndpointKafkaCompression - Kafka endpoint Compression properties 

const (
	// DataflowEndpointKafkaCompressionGzip - Gzip Option
	DataflowEndpointKafkaCompressionGzip DataflowEndpointKafkaCompression = "Gzip"
	// DataflowEndpointKafkaCompressionLz4 - LZ4 Option
	DataflowEndpointKafkaCompressionLz4 DataflowEndpointKafkaCompression = "Lz4"
	// DataflowEndpointKafkaCompressionNone - NONE Option
	DataflowEndpointKafkaCompressionNone DataflowEndpointKafkaCompression = "None"
	// DataflowEndpointKafkaCompressionSnappy - SNAPPY Option
	DataflowEndpointKafkaCompressionSnappy DataflowEndpointKafkaCompression = "Snappy"
)

func PossibleDataflowEndpointKafkaCompressionValues 

func PossibleDataflowEndpointKafkaCompressionValues() []DataflowEndpointKafkaCompression

PossibleDataflowEndpointKafkaCompressionValues returns the possible values for the DataflowEndpointKafkaCompression const type.

type DataflowEndpointKafkaPartitionStrategy 

type DataflowEndpointKafkaPartitionStrategy string

DataflowEndpointKafkaPartitionStrategy - DataflowEndpoint Kafka Partition Strategy properties 

const (
	// DataflowEndpointKafkaPartitionStrategyDefault - Default: Assigns messages to random partitions, using a round-robin algorithm.
	DataflowEndpointKafkaPartitionStrategyDefault DataflowEndpointKafkaPartitionStrategy = "Default"
	// DataflowEndpointKafkaPartitionStrategyProperty - PROPERTY Option
	DataflowEndpointKafkaPartitionStrategyProperty DataflowEndpointKafkaPartitionStrategy = "Property"
	// DataflowEndpointKafkaPartitionStrategyStatic - Static: Assigns messages to a fixed partition number that's derived from
	// the instance ID of the dataflow.
	DataflowEndpointKafkaPartitionStrategyStatic DataflowEndpointKafkaPartitionStrategy = "Static"
	// DataflowEndpointKafkaPartitionStrategyTopic - TOPIC Option
	DataflowEndpointKafkaPartitionStrategyTopic DataflowEndpointKafkaPartitionStrategy = "Topic"
)

func PossibleDataflowEndpointKafkaPartitionStrategyValues 

func PossibleDataflowEndpointKafkaPartitionStrategyValues() []DataflowEndpointKafkaPartitionStrategy

PossibleDataflowEndpointKafkaPartitionStrategyValues returns the possible values for the DataflowEndpointKafkaPartitionStrategy const type.

type DataflowEndpointLocalStorage 

type DataflowEndpointLocalStorage struct {
	// REQUIRED; Persistent volume claim name.
	PersistentVolumeClaimRef *string
}

DataflowEndpointLocalStorage - Local persistent volume endpoint properties

func (DataflowEndpointLocalStorage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointLocalStorage.

func (*DataflowEndpointLocalStorage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointLocalStorage.

type DataflowEndpointMqtt 

type DataflowEndpointMqtt struct {
	// REQUIRED; authentication properties. DEFAULT: kubernetes.audience=aio-internal. NOTE - Enum field only property is allowed
	Authentication *DataflowEndpointMqttAuthentication

	// Client ID prefix. Client ID generated by the dataflow is <prefix>-TBD. Optional; no prefix if omitted.
	ClientIDPrefix *string

	// Cloud event mapping config.
	CloudEventAttributes *CloudEventAttributeType

	// Host of the Broker in the form of <hostname>:<port>. Optional; connects to Broker if omitted.
	Host *string

	// Broker KeepAlive for connection in seconds.
	KeepAliveSeconds *int32

	// The max number of messages to keep in flight. For subscribe, this is the receive maximum. For publish, this is the maximum
	// number of messages to send before waiting for an ack.
	MaxInflightMessages *int32

	// Enable or disable websockets.
	Protocol *BrokerProtocolType

	// Qos for Broker connection.
	Qos *int32

	// Whether or not to keep the retain setting.
	Retain *MqttRetainType

	// Session expiry in seconds.
	SessionExpirySeconds *int32

	// TLS configuration.
	TLS *TLSProperties
}

DataflowEndpointMqtt - Broker endpoint properties

func (DataflowEndpointMqtt) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointMqtt.

func (*DataflowEndpointMqtt) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointMqtt.

type DataflowEndpointMqttAuthentication 

type DataflowEndpointMqttAuthentication struct {
	// REQUIRED; Mode of Authentication.
	Method *MqttAuthMethod

	// Kubernetes service account token authentication. Default audience if not set is aio-internal
	ServiceAccountTokenSettings *DataflowEndpointAuthenticationServiceAccountToken

	// System-assigned managed identity authentication.
	SystemAssignedManagedIdentitySettings *DataflowEndpointAuthenticationSystemAssignedManagedIdentity

	// User-assigned managed identity authentication.
	UserAssignedManagedIdentitySettings *DataflowEndpointAuthenticationUserAssignedManagedIdentity

	// X.509 certificate authentication.
	X509CertificateSettings *DataflowEndpointAuthenticationX509
}

DataflowEndpointMqttAuthentication - Mqtt endpoint Authentication properties. NOTE - only authentication property is allowed per entry.

func (DataflowEndpointMqttAuthentication) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointMqttAuthentication.

func (*DataflowEndpointMqttAuthentication) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointMqttAuthentication.

type DataflowEndpointProperties 

type DataflowEndpointProperties struct {
	// REQUIRED; Endpoint Type.
	EndpointType *EndpointType

	// Azure Data Explorer endpoint.
	DataExplorerSettings *DataflowEndpointDataExplorer

	// Azure Data Lake endpoint.
	DataLakeStorageSettings *DataflowEndpointDataLakeStorage

	// Microsoft Fabric endpoint.
	FabricOneLakeSettings *DataflowEndpointFabricOneLake

	// Kafka endpoint.
	KafkaSettings *DataflowEndpointKafka

	// Local persistent volume endpoint.
	LocalStorageSettings *DataflowEndpointLocalStorage

	// Broker endpoint.
	MqttSettings *DataflowEndpointMqtt

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

DataflowEndpointProperties - DataflowEndpoint Resource properties. NOTE - Only one type of endpoint is supported for one Resource

func (DataflowEndpointProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointProperties.

func (*DataflowEndpointProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointProperties.

type DataflowEndpointResource 

type DataflowEndpointResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *DataflowEndpointProperties

	// READ-ONLY; Name of Instance dataflowEndpoint resource
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

DataflowEndpointResource - Instance dataflowEndpoint resource

func (DataflowEndpointResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointResource.

func (*DataflowEndpointResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointResource.

type DataflowEndpointResourceListResult 

type DataflowEndpointResourceListResult struct {
	// REQUIRED; The DataflowEndpointResource items on this page
	Value []*DataflowEndpointResource

	// The link to the next page of items
	NextLink *string
}

DataflowEndpointResourceListResult - The response of a DataflowEndpointResource list operation.

func (DataflowEndpointResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowEndpointResourceListResult.

func (*DataflowEndpointResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowEndpointResourceListResult.

type DataflowMappingType 

type DataflowMappingType string

DataflowMappingType - Dataflow type mapping properties 

const (
	// DataflowMappingTypeBuiltInFunction - Built in function type
	DataflowMappingTypeBuiltInFunction DataflowMappingType = "BuiltInFunction"
	// DataflowMappingTypeCompute - Compute type
	DataflowMappingTypeCompute DataflowMappingType = "Compute"
	// DataflowMappingTypeNewProperties - New Properties type
	DataflowMappingTypeNewProperties DataflowMappingType = "NewProperties"
	// DataflowMappingTypePassThrough - Pass-through type
	DataflowMappingTypePassThrough DataflowMappingType = "PassThrough"
	// DataflowMappingTypeRename - Rename type
	DataflowMappingTypeRename DataflowMappingType = "Rename"
)

func PossibleDataflowMappingTypeValues 

func PossibleDataflowMappingTypeValues() []DataflowMappingType

PossibleDataflowMappingTypeValues returns the possible values for the DataflowMappingType const type.

type DataflowOperation 

type DataflowOperation struct {
	// REQUIRED; Type of operation.
	OperationType *OperationType

	// Built In Transformation configuration.
	BuiltInTransformationSettings *DataflowBuiltInTransformationSettings

	// Destination configuration.
	DestinationSettings *DataflowDestinationOperationSettings

	// Optional user provided name of the transformation.
	Name *string

	// Source configuration.
	SourceSettings *DataflowSourceOperationSettings
}

DataflowOperation - Dataflow Operation properties. NOTE - One only method is allowed to be used for one entry.

func (DataflowOperation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowOperation.

func (*DataflowOperation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowOperation.

type DataflowProfileClient 

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

DataflowProfileClient contains the methods for the DataflowProfile group. Don't use this type directly, use NewDataflowProfileClient() instead.

func NewDataflowProfileClient 

func NewDataflowProfileClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DataflowProfileClient, error)

NewDataflowProfileClient creates a new instance of DataflowProfileClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DataflowProfileClient) BeginCreateOrUpdate 

func (client *DataflowProfileClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, dataflowProfileName string, resource DataflowProfileResource, options *DataflowProfileClientBeginCreateOrUpdateOptions) (*runtime.Poller[DataflowProfileClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a DataflowProfileResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • resource - Resource create parameters.
  • options - DataflowProfileClientBeginCreateOrUpdateOptions contains the optional parameters for the DataflowProfileClient.BeginCreateOrUpdate method.
Example (DataflowProfileCreateOrUpdate)

Generated from example definition: 2024-11-01/DataflowProfile_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowProfileClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "resource-name123", armiotoperations.DataflowProfileResource{
		Properties: &armiotoperations.DataflowProfileProperties{
			Diagnostics: &armiotoperations.ProfileDiagnostics{
				Logs: &armiotoperations.DiagnosticsLogs{
					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
				},
				Metrics: &armiotoperations.Metrics{
					PrometheusPort: to.Ptr[int32](7581),
				},
			},
			InstanceCount: to.Ptr[int32](14),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowProfileClientCreateOrUpdateResponse{
	// 	DataflowProfileResource: &armiotoperations.DataflowProfileResource{
	// 		Properties: &armiotoperations.DataflowProfileProperties{
	// 			Diagnostics: &armiotoperations.ProfileDiagnostics{
	// 				Logs: &armiotoperations.DiagnosticsLogs{
	// 					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
	// 				},
	// 				Metrics: &armiotoperations.Metrics{
	// 					PrometheusPort: to.Ptr[int32](7581),
	// 				},
	// 			},
	// 			InstanceCount: to.Ptr[int32](14),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123"),
	// 		Name: to.Ptr("bwhcjsnnfnrmbixamyxjau"),
	// 		Type: to.Ptr("ejvancsomtbapgztnerhlvx"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowProfileCreateOrUpdateMinimal)

Generated from example definition: 2024-11-01/DataflowProfile_CreateOrUpdate_Minimal.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowProfileClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "aio-dataflowprofile", armiotoperations.DataflowProfileResource{
		Properties: &armiotoperations.DataflowProfileProperties{
			InstanceCount: to.Ptr[int32](1),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowProfileClientCreateOrUpdateResponse{
	// 	DataflowProfileResource: &armiotoperations.DataflowProfileResource{
	// 		Properties: &armiotoperations.DataflowProfileProperties{
	// 			InstanceCount: to.Ptr[int32](1),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123"),
	// 		Name: to.Ptr("bwhcjsnnfnrmbixamyxjau"),
	// 		Type: to.Ptr("ejvancsomtbapgztnerhlvx"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (DataflowProfileCreateOrUpdateMulti)

Generated from example definition: 2024-11-01/DataflowProfile_CreateOrUpdate_Multi.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowProfileClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "resource-name123", "aio-dataflowprofile", armiotoperations.DataflowProfileResource{
		Properties: &armiotoperations.DataflowProfileProperties{
			InstanceCount: to.Ptr[int32](3),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
	}, 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 = armiotoperations.DataflowProfileClientCreateOrUpdateResponse{
	// 	DataflowProfileResource: &armiotoperations.DataflowProfileResource{
	// 		Properties: &armiotoperations.DataflowProfileProperties{
	// 			InstanceCount: to.Ptr[int32](3),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123"),
	// 		Name: to.Ptr("bwhcjsnnfnrmbixamyxjau"),
	// 		Type: to.Ptr("ejvancsomtbapgztnerhlvx"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DataflowProfileClient) BeginDelete 

func (client *DataflowProfileClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, dataflowProfileName string, options *DataflowProfileClientBeginDeleteOptions) (*runtime.Poller[DataflowProfileClientDeleteResponse], error)

BeginDelete - Delete a DataflowProfileResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • options - DataflowProfileClientBeginDeleteOptions contains the optional parameters for the DataflowProfileClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/DataflowProfile_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDataflowProfileClient().BeginDelete(ctx, "rgiotoperations", "resource-name123", "resource-name123", 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 (*DataflowProfileClient) Get 

func (client *DataflowProfileClient) Get(ctx context.Context, resourceGroupName string, instanceName string, dataflowProfileName string, options *DataflowProfileClientGetOptions) (DataflowProfileClientGetResponse, error)

Get - Get a DataflowProfileResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • dataflowProfileName - Name of Instance dataflowProfile resource
  • options - DataflowProfileClientGetOptions contains the optional parameters for the DataflowProfileClient.Get method.
Example

Generated from example definition: 2024-11-01/DataflowProfile_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDataflowProfileClient().Get(ctx, "rgiotoperations", "resource-name123", "resource-name123", 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 = armiotoperations.DataflowProfileClientGetResponse{
	// 	DataflowProfileResource: &armiotoperations.DataflowProfileResource{
	// 		Properties: &armiotoperations.DataflowProfileProperties{
	// 			Diagnostics: &armiotoperations.ProfileDiagnostics{
	// 				Logs: &armiotoperations.DiagnosticsLogs{
	// 					Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
	// 				},
	// 				Metrics: &armiotoperations.Metrics{
	// 					PrometheusPort: to.Ptr[int32](7581),
	// 				},
	// 			},
	// 			InstanceCount: to.Ptr[int32](14),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123"),
	// 		Name: to.Ptr("bwhcjsnnfnrmbixamyxjau"),
	// 		Type: to.Ptr("ejvancsomtbapgztnerhlvx"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*DataflowProfileClient) NewListByResourceGroupPager 

func (client *DataflowProfileClient) NewListByResourceGroupPager(resourceGroupName string, instanceName string, options *DataflowProfileClientListByResourceGroupOptions) *runtime.Pager[DataflowProfileClientListByResourceGroupResponse]

NewListByResourceGroupPager - List DataflowProfileResource resources by InstanceResource

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • options - DataflowProfileClientListByResourceGroupOptions contains the optional parameters for the DataflowProfileClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/DataflowProfile_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDataflowProfileClient().NewListByResourceGroupPager("rgiotoperations", "resource-name123", 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 = armiotoperations.DataflowProfileClientListByResourceGroupResponse{
		// 	DataflowProfileResourceListResult: armiotoperations.DataflowProfileResourceListResult{
		// 		Value: []*armiotoperations.DataflowProfileResource{
		// 			{
		// 				Properties: &armiotoperations.DataflowProfileProperties{
		// 					Diagnostics: &armiotoperations.ProfileDiagnostics{
		// 						Logs: &armiotoperations.DiagnosticsLogs{
		// 							Level: to.Ptr("rnmwokumdmebpmfxxxzvvjfdywotav"),
		// 						},
		// 						Metrics: &armiotoperations.Metrics{
		// 							PrometheusPort: to.Ptr[int32](7581),
		// 						},
		// 					},
		// 					InstanceCount: to.Ptr[int32](14),
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123/dataflowProfiles/resource-name123"),
		// 				Name: to.Ptr("bwhcjsnnfnrmbixamyxjau"),
		// 				Type: to.Ptr("ejvancsomtbapgztnerhlvx"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type DataflowProfileClientBeginCreateOrUpdateOptions 

type DataflowProfileClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DataflowProfileClientBeginCreateOrUpdateOptions contains the optional parameters for the DataflowProfileClient.BeginCreateOrUpdate method.

type DataflowProfileClientBeginDeleteOptions 

type DataflowProfileClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DataflowProfileClientBeginDeleteOptions contains the optional parameters for the DataflowProfileClient.BeginDelete method.

type DataflowProfileClientCreateOrUpdateResponse 

type DataflowProfileClientCreateOrUpdateResponse struct {
	// Instance dataflowProfile resource
	DataflowProfileResource
}

DataflowProfileClientCreateOrUpdateResponse contains the response from method DataflowProfileClient.BeginCreateOrUpdate.

type DataflowProfileClientDeleteResponse 

type DataflowProfileClientDeleteResponse struct {
}

DataflowProfileClientDeleteResponse contains the response from method DataflowProfileClient.BeginDelete.

type DataflowProfileClientGetOptions 

type DataflowProfileClientGetOptions struct {
}

DataflowProfileClientGetOptions contains the optional parameters for the DataflowProfileClient.Get method.

type DataflowProfileClientGetResponse 

type DataflowProfileClientGetResponse struct {
	// Instance dataflowProfile resource
	DataflowProfileResource
}

DataflowProfileClientGetResponse contains the response from method DataflowProfileClient.Get.

type DataflowProfileClientListByResourceGroupOptions 

type DataflowProfileClientListByResourceGroupOptions struct {
}

DataflowProfileClientListByResourceGroupOptions contains the optional parameters for the DataflowProfileClient.NewListByResourceGroupPager method.

type DataflowProfileClientListByResourceGroupResponse 

type DataflowProfileClientListByResourceGroupResponse struct {
	// The response of a DataflowProfileResource list operation.
	DataflowProfileResourceListResult
}

DataflowProfileClientListByResourceGroupResponse contains the response from method DataflowProfileClient.NewListByResourceGroupPager.

type DataflowProfileProperties 

type DataflowProfileProperties struct {
	// Spec defines the desired identities of NBC diagnostics settings.
	Diagnostics *ProfileDiagnostics

	// To manually scale the dataflow profile, specify the maximum number of instances you want to run.
	InstanceCount *int32

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

DataflowProfileProperties - DataflowProfile Resource properties

func (DataflowProfileProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowProfileProperties.

func (*DataflowProfileProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowProfileProperties.

type DataflowProfileResource 

type DataflowProfileResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *DataflowProfileProperties

	// READ-ONLY; Name of Instance dataflowProfile resource
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

DataflowProfileResource - Instance dataflowProfile resource

func (DataflowProfileResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowProfileResource.

func (*DataflowProfileResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowProfileResource.

type DataflowProfileResourceListResult 

type DataflowProfileResourceListResult struct {
	// REQUIRED; The DataflowProfileResource items on this page
	Value []*DataflowProfileResource

	// The link to the next page of items
	NextLink *string
}

DataflowProfileResourceListResult - The response of a DataflowProfileResource list operation.

func (DataflowProfileResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowProfileResourceListResult.

func (*DataflowProfileResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowProfileResourceListResult.

type DataflowProperties 

type DataflowProperties struct {
	// REQUIRED; List of operations including source and destination references as well as transformation.
	Operations []*DataflowOperation

	// Mode for Dataflow. Optional; defaults to Enabled.
	Mode *OperationalMode

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState
}

DataflowProperties - Dataflow Resource properties

func (DataflowProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowProperties.

func (*DataflowProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowProperties.

type DataflowResource 

type DataflowResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// The resource-specific properties for this resource.
	Properties *DataflowProperties

	// READ-ONLY; Name of Instance dataflowProfile dataflow resource
	Name *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

DataflowResource - Instance dataflowProfile dataflow resource

func (DataflowResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowResource.

func (*DataflowResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowResource.

type DataflowResourceListResult 

type DataflowResourceListResult struct {
	// REQUIRED; The DataflowResource items on this page
	Value []*DataflowResource

	// The link to the next page of items
	NextLink *string
}

DataflowResourceListResult - The response of a DataflowResource list operation.

func (DataflowResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowResourceListResult.

func (*DataflowResourceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowResourceListResult.

type DataflowSourceOperationSettings 

type DataflowSourceOperationSettings struct {
	// REQUIRED; List of source locations. Can be Broker or Kafka topics. Supports wildcards # and +.
	DataSources []*string

	// REQUIRED; Reference to the Dataflow Endpoint resource. Can only be of Broker and Kafka type.
	EndpointRef *string

	// Reference to the resource in Azure Device Registry where the data in the endpoint originates from.
	AssetRef *string

	// Schema CR reference. Data will be deserialized according to the schema, and dropped if it doesn't match.
	SchemaRef *string

	// Content is a JSON Schema. Allowed: JSON Schema/draft-7.
	SerializationFormat *SourceSerializationFormat
}

DataflowSourceOperationSettings - Dataflow Source Operation properties

func (DataflowSourceOperationSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataflowSourceOperationSettings.

func (*DataflowSourceOperationSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataflowSourceOperationSettings.

type DiagnosticsLogs 

type DiagnosticsLogs struct {
	// The log level. Examples - 'debug', 'info', 'warn', 'error', 'trace'.
	Level *string
}

DiagnosticsLogs - Diagnostic Log properties

func (DiagnosticsLogs) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiagnosticsLogs.

func (*DiagnosticsLogs) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiagnosticsLogs.

type DiskBackedMessageBuffer 

type DiskBackedMessageBuffer struct {
	// REQUIRED; The max size of the message buffer on disk. If a PVC template is specified using one of ephemeralVolumeClaimSpec
	// or persistentVolumeClaimSpec, then this size is used as the request and limit sizes of that template. If neither ephemeralVolumeClaimSpec
	// nor persistentVolumeClaimSpec are specified, then an emptyDir volume is mounted with this size as its limit. See <https://kubernetes.io/docs/concepts/storage/volumes/#emptydir>
	// for details.
	MaxSize *string

	// Use the specified persistent volume claim template to mount a "generic ephemeral volume" for the message buffer. See <https://kubernetes.io/docs/concepts/storage/ephemeral-volumes/#generic-ephemeral-volumes>
	// for details.
	EphemeralVolumeClaimSpec *VolumeClaimSpec

	// Use the specified persistent volume claim template to mount a persistent volume for the message buffer.
	PersistentVolumeClaimSpec *VolumeClaimSpec
}

DiskBackedMessageBuffer properties

func (DiskBackedMessageBuffer) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiskBackedMessageBuffer.

func (*DiskBackedMessageBuffer) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiskBackedMessageBuffer.

type EndpointType 

type EndpointType string

EndpointType - DataflowEndpoint Type properties 

const (
	// EndpointTypeDataExplorer - Azure Data Explorer Type
	EndpointTypeDataExplorer EndpointType = "DataExplorer"
	// EndpointTypeDataLakeStorage - Azure Data Lake Type
	EndpointTypeDataLakeStorage EndpointType = "DataLakeStorage"
	// EndpointTypeFabricOneLake - Microsoft Fabric Type
	EndpointTypeFabricOneLake EndpointType = "FabricOneLake"
	// EndpointTypeKafka - Kafka Type
	EndpointTypeKafka EndpointType = "Kafka"
	// EndpointTypeLocalStorage - Local Storage Type
	EndpointTypeLocalStorage EndpointType = "LocalStorage"
	// EndpointTypeMqtt - Broker Type
	EndpointTypeMqtt EndpointType = "Mqtt"
)

func PossibleEndpointTypeValues 

func PossibleEndpointTypeValues() []EndpointType

PossibleEndpointTypeValues returns the possible values for the EndpointType const type.

type ExtendedLocation 

type ExtendedLocation struct {
	// REQUIRED; The name of the extended location.
	Name *string

	// REQUIRED; Type of ExtendedLocation.
	Type *ExtendedLocationType
}

ExtendedLocation - Extended location is an extension of Azure locations. They provide a way to use their Azure ARC enabled Kubernetes clusters as target locations for deploying Azure services instances.

func (ExtendedLocation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtendedLocation.

func (*ExtendedLocation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedLocation.

type ExtendedLocationType 

type ExtendedLocationType string

ExtendedLocationType - The enum defining type of ExtendedLocation accepted. 

const (
	// ExtendedLocationTypeCustomLocation - CustomLocation type
	ExtendedLocationTypeCustomLocation ExtendedLocationType = "CustomLocation"
)

func PossibleExtendedLocationTypeValues 

func PossibleExtendedLocationTypeValues() []ExtendedLocationType

PossibleExtendedLocationTypeValues returns the possible values for the ExtendedLocationType const type.

type FabricOneLakeAuthMethod 

type FabricOneLakeAuthMethod string

FabricOneLakeAuthMethod - DataflowEndpoint Fabric One Lake Authentication Method properties 

const (
	// FabricOneLakeAuthMethodSystemAssignedManagedIdentity - SystemAssignedManagedIdentity type
	FabricOneLakeAuthMethodSystemAssignedManagedIdentity FabricOneLakeAuthMethod = "SystemAssignedManagedIdentity"
	// FabricOneLakeAuthMethodUserAssignedManagedIdentity - UserAssignedManagedIdentity type
	FabricOneLakeAuthMethodUserAssignedManagedIdentity FabricOneLakeAuthMethod = "UserAssignedManagedIdentity"
)

func PossibleFabricOneLakeAuthMethodValues 

func PossibleFabricOneLakeAuthMethodValues() []FabricOneLakeAuthMethod

PossibleFabricOneLakeAuthMethodValues returns the possible values for the FabricOneLakeAuthMethod const type.

type FilterType 

type FilterType string

FilterType - Filter Type properties 

const (
	// FilterTypeFilter - Filter type
	FilterTypeFilter FilterType = "Filter"
)

func PossibleFilterTypeValues 

func PossibleFilterTypeValues() []FilterType

PossibleFilterTypeValues returns the possible values for the FilterType const type.

type Frontend 

type Frontend struct {
	// REQUIRED; The desired number of frontend instances (pods).
	Replicas *int32

	// Number of logical frontend workers per instance (pod).
	Workers *int32
}

Frontend - The desired properties of the frontend instances of the Broker

func (Frontend) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Frontend.

func (*Frontend) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Frontend.

type GenerateResourceLimits 

type GenerateResourceLimits struct {
	// The toggle to enable/disable cpu resource limits.
	CPU *OperationalMode
}

GenerateResourceLimits properties

func (GenerateResourceLimits) MarshalJSON 

func (g GenerateResourceLimits) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GenerateResourceLimits.

func (*GenerateResourceLimits) UnmarshalJSON 

func (g *GenerateResourceLimits) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GenerateResourceLimits.

type InstanceClient 

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

InstanceClient contains the methods for the Instance group. Don't use this type directly, use NewInstanceClient() instead.

func NewInstanceClient 

func NewInstanceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*InstanceClient, error)

NewInstanceClient creates a new instance of InstanceClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*InstanceClient) BeginCreateOrUpdate 

func (client *InstanceClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, instanceName string, resource InstanceResource, options *InstanceClientBeginCreateOrUpdateOptions) (*runtime.Poller[InstanceClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a InstanceResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • resource - Resource create parameters.
  • options - InstanceClientBeginCreateOrUpdateOptions contains the optional parameters for the InstanceClient.BeginCreateOrUpdate method.
Example

Generated from example definition: 2024-11-01/Instance_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInstanceClient().BeginCreateOrUpdate(ctx, "rgiotoperations", "aio-instance", armiotoperations.InstanceResource{
		Properties: &armiotoperations.InstanceProperties{
			SchemaRegistryRef: &armiotoperations.SchemaRegistryRef{
				ResourceID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.DeviceRegistry/schemaRegistries/resource-name123"),
			},
			Description: to.Ptr("kpqtgocs"),
		},
		ExtendedLocation: &armiotoperations.ExtendedLocation{
			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		},
		Identity: &armiotoperations.ManagedServiceIdentity{
			Type:                   to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
			UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{},
		},
		Tags:     map[string]*string{},
		Location: to.Ptr("xvewadyhycrjpu"),
	}, 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 = armiotoperations.InstanceClientCreateOrUpdateResponse{
	// 	InstanceResource: &armiotoperations.InstanceResource{
	// 		Properties: &armiotoperations.InstanceProperties{
	// 			SchemaRegistryRef: &armiotoperations.SchemaRegistryRef{
	// 				ResourceID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.DeviceRegistry/schemaRegistries/resource-name123"),
	// 			},
	// 			Description: to.Ptr("kpqtgocs"),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 			Version: to.Ptr("vjjbmunthiphfmekvxgxcxkzdwjti"),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		Identity: &armiotoperations.ManagedServiceIdentity{
	// 			Type: to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("4a6e4195-75b8-4685-aa0c-0b5704779327"),
	// 			TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("xvewadyhycrjpu"),
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123"),
	// 		Name: to.Ptr("llptmlifnqqwairx"),
	// 		Type: to.Ptr("qwrfzxjfxvismlqvigot"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*InstanceClient) BeginDelete 

func (client *InstanceClient) BeginDelete(ctx context.Context, resourceGroupName string, instanceName string, options *InstanceClientBeginDeleteOptions) (*runtime.Poller[InstanceClientDeleteResponse], error)

BeginDelete - Delete a InstanceResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • options - InstanceClientBeginDeleteOptions contains the optional parameters for the InstanceClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/Instance_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewInstanceClient().BeginDelete(ctx, "rgiotoperations", "aio-instance", 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 (*InstanceClient) Get 

func (client *InstanceClient) Get(ctx context.Context, resourceGroupName string, instanceName string, options *InstanceClientGetOptions) (InstanceClientGetResponse, error)

Get - Get a InstanceResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • options - InstanceClientGetOptions contains the optional parameters for the InstanceClient.Get method.
Example

Generated from example definition: 2024-11-01/Instance_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewInstanceClient().Get(ctx, "rgiotoperations", "aio-instance", 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 = armiotoperations.InstanceClientGetResponse{
	// 	InstanceResource: &armiotoperations.InstanceResource{
	// 		Properties: &armiotoperations.InstanceProperties{
	// 			SchemaRegistryRef: &armiotoperations.SchemaRegistryRef{
	// 				ResourceID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.DeviceRegistry/schemaRegistries/resource-name123"),
	// 			},
	// 			Description: to.Ptr("rlfvvnnhcypp"),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 			Version: to.Ptr("vjjbmunthiphfmekvxgxcxkzdwjti"),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		Identity: &armiotoperations.ManagedServiceIdentity{
	// 			Type: to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("4a6e4195-75b8-4685-aa0c-0b5704779327"),
	// 			TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("xvewadyhycrjpu"),
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123"),
	// 		Name: to.Ptr("llptmlifnqqwairx"),
	// 		Type: to.Ptr("qwrfzxjfxvismlqvigot"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*InstanceClient) NewListByResourceGroupPager 

func (client *InstanceClient) NewListByResourceGroupPager(resourceGroupName string, options *InstanceClientListByResourceGroupOptions) *runtime.Pager[InstanceClientListByResourceGroupResponse]

NewListByResourceGroupPager - List InstanceResource resources by resource group

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - InstanceClientListByResourceGroupOptions contains the optional parameters for the InstanceClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2024-11-01/Instance_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInstanceClient().NewListByResourceGroupPager("rgiotoperations", 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 = armiotoperations.InstanceClientListByResourceGroupResponse{
		// 	InstanceResourceListResult: armiotoperations.InstanceResourceListResult{
		// 		Value: []*armiotoperations.InstanceResource{
		// 			{
		// 				Properties: &armiotoperations.InstanceProperties{
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 					Version: to.Ptr("vjjbmunthiphfmekvxgxcxkzdwjti"),
		// 					SchemaRegistryRef: &armiotoperations.SchemaRegistryRef{
		// 						ResourceID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.DeviceRegistry/schemaRegistries/resource-name123"),
		// 					},
		// 					Description: to.Ptr("vmujggxdvxk"),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				Identity: &armiotoperations.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("4a6e4195-75b8-4685-aa0c-0b5704779327"),
		// 					TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 					Type: to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
		// 					UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Location: to.Ptr("xvewadyhycrjpu"),
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123"),
		// 				Name: to.Ptr("llptmlifnqqwairx"),
		// 				Type: to.Ptr("qwrfzxjfxvismlqvigot"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

func (*InstanceClient) NewListBySubscriptionPager 

func (client *InstanceClient) NewListBySubscriptionPager(options *InstanceClientListBySubscriptionOptions) *runtime.Pager[InstanceClientListBySubscriptionResponse]

NewListBySubscriptionPager - List InstanceResource resources by subscription ID

Generated from API version 2024-11-01

  • options - InstanceClientListBySubscriptionOptions contains the optional parameters for the InstanceClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2024-11-01/Instance_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewInstanceClient().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 = armiotoperations.InstanceClientListBySubscriptionResponse{
		// 	InstanceResourceListResult: armiotoperations.InstanceResourceListResult{
		// 		Value: []*armiotoperations.InstanceResource{
		// 			{
		// 				Properties: &armiotoperations.InstanceProperties{
		// 					ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
		// 					Version: to.Ptr("vjjbmunthiphfmekvxgxcxkzdwjti"),
		// 					SchemaRegistryRef: &armiotoperations.SchemaRegistryRef{
		// 						ResourceID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.DeviceRegistry/schemaRegistries/resource-name123"),
		// 					},
		// 					Description: to.Ptr("empgqmbhvklcqlyahmdsjemlep"),
		// 				},
		// 				ExtendedLocation: &armiotoperations.ExtendedLocation{
		// 					Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
		// 					Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
		// 				},
		// 				Identity: &armiotoperations.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("4a6e4195-75b8-4685-aa0c-0b5704779327"),
		// 					TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
		// 					Type: to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
		// 					UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 				},
		// 				Location: to.Ptr("xvewadyhycrjpu"),
		// 				ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123"),
		// 				Name: to.Ptr("llptmlifnqqwairx"),
		// 				Type: to.Ptr("qwrfzxjfxvismlqvigot"),
		// 				SystemData: &armiotoperations.SystemData{
		// 					CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
		// 					CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("gnicpuszwd"),
		// 					LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

func (*InstanceClient) Update 

func (client *InstanceClient) Update(ctx context.Context, resourceGroupName string, instanceName string, properties InstancePatchModel, options *InstanceClientUpdateOptions) (InstanceClientUpdateResponse, error)

Update - Update a InstanceResource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • instanceName - Name of instance.
  • properties - The resource properties to be updated.
  • options - InstanceClientUpdateOptions contains the optional parameters for the InstanceClient.Update method.
Example

Generated from example definition: 2024-11-01/Instance_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("F8C729F9-DF9C-4743-848F-96EE433D8E53", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewInstanceClient().Update(ctx, "rgiotoperations", "aio-instance", armiotoperations.InstancePatchModel{
		Tags: map[string]*string{},
		Identity: &armiotoperations.ManagedServiceIdentity{
			Type:                   to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
			UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{},
		},
	}, 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 = armiotoperations.InstanceClientUpdateResponse{
	// 	InstanceResource: &armiotoperations.InstanceResource{
	// 		Properties: &armiotoperations.InstanceProperties{
	// 			SchemaRegistryRef: &armiotoperations.SchemaRegistryRef{
	// 				ResourceID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.DeviceRegistry/schemaRegistries/resource-name123"),
	// 			},
	// 			Description: to.Ptr("wwihkapmgjbyrtyaj"),
	// 			ProvisioningState: to.Ptr(armiotoperations.ProvisioningStateSucceeded),
	// 			Version: to.Ptr("vjjbmunthiphfmekvxgxcxkzdwjti"),
	// 		},
	// 		ExtendedLocation: &armiotoperations.ExtendedLocation{
	// 			Name: to.Ptr("qmbrfwcpwwhggszhrdjv"),
	// 			Type: to.Ptr(armiotoperations.ExtendedLocationTypeCustomLocation),
	// 		},
	// 		Identity: &armiotoperations.ManagedServiceIdentity{
	// 			Type: to.Ptr(armiotoperations.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armiotoperations.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("4a6e4195-75b8-4685-aa0c-0b5704779327"),
	// 			TenantID: to.Ptr("ed060aa2-71ff-4d3f-99c4-a9138356fdec"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("xvewadyhycrjpu"),
	// 		ID: to.Ptr("/subscriptions/0000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup123/providers/Microsoft.IoTOperations/instances/resource-name123"),
	// 		Name: to.Ptr("llptmlifnqqwairx"),
	// 		Type: to.Ptr("qwrfzxjfxvismlqvigot"),
	// 		SystemData: &armiotoperations.SystemData{
	// 			CreatedBy: to.Ptr("ssvaslsmudloholronopqyxjcu"),
	// 			CreatedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("gnicpuszwd"),
	// 			LastModifiedByType: to.Ptr(armiotoperations.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-09T18:13:29.389Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

type InstanceClientBeginCreateOrUpdateOptions 

type InstanceClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

InstanceClientBeginCreateOrUpdateOptions contains the optional parameters for the InstanceClient.BeginCreateOrUpdate method.

type InstanceClientBeginDeleteOptions 

type InstanceClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

InstanceClientBeginDeleteOptions contains the optional parameters for the InstanceClient.BeginDelete method.

type InstanceClientCreateOrUpdateResponse 

type InstanceClientCreateOrUpdateResponse struct {
	// A Instance resource is a logical container for a set of child resources.
	InstanceResource
}

InstanceClientCreateOrUpdateResponse contains the response from method InstanceClient.BeginCreateOrUpdate.

type InstanceClientDeleteResponse 

type InstanceClientDeleteResponse struct {
}

InstanceClientDeleteResponse contains the response from method InstanceClient.BeginDelete.

type InstanceClientGetOptions 

type InstanceClientGetOptions struct {
}

InstanceClientGetOptions contains the optional parameters for the InstanceClient.Get method.

type InstanceClientGetResponse 

type InstanceClientGetResponse struct {
	// A Instance resource is a logical container for a set of child resources.
	InstanceResource
}

InstanceClientGetResponse contains the response from method InstanceClient.Get.

type InstanceClientListByResourceGroupOptions 

type InstanceClientListByResourceGroupOptions struct {
}

InstanceClientListByResourceGroupOptions contains the optional parameters for the InstanceClient.NewListByResourceGroupPager method.

type InstanceClientListByResourceGroupResponse 

type InstanceClientListByResourceGroupResponse struct {
	// The response of a InstanceResource list operation.
	InstanceResourceListResult
}

InstanceClientListByResourceGroupResponse contains the response from method InstanceClient.NewListByResourceGroupPager.

type InstanceClientListBySubscriptionOptions 

type InstanceClientListBySubscriptionOptions struct {
}

InstanceClientListBySubscriptionOptions contains the optional parameters for the InstanceClient.NewListBySubscriptionPager method.

type InstanceClientListBySubscriptionResponse 

type InstanceClientListBySubscriptionResponse struct {
	// The response of a InstanceResource list operation.
	InstanceResourceListResult
}

InstanceClientListBySubscriptionResponse contains the response from method InstanceClient.NewListBySubscriptionPager.

type InstanceClientUpdateOptions 

type InstanceClientUpdateOptions struct {
}

InstanceClientUpdateOptions contains the optional parameters for the InstanceClient.Update method.

type InstanceClientUpdateResponse 

type InstanceClientUpdateResponse struct {
	// A Instance resource is a logical container for a set of child resources.
	InstanceResource
}

InstanceClientUpdateResponse contains the response from method InstanceClient.Update.

type InstancePatchModel 

type InstancePatchModel struct {
	// The managed service identities assigned to this resource.
	Identity *ManagedServiceIdentity

	// Resource tags.
	Tags map[string]*string
}

InstancePatchModel - The Instance update model.

func (InstancePatchModel) MarshalJSON 

func (i InstancePatchModel) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InstancePatchModel.

func (*InstancePatchModel) UnmarshalJSON 

func (i *InstancePatchModel) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InstancePatchModel.

type InstanceProperties 

type InstanceProperties struct {
	// REQUIRED; The reference to the Schema Registry for this AIO Instance.
	SchemaRegistryRef *SchemaRegistryRef

	// Detailed description of the Instance.
	Description *string

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The Azure IoT Operations version.
	Version *string
}

InstanceProperties - The properties of the Instance resource.

func (InstanceProperties) MarshalJSON 

func (i InstanceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InstanceProperties.

func (*InstanceProperties) UnmarshalJSON 

func (i *InstanceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InstanceProperties.

type InstanceResource 

type InstanceResource struct {
	// REQUIRED; Edge location of the resource.
	ExtendedLocation *ExtendedLocation

	// REQUIRED; The geo-location where the resource lives
	Location *string

	// The resource-specific properties for this resource.
	Properties *InstanceProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Name of instance.
	Name *string

	// The managed service identities assigned to this resource.
	Identity *ManagedServiceIdentity

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

InstanceResource - A Instance resource is a logical container for a set of child resources.

func (InstanceResource) MarshalJSON 

func (i InstanceResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InstanceResource.

func (*InstanceResource) UnmarshalJSON 

func (i *InstanceResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InstanceResource.

type InstanceResourceListResult 

type InstanceResourceListResult struct {
	// REQUIRED; The InstanceResource items on this page
	Value []*InstanceResource

	// The link to the next page of items
	NextLink *string
}

InstanceResourceListResult - The response of a InstanceResource list operation.

func (InstanceResourceListResult) MarshalJSON 

func (i InstanceResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type InstanceResourceListResult.

func (*InstanceResourceListResult) UnmarshalJSON 

func (i *InstanceResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type InstanceResourceListResult.

type KafkaAuthMethod 

type KafkaAuthMethod string

KafkaAuthMethod - DataflowEndpoint Kafka Authentication Method properties 

const (
	// KafkaAuthMethodAnonymous - Anonymous Option
	KafkaAuthMethodAnonymous KafkaAuthMethod = "Anonymous"
	// KafkaAuthMethodSasl - Sasl Option
	KafkaAuthMethodSasl KafkaAuthMethod = "Sasl"
	// KafkaAuthMethodSystemAssignedManagedIdentity - SystemAssignedManagedIdentity type
	KafkaAuthMethodSystemAssignedManagedIdentity KafkaAuthMethod = "SystemAssignedManagedIdentity"
	// KafkaAuthMethodUserAssignedManagedIdentity - UserAssignedManagedIdentity type
	KafkaAuthMethodUserAssignedManagedIdentity KafkaAuthMethod = "UserAssignedManagedIdentity"
	// KafkaAuthMethodX509Certificate - x509Certificate Option
	KafkaAuthMethodX509Certificate KafkaAuthMethod = "X509Certificate"
)

func PossibleKafkaAuthMethodValues 

func PossibleKafkaAuthMethodValues() []KafkaAuthMethod

PossibleKafkaAuthMethodValues returns the possible values for the KafkaAuthMethod const type.

type KubernetesReference 

type KubernetesReference struct {
	// REQUIRED; Kind is the type of resource being referenced
	Kind *string

	// REQUIRED; Name is the name of resource being referenced
	Name *string

	// APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the
	// core API group. For any other third-party types, APIGroup is required.
	APIGroup *string

	// Namespace is the namespace of the resource being referenced. This field is required when the resource has a namespace.
	Namespace *string
}

KubernetesReference - Kubernetes reference

func (KubernetesReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type KubernetesReference.

func (*KubernetesReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type KubernetesReference.

type ListenerPort 

type ListenerPort struct {
	// REQUIRED; TCP port for accepting client connections.
	Port *int32

	// Reference to client authentication settings. Omit to disable authentication.
	AuthenticationRef *string

	// Reference to client authorization settings. Omit to disable authorization.
	AuthorizationRef *string

	// Kubernetes node port. Only relevant when this port is associated with a `NodePort` listener.
	NodePort *int32

	// Protocol to use for client connections.
	Protocol *BrokerProtocolType

	// TLS server certificate settings for this port. Omit to disable TLS.
	TLS *TLSCertMethod
}

ListenerPort - Defines a TCP port on which a `BrokerListener` listens.

func (ListenerPort) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ListenerPort.

func (*ListenerPort) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListenerPort.

type LocalKubernetesReference 

type LocalKubernetesReference struct {
	// REQUIRED; Kind is the type of resource being referenced
	Kind *string

	// REQUIRED; Name is the name of resource being referenced
	Name *string

	// APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the
	// core API group. For any other third-party types, APIGroup is required.
	APIGroup *string
}

LocalKubernetesReference - Kubernetes reference

func (LocalKubernetesReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LocalKubernetesReference.

func (*LocalKubernetesReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LocalKubernetesReference.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; The type of managed identity assigned to this resource.
	Type *ManagedServiceIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity

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

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

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). 

const (
	// ManagedServiceIdentityTypeNone - No managed identity.
	ManagedServiceIdentityTypeNone ManagedServiceIdentityType = "None"
	// ManagedServiceIdentityTypeSystemAndUserAssigned - System and user assigned managed identity.
	ManagedServiceIdentityTypeSystemAndUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	// ManagedServiceIdentityTypeSystemAssigned - System assigned managed identity.
	ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned"
	// ManagedServiceIdentityTypeUserAssigned - User assigned managed identity.
	ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type Metrics 

type Metrics struct {
	// The prometheus port to expose the metrics.
	PrometheusPort *int32
}

Metrics - Diagnostic Metrics properties

func (Metrics) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Metrics.

func (*Metrics) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Metrics.

type MqttAuthMethod 

type MqttAuthMethod string

MqttAuthMethod - DataflowEndpoint Mqtt Authentication Method properties 

const (
	// MqttAuthMethodAnonymous - Anonymous Option
	MqttAuthMethodAnonymous MqttAuthMethod = "Anonymous"
	// MqttAuthMethodServiceAccountToken - ServiceAccountToken Option
	MqttAuthMethodServiceAccountToken MqttAuthMethod = "ServiceAccountToken"
	// MqttAuthMethodSystemAssignedManagedIdentity - SystemAssignedManagedIdentity type
	MqttAuthMethodSystemAssignedManagedIdentity MqttAuthMethod = "SystemAssignedManagedIdentity"
	// MqttAuthMethodUserAssignedManagedIdentity - UserAssignedManagedIdentity type
	MqttAuthMethodUserAssignedManagedIdentity MqttAuthMethod = "UserAssignedManagedIdentity"
	// MqttAuthMethodX509Certificate - x509Certificate Option
	MqttAuthMethodX509Certificate MqttAuthMethod = "X509Certificate"
)

func PossibleMqttAuthMethodValues 

func PossibleMqttAuthMethodValues() []MqttAuthMethod

PossibleMqttAuthMethodValues returns the possible values for the MqttAuthMethod const type.

type MqttRetainType 

type MqttRetainType string

MqttRetainType - Broker Retain types 

const (
	// MqttRetainTypeKeep - Retain the messages.
	MqttRetainTypeKeep MqttRetainType = "Keep"
	// MqttRetainTypeNever - Never retain messages.
	MqttRetainTypeNever MqttRetainType = "Never"
)

func PossibleMqttRetainTypeValues 

func PossibleMqttRetainTypeValues() []MqttRetainType

PossibleMqttRetainTypeValues returns the possible values for the MqttRetainType const type.

type Operation 

type Operation struct {
	// Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure
	// Resource Manager/control-plane operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

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; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for and 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 OperationListResult 

type OperationListResult struct {
	// REQUIRED; The Operation items on this page
	Value []*Operation

	// The link to the next page of items
	NextLink *string
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an 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 OperationType 

type OperationType string

OperationType - Dataflow Operation Type properties 

const (
	// OperationTypeBuiltInTransformation - Dataflow BuiltIn Transformation Operation
	OperationTypeBuiltInTransformation OperationType = "BuiltInTransformation"
	// OperationTypeDestination - Dataflow Destination Operation
	OperationTypeDestination OperationType = "Destination"
	// OperationTypeSource - Dataflow Source Operation
	OperationTypeSource OperationType = "Source"
)

func PossibleOperationTypeValues 

func PossibleOperationTypeValues() []OperationType

PossibleOperationTypeValues returns the possible values for the OperationType const type.

type OperationalMode 

type OperationalMode string

OperationalMode - Mode properties 

const (
	// OperationalModeDisabled - Disabled is equivalent to False.
	OperationalModeDisabled OperationalMode = "Disabled"
	// OperationalModeEnabled - Enabled is equivalent to True
	OperationalModeEnabled OperationalMode = "Enabled"
)

func PossibleOperationalModeValues 

func PossibleOperationalModeValues() []OperationalMode

PossibleOperationalModeValues returns the possible values for the OperationalMode const type.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager 

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

NewListPager - List the operations for the provider

Generated from API version 2024-11-01

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

Generated from example definition: 2024-11-01/Operations_List_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/iotoperations/armiotoperations"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armiotoperations.NewClientFactory("<subscriptionID>", 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 = armiotoperations.OperationsClientListResponse{
		// 	OperationListResult: armiotoperations.OperationListResult{
		// 		Value: []*armiotoperations.Operation{
		// 			{
		// 				Name: to.Ptr("xzxqfusky"),
		// 				IsDataAction: to.Ptr(true),
		// 				Display: &armiotoperations.OperationDisplay{
		// 					Provider: to.Ptr("lrveskajtuwf"),
		// 					Resource: to.Ptr("d"),
		// 					Operation: to.Ptr("icuckgobartrrgmirax"),
		// 					Description: to.Ptr("dsbfnxzvnoqdm"),
		// 				},
		// 				Origin: to.Ptr(armiotoperations.OriginUser),
		// 				ActionType: to.Ptr(armiotoperations.ActionTypeInternal),
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OperatorValues 

type OperatorValues string

OperatorValues - Valid operators are In, NotIn, Exists and DoesNotExist. 

const (
	// OperatorValuesDoesNotExist - DoesNotExist operator.
	OperatorValuesDoesNotExist OperatorValues = "DoesNotExist"
	// OperatorValuesExists - Exists operator.
	OperatorValuesExists OperatorValues = "Exists"
	// OperatorValuesIn - In operator.
	OperatorValuesIn OperatorValues = "In"
	// OperatorValuesNotIn - NotIn operator.
	OperatorValuesNotIn OperatorValues = "NotIn"
)

func PossibleOperatorValuesValues 

func PossibleOperatorValuesValues() []OperatorValues

PossibleOperatorValuesValues returns the possible values for the OperatorValues const type.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	// OriginSystem - Indicates the operation is initiated by a system.
	OriginSystem Origin = "system"
	// OriginUser - Indicates the operation is initiated by a user.
	OriginUser Origin = "user"
	// OriginUserSystem - Indicates the operation is initiated by a user or system.
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PrincipalDefinition 

type PrincipalDefinition struct {
	// A list of key-value pairs that match the attributes of the clients. The attributes are case-sensitive and must match the
	// attributes provided by the clients during authentication.
	Attributes []map[string]*string

	// A list of client IDs that match the clients. The client IDs are case-sensitive and must match the client IDs provided by
	// the clients during connection.
	ClientIDs []*string

	// A list of usernames that match the clients. The usernames are case-sensitive and must match the usernames provided by the
	// clients during authentication.
	Usernames []*string
}

PrincipalDefinition properties of Rule

func (PrincipalDefinition) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrincipalDefinition.

func (*PrincipalDefinition) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrincipalDefinition.

type PrivateKeyAlgorithm 

type PrivateKeyAlgorithm string

PrivateKeyAlgorithm - Private key algorithm types. 

const (
	// PrivateKeyAlgorithmEc256 - Algorithm - ec256.
	PrivateKeyAlgorithmEc256 PrivateKeyAlgorithm = "Ec256"
	// PrivateKeyAlgorithmEc384 - Algorithm - ec384.
	PrivateKeyAlgorithmEc384 PrivateKeyAlgorithm = "Ec384"
	// PrivateKeyAlgorithmEc521 - Algorithm - ec521.
	PrivateKeyAlgorithmEc521 PrivateKeyAlgorithm = "Ec521"
	// PrivateKeyAlgorithmEd25519 - Algorithm - ed25519.
	PrivateKeyAlgorithmEd25519 PrivateKeyAlgorithm = "Ed25519"
	// PrivateKeyAlgorithmRsa2048 - Algorithm - rsa2048.
	PrivateKeyAlgorithmRsa2048 PrivateKeyAlgorithm = "Rsa2048"
	// PrivateKeyAlgorithmRsa4096 - Algorithm - rsa4096.
	PrivateKeyAlgorithmRsa4096 PrivateKeyAlgorithm = "Rsa4096"
	// PrivateKeyAlgorithmRsa8192 - Algorithm - rsa8192.
	PrivateKeyAlgorithmRsa8192 PrivateKeyAlgorithm = "Rsa8192"
)

func PossiblePrivateKeyAlgorithmValues 

func PossiblePrivateKeyAlgorithmValues() []PrivateKeyAlgorithm

PossiblePrivateKeyAlgorithmValues returns the possible values for the PrivateKeyAlgorithm const type.

type PrivateKeyRotationPolicy 

type PrivateKeyRotationPolicy string

PrivateKeyRotationPolicy - Private key rotation policy. 

const (
	// PrivateKeyRotationPolicyAlways - Rotation Policy - Always.
	PrivateKeyRotationPolicyAlways PrivateKeyRotationPolicy = "Always"
	// PrivateKeyRotationPolicyNever - Rotation Policy - Never.
	PrivateKeyRotationPolicyNever PrivateKeyRotationPolicy = "Never"
)

func PossiblePrivateKeyRotationPolicyValues 

func PossiblePrivateKeyRotationPolicyValues() []PrivateKeyRotationPolicy

PossiblePrivateKeyRotationPolicyValues returns the possible values for the PrivateKeyRotationPolicy const type.

type ProfileDiagnostics 

type ProfileDiagnostics struct {
	// Diagnostic log settings for the resource.
	Logs *DiagnosticsLogs

	// The metrics settings for the resource.
	Metrics *Metrics
}

ProfileDiagnostics - DataflowProfile Diagnostics properties

func (ProfileDiagnostics) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProfileDiagnostics.

func (*ProfileDiagnostics) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProfileDiagnostics.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The enum defining status of resource. 

const (
	// ProvisioningStateAccepted - Resource has been Accepted.
	ProvisioningStateAccepted ProvisioningState = "Accepted"
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateDeleting - Resource is Deleting.
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateProvisioning - Resource is getting provisioned.
	ProvisioningStateProvisioning ProvisioningState = "Provisioning"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - Resource is Updating.
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type SanForCert 

type SanForCert struct {
	// REQUIRED; DNS SANs.
	DNS []*string

	// REQUIRED; IP address SANs.
	IP []*string
}

SanForCert - Subject Alternative Names (SANs) for certificate.

func (SanForCert) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SanForCert.

func (*SanForCert) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SanForCert.

type SchemaRegistryRef 

type SchemaRegistryRef struct {
	// REQUIRED; The resource ID of the Schema Registry.
	ResourceID *string
}

SchemaRegistryRef - The reference to the Schema Registry for this AIO Instance.

func (SchemaRegistryRef) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SchemaRegistryRef.

func (*SchemaRegistryRef) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SchemaRegistryRef.

type SelfCheck 

type SelfCheck struct {
	// The self check interval.
	IntervalSeconds *int32

	// The toggle to enable/disable self check.
	Mode *OperationalMode

	// The timeout for self check.
	TimeoutSeconds *int32
}

SelfCheck - Broker Diagnostic Self check properties

func (SelfCheck) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SelfCheck.

func (*SelfCheck) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SelfCheck.

type SelfTracing 

type SelfTracing struct {
	// The self tracing interval.
	IntervalSeconds *int32

	// The toggle to enable/disable self tracing.
	Mode *OperationalMode
}

SelfTracing - Diagnostic Self tracing properties

func (SelfTracing) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SelfTracing.

func (*SelfTracing) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SelfTracing.

type ServiceType 

type ServiceType string

ServiceType - Kubernetes Service Types supported by Listener 

const (
	// ServiceTypeClusterIP - Cluster IP Service.
	ServiceTypeClusterIP ServiceType = "ClusterIp"
	// ServiceTypeLoadBalancer - Load Balancer Service.
	ServiceTypeLoadBalancer ServiceType = "LoadBalancer"
	// ServiceTypeNodePort - Node Port Service.
	ServiceTypeNodePort ServiceType = "NodePort"
)

func PossibleServiceTypeValues 

func PossibleServiceTypeValues() []ServiceType

PossibleServiceTypeValues returns the possible values for the ServiceType const type.

type SourceSerializationFormat 

type SourceSerializationFormat string

SourceSerializationFormat - Serialization Format properties 

const (
	// SourceSerializationFormatJSON - JSON Format
	SourceSerializationFormatJSON SourceSerializationFormat = "Json"
)

func PossibleSourceSerializationFormatValues 

func PossibleSourceSerializationFormatValues() []SourceSerializationFormat

PossibleSourceSerializationFormatValues returns the possible values for the SourceSerializationFormat const type.

type StateStoreResourceDefinitionMethods 

type StateStoreResourceDefinitionMethods string

StateStoreResourceDefinitionMethods - StateStoreResourceDefinitionMethods methods allowed 

const (
	// StateStoreResourceDefinitionMethodsRead - Get/KeyNotify from Store
	StateStoreResourceDefinitionMethodsRead StateStoreResourceDefinitionMethods = "Read"
	// StateStoreResourceDefinitionMethodsReadWrite - Allowed all operations on Store - Get/KeyNotify/Set/Delete
	StateStoreResourceDefinitionMethodsReadWrite StateStoreResourceDefinitionMethods = "ReadWrite"
	// StateStoreResourceDefinitionMethodsWrite - Set/Delete in Store
	StateStoreResourceDefinitionMethodsWrite StateStoreResourceDefinitionMethods = "Write"
)

func PossibleStateStoreResourceDefinitionMethodsValues 

func PossibleStateStoreResourceDefinitionMethodsValues() []StateStoreResourceDefinitionMethods

PossibleStateStoreResourceDefinitionMethodsValues returns the possible values for the StateStoreResourceDefinitionMethods const type.

type StateStoreResourceKeyTypes 

type StateStoreResourceKeyTypes string

StateStoreResourceKeyTypes - StateStoreResourceKeyTypes properties 

const (
	// StateStoreResourceKeyTypesBinary - Key type - binary
	StateStoreResourceKeyTypesBinary StateStoreResourceKeyTypes = "Binary"
	// StateStoreResourceKeyTypesPattern - Key type - pattern
	StateStoreResourceKeyTypesPattern StateStoreResourceKeyTypes = "Pattern"
	// StateStoreResourceKeyTypesString - Key type - string
	StateStoreResourceKeyTypesString StateStoreResourceKeyTypes = "String"
)

func PossibleStateStoreResourceKeyTypesValues 

func PossibleStateStoreResourceKeyTypesValues() []StateStoreResourceKeyTypes

PossibleStateStoreResourceKeyTypesValues returns the possible values for the StateStoreResourceKeyTypes const type.

type StateStoreResourceRule 

type StateStoreResourceRule struct {
	// REQUIRED; Allowed keyTypes pattern, string, binary. The key type used for matching, for example pattern tries to match
	// the key to a glob-style pattern and string checks key is equal to value provided in keys.
	KeyType *StateStoreResourceKeyTypes

	// REQUIRED; Give access to state store keys for the corresponding principals defined. When key type is pattern set glob-style
	// pattern (e.g., '*', 'clients/*').
	Keys []*string

	// REQUIRED; Give access for `Read`, `Write` and `ReadWrite` access level.
	Method *StateStoreResourceDefinitionMethods
}

StateStoreResourceRule - State Store Resource Rule properties.

func (StateStoreResourceRule) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StateStoreResourceRule.

func (*StateStoreResourceRule) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StateStoreResourceRule.

type SubscriberMessageDropStrategy 

type SubscriberMessageDropStrategy string

SubscriberMessageDropStrategy - The enum defining strategies for dropping messages from the subscriber queue. 

const (
	// SubscriberMessageDropStrategyDropOldest - The oldest message is dropped.
	SubscriberMessageDropStrategyDropOldest SubscriberMessageDropStrategy = "DropOldest"
	// SubscriberMessageDropStrategyNone - Messages are never dropped.
	SubscriberMessageDropStrategyNone SubscriberMessageDropStrategy = "None"
)

func PossibleSubscriberMessageDropStrategyValues 

func PossibleSubscriberMessageDropStrategyValues() []SubscriberMessageDropStrategy

PossibleSubscriberMessageDropStrategyValues returns the possible values for the SubscriberMessageDropStrategy const type.

type SubscriberQueueLimit 

type SubscriberQueueLimit struct {
	// The maximum length of the queue before messages start getting dropped.
	Length *int64

	// The strategy to use for dropping messages from the queue.
	Strategy *SubscriberMessageDropStrategy
}

SubscriberQueueLimit - The settings of Subscriber Queue Limit.

func (SubscriberQueueLimit) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SubscriberQueueLimit.

func (*SubscriberQueueLimit) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SubscriberQueueLimit.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

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 TLSCertMethod 

type TLSCertMethod struct {
	// REQUIRED; Mode of TLS server certificate management.
	Mode *TLSCertMethodMode

	// Option 1 - Automatic TLS server certificate management with cert-manager.
	CertManagerCertificateSpec *CertManagerCertificateSpec

	// Option 2 - Manual TLS server certificate management through a defined secret.
	Manual *X509ManualCertificate
}

TLSCertMethod - Collection of different TLS types, NOTE- Enum at a time only one of them needs to be supported

func (TLSCertMethod) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TLSCertMethod.

func (*TLSCertMethod) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TLSCertMethod.

type TLSCertMethodMode 

type TLSCertMethodMode string

TLSCertMethodMode - Broker Authentication Mode 

const (
	// TLSCertMethodModeAutomatic - Automatic TLS server certificate configuration.
	TLSCertMethodModeAutomatic TLSCertMethodMode = "Automatic"
	// TLSCertMethodModeManual - Manual TLS server certificate configuration.
	TLSCertMethodModeManual TLSCertMethodMode = "Manual"
)

func PossibleTLSCertMethodModeValues 

func PossibleTLSCertMethodModeValues() []TLSCertMethodMode

PossibleTLSCertMethodModeValues returns the possible values for the TLSCertMethodMode const type.

type TLSProperties 

type TLSProperties struct {
	// Mode for TLS.
	Mode *OperationalMode

	// Trusted CA certificate config map.
	TrustedCaCertificateConfigMapRef *string
}

TLSProperties - Tls properties

func (TLSProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TLSProperties.

func (*TLSProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TLSProperties.

type Traces 

type Traces struct {
	// The cache size in megabytes.
	CacheSizeMegabytes *int32

	// The toggle to enable/disable traces.
	Mode *OperationalMode

	// The self tracing properties.
	SelfTracing *SelfTracing

	// The span channel capacity.
	SpanChannelCapacity *int32
}

Traces - Broker Diagnostic Trace properties

func (Traces) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Traces.

func (*Traces) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Traces.

type TransformationSerializationFormat 

type TransformationSerializationFormat string

TransformationSerializationFormat - Transformation Format properties 

const (
	// TransformationSerializationFormatDelta - Delta Format
	TransformationSerializationFormatDelta TransformationSerializationFormat = "Delta"
	// TransformationSerializationFormatJSON - JSON Format
	TransformationSerializationFormatJSON TransformationSerializationFormat = "Json"
	// TransformationSerializationFormatParquet - Parquet Format
	TransformationSerializationFormatParquet TransformationSerializationFormat = "Parquet"
)

func PossibleTransformationSerializationFormatValues 

func PossibleTransformationSerializationFormatValues() []TransformationSerializationFormat

PossibleTransformationSerializationFormatValues returns the possible values for the TransformationSerializationFormat const type.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type VolumeClaimResourceRequirements 

type VolumeClaimResourceRequirements struct {
	// Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	Limits map[string]*string

	// Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults
	// to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	Requests map[string]*string
}

VolumeClaimResourceRequirements properties

func (VolumeClaimResourceRequirements) MarshalJSON 

func (v VolumeClaimResourceRequirements) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeClaimResourceRequirements.

func (*VolumeClaimResourceRequirements) UnmarshalJSON 

func (v *VolumeClaimResourceRequirements) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeClaimResourceRequirements.

type VolumeClaimSpec 

type VolumeClaimSpec struct {
	// AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1
	AccessModes []*string

	// This field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)
	// * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source,
	// it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate
	// is enabled, this field will always have the same contents as the DataSourceRef field.
	DataSource *LocalKubernetesReference

	// Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local
	// object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume
	// binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner.
	// This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have
	// the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically
	// if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef:
	// * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim
	// objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates
	// an error if a disallowed value is specified. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be
	// enabled.
	DataSourceRef *KubernetesReference

	// Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled
	// users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity
	// recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
	Resources *VolumeClaimResourceRequirements

	// A label query over volumes to consider for binding.
	Selector *VolumeClaimSpecSelector

	// Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1
	StorageClassName *string

	// volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim
	// spec. This is a beta feature.
	VolumeMode *string

	// VolumeName is the binding reference to the PersistentVolume backing this claim.
	VolumeName *string
}

VolumeClaimSpec properties

func (VolumeClaimSpec) MarshalJSON 

func (v VolumeClaimSpec) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeClaimSpec.

func (*VolumeClaimSpec) UnmarshalJSON 

func (v *VolumeClaimSpec) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeClaimSpec.

type VolumeClaimSpecSelector 

type VolumeClaimSpecSelector struct {
	// MatchExpressions is a list of label selector requirements. The requirements are ANDed.
	MatchExpressions []*VolumeClaimSpecSelectorMatchExpressions

	// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions,
	// whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels map[string]*string
}

VolumeClaimSpecSelector properties

func (VolumeClaimSpecSelector) MarshalJSON 

func (v VolumeClaimSpecSelector) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeClaimSpecSelector.

func (*VolumeClaimSpecSelector) UnmarshalJSON 

func (v *VolumeClaimSpecSelector) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeClaimSpecSelector.

type VolumeClaimSpecSelectorMatchExpressions 

type VolumeClaimSpecSelectorMatchExpressions struct {
	// REQUIRED; key is the label key that the selector applies to.
	Key *string

	// REQUIRED; operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator *OperatorValues

	// values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator
	// is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
	Values []*string
}

VolumeClaimSpecSelectorMatchExpressions properties

func (VolumeClaimSpecSelectorMatchExpressions) MarshalJSON 

func (v VolumeClaimSpecSelectorMatchExpressions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeClaimSpecSelectorMatchExpressions.

func (*VolumeClaimSpecSelectorMatchExpressions) UnmarshalJSON 

func (v *VolumeClaimSpecSelectorMatchExpressions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeClaimSpecSelectorMatchExpressions.

type X509ManualCertificate 

type X509ManualCertificate struct {
	// REQUIRED; Kubernetes secret containing an X.509 client certificate. This is a reference to the secret through an identifying
	// name, not the secret itself.
	SecretRef *string
}

X509ManualCertificate - X509 Certificate Authentication properties.

func (X509ManualCertificate) MarshalJSON 

func (x X509ManualCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type X509ManualCertificate.

func (*X509ManualCertificate) UnmarshalJSON 

func (x *X509ManualCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type X509ManualCertificate.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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