armdeviceprovisioningservices

package module
v1.3.0 Latest Latest
Warning

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

 Go to latest Published: Sep 8, 2026 License: MIT Imports: 16 Imported by: 8

README

Azure Device Provisioning Service Module for Go

The armdeviceprovisioningservices module provides operations for working with Azure Device Provisioning Service.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Supported version of Go (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 Device Provisioning Service module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Device Provisioning Service. 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 Device Provisioning Service 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 := armdeviceprovisioningservices.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 := armdeviceprovisioningservices.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.NewDpsCertificateClient()

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 Device Provisioning Service 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 AccessRightsDescription 

type AccessRightsDescription string

AccessRightsDescription - Rights that this key has. 

const (
	AccessRightsDescriptionDeviceConnect           AccessRightsDescription = "DeviceConnect"
	AccessRightsDescriptionEnrollmentRead          AccessRightsDescription = "EnrollmentRead"
	AccessRightsDescriptionEnrollmentWrite         AccessRightsDescription = "EnrollmentWrite"
	AccessRightsDescriptionRegistrationStatusRead  AccessRightsDescription = "RegistrationStatusRead"
	AccessRightsDescriptionRegistrationStatusWrite AccessRightsDescription = "RegistrationStatusWrite"
	AccessRightsDescriptionServiceConfig           AccessRightsDescription = "ServiceConfig"
)

func PossibleAccessRightsDescriptionValues 

func PossibleAccessRightsDescriptionValues() []AccessRightsDescription

PossibleAccessRightsDescriptionValues returns the possible values for the AccessRightsDescription const type.

type AllocationPolicy 

type AllocationPolicy string

AllocationPolicy - Allocation policy to be used by this provisioning service. 

const (
	AllocationPolicyGeoLatency AllocationPolicy = "GeoLatency"
	AllocationPolicyHashed     AllocationPolicy = "Hashed"
	AllocationPolicyStatic     AllocationPolicy = "Static"
)

func PossibleAllocationPolicyValues 

func PossibleAllocationPolicyValues() []AllocationPolicy

PossibleAllocationPolicyValues returns the possible values for the AllocationPolicy const type.

type AsyncOperationResult 

type AsyncOperationResult struct {
	// Error message containing code, description and details
	Error *ErrorMessage

	// current status of a long running operation.
	Status *string
}

AsyncOperationResult - Result of a long running operation.

func (AsyncOperationResult) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type AsyncOperationResult.

func (*AsyncOperationResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AsyncOperationResult.

type CertificateListDescription 

type CertificateListDescription struct {
	// The array of Certificate objects.
	Value []*CertificateResponse
}

CertificateListDescription - The JSON-serialized array of Certificate objects.

func (CertificateListDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateListDescription.

func (*CertificateListDescription) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateListDescription.

type CertificateProperties 

type CertificateProperties struct {
	// base-64 representation of X509 certificate .cer file or just .pem file content.
	Certificate []byte

	// Determines whether certificate has been verified.
	IsVerified *bool

	// READ-ONLY; The certificate's creation date and time.
	Created *time.Time

	// READ-ONLY; The certificate's expiration date and time.
	Expiry *time.Time

	// READ-ONLY; The certificate's subject name.
	Subject *string

	// READ-ONLY; The certificate's thumbprint.
	Thumbprint *string

	// READ-ONLY; The certificate's last update date and time.
	Updated *time.Time
}

CertificateProperties - The description of an X509 CA Certificate.

func (CertificateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateProperties.

func (*CertificateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateProperties.

type CertificatePurpose 

type CertificatePurpose string
const (
	CertificatePurposeClientAuthentication CertificatePurpose = "clientAuthentication"
	CertificatePurposeServerAuthentication CertificatePurpose = "serverAuthentication"
)

func PossibleCertificatePurposeValues 

func PossibleCertificatePurposeValues() []CertificatePurpose

PossibleCertificatePurposeValues returns the possible values for the CertificatePurpose const type.

type CertificateResponse 

type CertificateResponse struct {
	// properties of a certificate
	Properties *CertificateProperties

	// READ-ONLY; The entity tag.
	Etag *string

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

	// READ-ONLY; The name of the resource
	Name *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
}

CertificateResponse - The X509 Certificate.

func (CertificateResponse) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CertificateResponse.

func (*CertificateResponse) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateResponse.

type ClientFactory added in v1.1.0 

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

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

func NewClientFactory added in v1.1.0 

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

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

  • subscriptionID - The 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) NewDpsCertificateClient added in v1.1.0 

func (c *ClientFactory) NewDpsCertificateClient() *DpsCertificateClient

NewDpsCertificateClient creates a new instance of DpsCertificateClient.

func (*ClientFactory) NewIotDpsResourceClient added in v1.1.0 

func (c *ClientFactory) NewIotDpsResourceClient() *IotDpsResourceClient

NewIotDpsResourceClient creates a new instance of IotDpsResourceClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type CreatedByType added in v0.3.0 

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 added in v0.3.0 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DpsCertificateClient 

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

DpsCertificateClient contains the methods for the DpsCertificate group. Don't use this type directly, use NewDpsCertificateClient() instead.

Generated from API version 2026-08-31

func NewDpsCertificateClient 

func NewDpsCertificateClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DpsCertificateClient, error)

NewDpsCertificateClient creates a new instance of DpsCertificateClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*DpsCertificateClient) CreateOrUpdate 

func (client *DpsCertificateClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, provisioningServiceName string, certificateName string, certificateDescription CertificateResponse, options *DpsCertificateClientCreateOrUpdateOptions) (DpsCertificateClientCreateOrUpdateResponse, error)

CreateOrUpdate - Add new certificate or update an existing certificate. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • provisioningServiceName - Name of the provisioning service to retrieve.
  • certificateName - Name of the certificate to retrieve.
  • certificateDescription - The certificate body.
  • options - DpsCertificateClientCreateOrUpdateOptions contains the optional parameters for the DpsCertificateClient.CreateOrUpdate method.
Example

Generated from example definition: 2026-08-31/DPSCertificateCreateOrUpdate.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDpsCertificateClient().CreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", "cert", armdeviceprovisioningservices.CertificateResponse{
		Properties: &armdeviceprovisioningservices.CertificateProperties{
			Certificate: []byte("MA=="),
		},
	}, 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 = armdeviceprovisioningservices.DpsCertificateClientCreateOrUpdateResponse{
	// 	CertificateResponse: armdeviceprovisioningservices.CertificateResponse{
	// 		Name: to.Ptr("cert"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/Certificates"),
	// 		Etag: to.Ptr("AAAAAAExpNs="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServives/myFirstProvisioningService/certificates/cert"),
	// 		Properties: &armdeviceprovisioningservices.CertificateProperties{
	// 			Certificate: []byte("MA=="),
	// 			Created: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 			Expiry: to.Ptr(time.Date(2039, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 			IsVerified: to.Ptr(false),
	// 			Subject: to.Ptr("CN=testdevice1"),
	// 			Thumbprint: to.Ptr("97388663832D0393C9246CAB4FBA2C8677185A25"),
	// 			Updated: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 		},
	// 	},
	// }
}

func (*DpsCertificateClient) Delete 

func (client *DpsCertificateClient) Delete(ctx context.Context, resourceGroupName string, ifMatch string, provisioningServiceName string, certificateName string, options *DpsCertificateClientDeleteOptions) (DpsCertificateClientDeleteResponse, error)

Delete - Deletes the specified certificate associated with the Provisioning Service If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - DpsCertificateClientDeleteOptions contains the optional parameters for the DpsCertificateClient.Delete method.
Example

Generated from example definition: 2026-08-31/DPSDeleteCertificate.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDpsCertificateClient().Delete(ctx, "myResourceGroup", "AAAAAAAADGk=", "myFirstProvisioningService", "cert", 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 = armdeviceprovisioningservices.DpsCertificateClientDeleteResponse{
	// }
}

func (*DpsCertificateClient) GenerateVerificationCode 

func (client *DpsCertificateClient) GenerateVerificationCode(ctx context.Context, certificateName string, ifMatch string, resourceGroupName string, provisioningServiceName string, options *DpsCertificateClientGenerateVerificationCodeOptions) (DpsCertificateClientGenerateVerificationCodeResponse, error)

GenerateVerificationCode - Generate verification code for Proof of Possession. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - DpsCertificateClientGenerateVerificationCodeOptions contains the optional parameters for the DpsCertificateClient.GenerateVerificationCode method.
Example

Generated from example definition: 2026-08-31/DPSGenerateVerificationCode.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDpsCertificateClient().GenerateVerificationCode(ctx, "cert", "AAAAAAAADGk=", "myResourceGroup", "myFirstProvisioningService", 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 = armdeviceprovisioningservices.DpsCertificateClientGenerateVerificationCodeResponse{
	// 	VerificationCodeResponse: armdeviceprovisioningservices.VerificationCodeResponse{
	// 		Name: to.Ptr("cert"),
	// 		Properties: &armdeviceprovisioningservices.VerificationCodeResponseProperties{
	// 			Certificate: []byte("MA=="),
	// 			Created: to.Ptr("Thu, 12 Oct 2017 19:23:50 GMT"),
	// 			Expiry: to.Ptr("Sat, 31 Dec 2039 23:59:59 GMT"),
	// 			IsVerified: to.Ptr(false),
	// 			Subject: to.Ptr("CN=andbucdevice1"),
	// 			Thumbprint: to.Ptr("##############################"),
	// 			Updated: to.Ptr("Thu, 12 Oct 2017 19:26:56 GMT"),
	// 			VerificationCode: to.Ptr("##################################"),
	// 		},
	// 	},
	// }
}

func (*DpsCertificateClient) Get 

func (client *DpsCertificateClient) Get(ctx context.Context, certificateName string, resourceGroupName string, provisioningServiceName string, options *DpsCertificateClientGetOptions) (DpsCertificateClientGetResponse, error)

Get - Get the certificate from the provisioning service. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - DpsCertificateClientGetOptions contains the optional parameters for the DpsCertificateClient.Get method.
Example

Generated from example definition: 2026-08-31/DPSGetCertificate.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDpsCertificateClient().Get(ctx, "cert", "myResourceGroup", "myFirstProvisioningService", 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 = armdeviceprovisioningservices.DpsCertificateClientGetResponse{
	// 	CertificateResponse: armdeviceprovisioningservices.CertificateResponse{
	// 		Name: to.Ptr("cert"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/Certificates"),
	// 		Etag: to.Ptr("AAAAAAExpNs="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/IotHubs/andbuc-hub/certificates/cert"),
	// 		Properties: &armdeviceprovisioningservices.CertificateProperties{
	// 			Certificate: []byte("MA=="),
	// 			Created: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 			Expiry: to.Ptr(time.Date(2039, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 			IsVerified: to.Ptr(false),
	// 			Subject: to.Ptr("CN=testdevice1"),
	// 			Thumbprint: to.Ptr("97388663832D0393C9246CAB4FBA2C8677185A25"),
	// 			Updated: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 		},
	// 	},
	// }
}

func (*DpsCertificateClient) List 

func (client *DpsCertificateClient) List(ctx context.Context, resourceGroupName string, provisioningServiceName string, options *DpsCertificateClientListOptions) (DpsCertificateClientListResponse, error)

List - Get all the certificates tied to the provisioning service. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • provisioningServiceName - Name of the provisioning service to retrieve.
  • options - DpsCertificateClientListOptions contains the optional parameters for the DpsCertificateClient.List method.
Example

Generated from example definition: 2026-08-31/DPSGetCertificates.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDpsCertificateClient().List(ctx, "myResourceGroup", "myFirstProvisioningService", 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 = armdeviceprovisioningservices.DpsCertificateClientListResponse{
	// 	CertificateListDescription: armdeviceprovisioningservices.CertificateListDescription{
	// 		Value: []*armdeviceprovisioningservices.CertificateResponse{
	// 			{
	// 				Name: to.Ptr("cert"),
	// 				Type: to.Ptr("Microsoft.Devices/ProvisioningServices/Certificates"),
	// 				Etag: to.Ptr("AAAAAAExpNs="),
	// 				ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/IotHubs/andbuc-hub/certificates/cert"),
	// 				Properties: &armdeviceprovisioningservices.CertificateProperties{
	// 					Certificate: []byte("MA=="),
	// 					Created: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 					Expiry: to.Ptr(time.Date(2039, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 					IsVerified: to.Ptr(false),
	// 					Subject: to.Ptr("CN=testdevice1"),
	// 					Thumbprint: to.Ptr("97388663832D0393C9246CAB4FBA2C8677185A25"),
	// 					Updated: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}

func (*DpsCertificateClient) VerifyCertificate 

func (client *DpsCertificateClient) VerifyCertificate(ctx context.Context, certificateName string, ifMatch string, resourceGroupName string, provisioningServiceName string, request VerificationCodeRequest, options *DpsCertificateClientVerifyCertificateOptions) (DpsCertificateClientVerifyCertificateResponse, error)

VerifyCertificate - Verifies the certificate's private key possession by providing the leaf cert issued by the verifying pre uploaded certificate. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - DpsCertificateClientVerifyCertificateOptions contains the optional parameters for the DpsCertificateClient.VerifyCertificate method.
Example

Generated from example definition: 2026-08-31/DPSVerifyCertificate.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDpsCertificateClient().VerifyCertificate(ctx, "cert", "AAAAAAAADGk=", "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.VerificationCodeRequest{
		Certificate: to.Ptr("#####################################"),
	}, 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 = armdeviceprovisioningservices.DpsCertificateClientVerifyCertificateResponse{
	// 	CertificateResponse: armdeviceprovisioningservices.CertificateResponse{
	// 		Name: to.Ptr("cert"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/Certificates"),
	// 		Etag: to.Ptr("AAAAAAExpTQ="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/certificates/cert"),
	// 		Properties: &armdeviceprovisioningservices.CertificateProperties{
	// 			Certificate: []byte("MA=="),
	// 			Created: to.Ptr(time.Date(2017, time.October, 12, 19, 23, 50, 0, time.UTC)),
	// 			Expiry: to.Ptr(time.Date(2039, time.December, 31, 23, 59, 59, 0, time.UTC)),
	// 			IsVerified: to.Ptr(true),
	// 			Subject: to.Ptr("CN=andbucdevice1"),
	// 			Thumbprint: to.Ptr("97388663832D0393C9246CAB4FBA2C8677185A25"),
	// 			Updated: to.Ptr(time.Date(2017, time.October, 12, 19, 26, 56, 0, time.UTC)),
	// 		},
	// 	},
	// }
}

type DpsCertificateClientCreateOrUpdateOptions added in v0.2.0 

type DpsCertificateClientCreateOrUpdateOptions struct {
	// ETag of the certificate. This is required to update an existing certificate, and ignored while creating a brand new certificate.
	IfMatch *string
}

DpsCertificateClientCreateOrUpdateOptions contains the optional parameters for the DpsCertificateClient.CreateOrUpdate method.

type DpsCertificateClientCreateOrUpdateResponse added in v0.2.0 

type DpsCertificateClientCreateOrUpdateResponse struct {
	// The X509 Certificate.
	CertificateResponse
}

DpsCertificateClientCreateOrUpdateResponse contains the response from method DpsCertificateClient.CreateOrUpdate.

type DpsCertificateClientDeleteOptions added in v0.2.0 

type DpsCertificateClientDeleteOptions struct {
	// Time the certificate is created.
	CertificateCreated       *time.Time
	CertificateHasPrivateKey *bool
	CertificateIsVerified    *bool

	// Certificate last updated time.
	CertificateLastUpdated *time.Time

	// This is optional, and it is the Common Name of the certificate.
	CertificateName1    *string
	CertificateNonce    *string
	CertificatePurpose  *CertificatePurpose
	CertificateRawBytes []byte
}

DpsCertificateClientDeleteOptions contains the optional parameters for the DpsCertificateClient.Delete method.

type DpsCertificateClientDeleteResponse added in v0.2.0 

type DpsCertificateClientDeleteResponse struct {
}

DpsCertificateClientDeleteResponse contains the response from method DpsCertificateClient.Delete.

type DpsCertificateClientGenerateVerificationCodeOptions added in v0.2.0 

type DpsCertificateClientGenerateVerificationCodeOptions struct {
	// Time the certificate is created.
	CertificateCreated *time.Time

	// Indicates if the certificate contains private key.
	CertificateHasPrivateKey *bool

	// Indicates if the certificate has been verified by owner of the private key.
	CertificateIsVerified *bool

	// Certificate last updated time.
	CertificateLastUpdated *time.Time

	// Common Name for the certificate.
	CertificateName1 *string

	// Random number generated to indicate Proof of Possession.
	CertificateNonce *string

	// Description mentioning the purpose of the certificate.
	CertificatePurpose *CertificatePurpose

	// Raw data of certificate.
	CertificateRawBytes []byte
}

DpsCertificateClientGenerateVerificationCodeOptions contains the optional parameters for the DpsCertificateClient.GenerateVerificationCode method.

type DpsCertificateClientGenerateVerificationCodeResponse added in v0.2.0 

type DpsCertificateClientGenerateVerificationCodeResponse struct {
	// Description of the response of the verification code.
	VerificationCodeResponse
}

DpsCertificateClientGenerateVerificationCodeResponse contains the response from method DpsCertificateClient.GenerateVerificationCode.

type DpsCertificateClientGetOptions added in v0.2.0 

type DpsCertificateClientGetOptions struct {
	// ETag of the certificate.
	IfMatch *string
}

DpsCertificateClientGetOptions contains the optional parameters for the DpsCertificateClient.Get method.

type DpsCertificateClientGetResponse added in v0.2.0 

type DpsCertificateClientGetResponse struct {
	// The X509 Certificate.
	CertificateResponse
}

DpsCertificateClientGetResponse contains the response from method DpsCertificateClient.Get.

type DpsCertificateClientListOptions added in v0.2.0 

type DpsCertificateClientListOptions struct {
}

DpsCertificateClientListOptions contains the optional parameters for the DpsCertificateClient.List method.

type DpsCertificateClientListResponse added in v0.2.0 

type DpsCertificateClientListResponse struct {
	// The JSON-serialized array of Certificate objects.
	CertificateListDescription
}

DpsCertificateClientListResponse contains the response from method DpsCertificateClient.List.

type DpsCertificateClientVerifyCertificateOptions added in v0.2.0 

type DpsCertificateClientVerifyCertificateOptions struct {
	// Time the certificate is created.
	CertificateCreated *time.Time

	// Indicates if the certificate contains private key.
	CertificateHasPrivateKey *bool

	// Indicates if the certificate has been verified by owner of the private key.
	CertificateIsVerified *bool

	// Certificate last updated time.
	CertificateLastUpdated *time.Time

	// Common Name for the certificate.
	CertificateName1 *string

	// Random number generated to indicate Proof of Possession.
	CertificateNonce *string

	// Describe the purpose of the certificate.
	CertificatePurpose *CertificatePurpose

	// Raw data of certificate.
	CertificateRawBytes []byte
}

DpsCertificateClientVerifyCertificateOptions contains the optional parameters for the DpsCertificateClient.VerifyCertificate method.

type DpsCertificateClientVerifyCertificateResponse added in v0.2.0 

type DpsCertificateClientVerifyCertificateResponse struct {
	// The X509 Certificate.
	CertificateResponse
}

DpsCertificateClientVerifyCertificateResponse contains the response from method DpsCertificateClient.VerifyCertificate.

type ErrorMessage added in v1.0.0 

type ErrorMessage struct {
	// standard error code
	Code *string

	// detailed summary of error
	Details *string

	// standard error description
	Message *string
}

ErrorMessage - Error response containing message and code.

func (ErrorMessage) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type ErrorMessage.

func (*ErrorMessage) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorMessage.

type GroupIDInformation 

type GroupIDInformation struct {
	// REQUIRED; The properties for a group information object
	Properties *GroupIDInformationProperties

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

	// READ-ONLY; The name of the resource
	Name *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
}

GroupIDInformation - The group information for creating a private endpoint on a provisioning service

func (GroupIDInformation) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type GroupIDInformation.

func (*GroupIDInformation) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GroupIDInformation.

type GroupIDInformationProperties 

type GroupIDInformationProperties struct {
	// The group id
	GroupID *string

	// The required members for a specific group id
	RequiredMembers []*string

	// The required DNS zones for a specific group id
	RequiredZoneNames []*string
}

GroupIDInformationProperties - The properties for a group information object

func (GroupIDInformationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type GroupIDInformationProperties.

func (*GroupIDInformationProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GroupIDInformationProperties.

type IPFilterActionType 

type IPFilterActionType string

IPFilterActionType - The desired action for requests captured by this rule. 

const (
	IPFilterActionTypeAccept IPFilterActionType = "Accept"
	IPFilterActionTypeReject IPFilterActionType = "Reject"
)

func PossibleIPFilterActionTypeValues 

func PossibleIPFilterActionTypeValues() []IPFilterActionType

PossibleIPFilterActionTypeValues returns the possible values for the IPFilterActionType const type.

type IPFilterRule 

type IPFilterRule struct {
	// REQUIRED; The desired action for requests captured by this rule.
	Action *IPFilterActionType

	// REQUIRED; The name of the IP filter rule.
	FilterName *string

	// REQUIRED; A string that contains the IP address range in CIDR notation for the rule.
	IPMask *string

	// Target for requests captured by this rule.
	Target *IPFilterTargetType
}

IPFilterRule - The IP filter rules for a provisioning Service.

func (IPFilterRule) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type IPFilterRule.

func (*IPFilterRule) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IPFilterRule.

type IPFilterTargetType 

type IPFilterTargetType string

IPFilterTargetType - Target for requests captured by this rule. 

const (
	IPFilterTargetTypeAll        IPFilterTargetType = "all"
	IPFilterTargetTypeDeviceAPI  IPFilterTargetType = "deviceApi"
	IPFilterTargetTypeServiceAPI IPFilterTargetType = "serviceApi"
)

func PossibleIPFilterTargetTypeValues 

func PossibleIPFilterTargetTypeValues() []IPFilterTargetType

PossibleIPFilterTargetTypeValues returns the possible values for the IPFilterTargetType const type.

type IotDpsPropertiesDescription 

type IotDpsPropertiesDescription struct {
	// Allocation policy to be used by this provisioning service.
	AllocationPolicy *AllocationPolicy

	// List of authorization keys for a provisioning service.
	AuthorizationPolicies []*SharedAccessSignatureAuthorizationRuleAccessRightsDescription

	// Disables all authentication methods other than Azure RBAC.
	DisableLocalAuth *bool

	// Optional.
	// Indicates if the DPS instance has Data Residency enabled, removing the cross geo-pair disaster recovery.
	EnableDataResidency *bool

	// The IP filter rules.
	IPFilterRules []*IPFilterRule

	// List of IoT hubs associated with this provisioning service.
	IotHubs []*IotHubDefinitionDescription

	// Portal endpoint to enable CORS for this provisioning service.
	PortalOperationsHostName *string

	// Private endpoint connections created on this IotHub
	PrivateEndpointConnections []*PrivateEndpointConnection

	// The ARM provisioning state of the provisioning service.
	ProvisioningState *string

	// Whether requests from Public Network are allowed
	PublicNetworkAccess *PublicNetworkAccess

	// Current state of the provisioning service.
	State *State

	// READ-ONLY; Device endpoint for this provisioning service.
	DeviceProvisioningHostName *string

	// READ-ONLY; Unique identifier of this provisioning service.
	IDScope *string

	// READ-ONLY; Service endpoint for provisioning service.
	ServiceOperationsHostName *string
}

IotDpsPropertiesDescription - the service specific properties of a provisioning service, including keys, linked iot hubs, current state, and system generated properties such as hostname and idScope

func (IotDpsPropertiesDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotDpsPropertiesDescription.

func (*IotDpsPropertiesDescription) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotDpsPropertiesDescription.

type IotDpsResourceClient 

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

IotDpsResourceClient contains the methods for the IotDpsResource group. Don't use this type directly, use NewIotDpsResourceClient() instead.

Generated from API version 2026-08-31

func NewIotDpsResourceClient 

func NewIotDpsResourceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IotDpsResourceClient, error)

NewIotDpsResourceClient creates a new instance of IotDpsResourceClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*IotDpsResourceClient) BeginCreateOrUpdate 

func (client *IotDpsResourceClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, provisioningServiceName string, iotDpsDescription ProvisioningServiceDescription, options *IotDpsResourceClientBeginCreateOrUpdateOptions) (*runtime.Poller[IotDpsResourceClientCreateOrUpdateResponse], error)

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

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • provisioningServiceName - Name of the provisioning service to retrieve.
  • iotDpsDescription - Description of the provisioning service to create or update.
  • options - IotDpsResourceClientBeginCreateOrUpdateOptions contains the optional parameters for the IotDpsResourceClient.BeginCreateOrUpdate method.
Example (DpsCreate)

Generated from example definition: 2026-08-31/DPSCreate.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			EnableDataResidency: to.Ptr(false),
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Tags: map[string]*string{},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups//providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			EnableDataResidency: to.Ptr(false),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}
Example (DpsCreateDisableLocalAuthFalse)

Generated from example definition: 2026-08-31/DPSCreate_DisableLocalAuthFalse.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			PublicNetworkAccess: to.Ptr(armdeviceprovisioningservices.PublicNetworkAccessEnabled),
			DisableLocalAuth:    to.Ptr(false),
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
		},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 			DisableLocalAuth: to.Ptr(false),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 		},
	// 	},
	// }
}
Example (DpsCreateDisableLocalAuthTrue)

Generated from example definition: 2026-08-31/DPSCreate_DisableLocalAuthTrue.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			PublicNetworkAccess: to.Ptr(armdeviceprovisioningservices.PublicNetworkAccessEnabled),
			DisableLocalAuth:    to.Ptr(true),
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 			DisableLocalAuth: to.Ptr(true),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}
Example (DpsCreateWithIotHub)

Generated from example definition: 2026-08-31/DPSCreateWithIotHub.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			EnableDataResidency: to.Ptr(false),
			IotHubs: []*armdeviceprovisioningservices.IotHubDefinitionDescription{
				{
					ApplyAllocationPolicy:                  to.Ptr(true),
					AllocationWeight:                       to.Ptr[int32](1),
					HostName:                               to.Ptr("myFirstIoTHub.azure-devices.net"),
					AuthenticationType:                     to.Ptr(armdeviceprovisioningservices.IotHubAuthenticationTypeUserAssigned),
					SelectedUserAssignedIdentityResourceID: to.Ptr("/subscriptions/abcf2d55-764f-419f-974d-f77a55c2ce55/resourcegroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-mi-1"),
					Location:                               to.Ptr("eastus"),
				},
			},
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityType("SystemAssigned, UserAssigned")),
			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
				"/subscriptions/abcf2d55-764f-419f-974d-f77a55c2ce55/resourcegroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-mi-1": {},
			},
		},
		Tags: map[string]*string{},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			EnableDataResidency: to.Ptr(false),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			IotHubs: []*armdeviceprovisioningservices.IotHubDefinitionDescription{
	// 				{
	// 					ApplyAllocationPolicy: to.Ptr(true),
	// 					AllocationWeight: to.Ptr[int32](1),
	// 					Name: to.Ptr("myFirstIoTHub.azure-devices.net"),
	// 					HostName: to.Ptr("myFirstIoTHub.azure-devices.net"),
	// 					AuthenticationType: to.Ptr(armdeviceprovisioningservices.IotHubAuthenticationTypeUserAssigned),
	// 					SelectedUserAssignedIdentityResourceID: to.Ptr("/subscriptions/abcf2d55-764f-419f-974d-f77a55c2ce55/resourcegroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-mi-1"),
	// 					Location: to.Ptr("eastus"),
	// 				},
	// 			},
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityType("SystemAssigned, UserAssigned")),
	// 			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
	// 				"/subscriptions/abcf2d55-764f-419f-974d-f77a55c2ce55/resourcegroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-mi-1": &armdeviceprovisioningservices.UserAssignedIdentity{
	// 				},
	// 			},
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}
Example (DpsCreateWithNamespace)

Generated from example definition: 2026-08-31/DPSCreateWithNamespace.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			EnableDataResidency: to.Ptr(false),
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Tags: map[string]*string{},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups//providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			EnableDataResidency: to.Ptr(false),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityType("SystemAssigned, UserAssigned")),
	// 			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
	// 				"/subscriptions/abcf2d55-764f-419f-974d-f77a55c2ce55/resourcegroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-mi-1": &armdeviceprovisioningservices.UserAssignedIdentity{
	// 				},
	// 				"/subscriptions/abcf2d55-764f-419f-974d-f77a55c2ce55/resourcegroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-mi-2": &armdeviceprovisioningservices.UserAssignedIdentity{
	// 				},
	// 			},
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}
Example (DpsUpdate)

Generated from example definition: 2026-08-31/DPSUpdate.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
				"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity": {},
			},
		},
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			EnableDataResidency: to.Ptr(false),
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Tags: map[string]*string{},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups//providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
	// 			PrincipalID: to.Ptr("aa80bd74-a3f0-4f14-b9da-99c5351cf9d5"),
	// 			TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
	// 			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
	// 				"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity": &armdeviceprovisioningservices.UserAssignedIdentity{
	// 					ClientID: to.Ptr("c38f618d-47f6-4260-8b3d-1dd8c130f323"),
	// 					PrincipalID: to.Ptr("f1b0b133-10dc-4985-966f-a98a04675fe9"),
	// 				},
	// 			},
	// 		},
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			EnableDataResidency: to.Ptr(false),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}
Example (DpsUpdateDisableLocalAuth)

Generated from example definition: 2026-08-31/DPSUpdate_DisableLocalAuth.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.ProvisioningServiceDescription{
		Location: to.Ptr("East US"),
		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
			DisableLocalAuth: to.Ptr(true),
		},
		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
			Name:     to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
			Capacity: to.Ptr[int64](1),
		},
		Tags: map[string]*string{},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 			DisableLocalAuth: to.Ptr(true),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) BeginCreateOrUpdatePrivateEndpointConnection 

func (client *IotDpsResourceClient) BeginCreateOrUpdatePrivateEndpointConnection(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection, options *IotDpsResourceClientBeginCreateOrUpdatePrivateEndpointConnectionOptions) (*runtime.Poller[IotDpsResourceClientCreateOrUpdatePrivateEndpointConnectionResponse], error)

BeginCreateOrUpdatePrivateEndpointConnection - Create or update the status of a private endpoint connection with the specified name If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Name of the provisioning service to retrieve.
  • privateEndpointConnectionName - The name of the private endpoint connection
  • privateEndpointConnection - The private endpoint connection with updated properties
  • options - IotDpsResourceClientBeginCreateOrUpdatePrivateEndpointConnectionOptions contains the optional parameters for the IotDpsResourceClient.BeginCreateOrUpdatePrivateEndpointConnection method.
Example

Generated from example definition: 2026-08-31/DPSCreateOrUpdatePrivateEndpointConnection.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginCreateOrUpdatePrivateEndpointConnection(ctx, "myResourceGroup", "myFirstProvisioningService", "myPrivateEndpointConnection", armdeviceprovisioningservices.PrivateEndpointConnection{
		Properties: &armdeviceprovisioningservices.PrivateEndpointConnectionProperties{
			PrivateLinkServiceConnectionState: &armdeviceprovisioningservices.PrivateLinkServiceConnectionState{
				Description: to.Ptr("Approved by johndoe@contoso.com"),
				Status:      to.Ptr(armdeviceprovisioningservices.PrivateLinkServiceConnectionStatusApproved),
			},
		},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientCreateOrUpdatePrivateEndpointConnectionResponse{
	// 	PrivateEndpointConnection: armdeviceprovisioningservices.PrivateEndpointConnection{
	// 		Name: to.Ptr("myPrivateEndpointConnection"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/PrivateEndpointConnections"),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/PrivateEndpointConnections/myPrivateEndpointConnection"),
	// 		Properties: &armdeviceprovisioningservices.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armdeviceprovisioningservices.PrivateEndpoint{
	// 				ID: to.Ptr("/subscriptions/a9eba280-4734-4d49-878f-b5549d1d0453/resourceGroups/networkResourceGroup/providers/Microsoft.Network/privateEndpoints/myPrivateEndpoint"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armdeviceprovisioningservices.PrivateLinkServiceConnectionState{
	// 				Description: to.Ptr("Approved by johndoe@contoso.com"),
	// 				ActionsRequired: to.Ptr("None"),
	// 				Status: to.Ptr(armdeviceprovisioningservices.PrivateLinkServiceConnectionStatusApproved),
	// 			},
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) BeginDelete 

func (client *IotDpsResourceClient) BeginDelete(ctx context.Context, provisioningServiceName string, resourceGroupName string, options *IotDpsResourceClientBeginDeleteOptions) (*runtime.Poller[IotDpsResourceClientDeleteResponse], error)

BeginDelete - Deletes the Provisioning Service. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IotDpsResourceClientBeginDeleteOptions contains the optional parameters for the IotDpsResourceClient.BeginDelete method.
Example

Generated from example definition: 2026-08-31/DPSDelete.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginDelete(ctx, "myFirstProvisioningService", "myResourceGroup", 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientDeleteResponse{
	// }
}

func (*IotDpsResourceClient) BeginDeletePrivateEndpointConnection 

func (client *IotDpsResourceClient) BeginDeletePrivateEndpointConnection(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *IotDpsResourceClientBeginDeletePrivateEndpointConnectionOptions) (*runtime.Poller[IotDpsResourceClientDeletePrivateEndpointConnectionResponse], error)

BeginDeletePrivateEndpointConnection - Delete private endpoint connection with the specified name If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Name of the provisioning service to retrieve.
  • privateEndpointConnectionName - The name of the private endpoint connection
  • options - IotDpsResourceClientBeginDeletePrivateEndpointConnectionOptions contains the optional parameters for the IotDpsResourceClient.BeginDeletePrivateEndpointConnection method.
Example

Generated from example definition: 2026-08-31/DPSDeletePrivateEndpointConnection.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginDeletePrivateEndpointConnection(ctx, "myResourceGroup", "myFirstProvisioningService", "myPrivateEndpointConnection", 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientDeletePrivateEndpointConnectionResponse{
	// 	PrivateEndpointConnection: armdeviceprovisioningservices.PrivateEndpointConnection{
	// 		Name: to.Ptr("myPrivateEndpointConnection"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/PrivateEndpointConnections"),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/PrivateEndpointConnections/myPrivateEndpointConnection"),
	// 		Properties: &armdeviceprovisioningservices.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armdeviceprovisioningservices.PrivateEndpoint{
	// 				ID: to.Ptr("/subscriptions/a9eba280-4734-4d49-878f-b5549d1d0453/resourceGroups/networkResourceGroup/providers/Microsoft.Network/privateEndpoints/myPrivateEndpoint"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armdeviceprovisioningservices.PrivateLinkServiceConnectionState{
	// 				Description: to.Ptr("Deleted"),
	// 				ActionsRequired: to.Ptr("None"),
	// 				Status: to.Ptr(armdeviceprovisioningservices.PrivateLinkServiceConnectionStatusDisconnected),
	// 			},
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) BeginUpdate 

func (client *IotDpsResourceClient) BeginUpdate(ctx context.Context, resourceGroupName string, provisioningServiceName string, provisioningServiceTags TagsResource, options *IotDpsResourceClientBeginUpdateOptions) (*runtime.Poller[IotDpsResourceClientUpdateResponse], error)

BeginUpdate - Update an existing provisioning service's tags. to update other fields use the CreateOrUpdate method If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • provisioningServiceName - Name of the provisioning service to retrieve.
  • provisioningServiceTags - Updated tag information to set into the provisioning service instance.
  • options - IotDpsResourceClientBeginUpdateOptions contains the optional parameters for the IotDpsResourceClient.BeginUpdate method.
Example (DpsPatch)

Generated from example definition: 2026-08-31/DPSPatch.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.TagsResource{
		Tags: map[string]*string{
			"foo": to.Ptr("bar"),
		},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
	// 			PrincipalID: to.Ptr("aa80bd74-a3f0-4f14-b9da-99c5351cf9d5"),
	// 			TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
	// 			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
	// 				"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity": &armdeviceprovisioningservices.UserAssignedIdentity{
	// 					ClientID: to.Ptr("c38f618d-47f6-4260-8b3d-1dd8c130f323"),
	// 					PrincipalID: to.Ptr("f1b0b133-10dc-4985-966f-a98a04675fe9"),
	// 				},
	// 			},
	// 		},
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 			"foo": to.Ptr("bar"),
	// 		},
	// 	},
	// }
}
Example (DpsPatchDisableLocalAuth)

Generated from example definition: 2026-08-31/DPSPatch_DisableLocalAuth.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIotDpsResourceClient().BeginUpdate(ctx, "myResourceGroup", "myFirstProvisioningService", armdeviceprovisioningservices.TagsResource{
		Tags: map[string]*string{
			"foo": to.Ptr("bar"),
		},
	}, 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 poll 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 = armdeviceprovisioningservices.IotDpsResourceClientUpdateResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 			DisableLocalAuth: to.Ptr(true),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 			"foo": to.Ptr("bar"),
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) CheckProvisioningServiceNameAvailability 

func (client *IotDpsResourceClient) CheckProvisioningServiceNameAvailability(ctx context.Context, arguments OperationInputs, options *IotDpsResourceClientCheckProvisioningServiceNameAvailabilityOptions) (IotDpsResourceClientCheckProvisioningServiceNameAvailabilityResponse, error)

CheckProvisioningServiceNameAvailability - Check if a provisioning service name is available.

Check if a provisioning service name is available. This will validate if the name is syntactically valid and if the name is usable If the operation fails it returns an *azcore.ResponseError type.

  • arguments - The request body
  • options - IotDpsResourceClientCheckProvisioningServiceNameAvailabilityOptions contains the optional parameters for the IotDpsResourceClient.CheckProvisioningServiceNameAvailability method.
Example

Generated from example definition: 2026-08-31/DPSCheckNameAvailability.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/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().CheckProvisioningServiceNameAvailability(ctx, armdeviceprovisioningservices.OperationInputs{
		Name: to.Ptr("test213123"),
	}, 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 = armdeviceprovisioningservices.IotDpsResourceClientCheckProvisioningServiceNameAvailabilityResponse{
	// 	NameAvailabilityInfo: armdeviceprovisioningservices.NameAvailabilityInfo{
	// 		Message: to.Ptr("name is valid"),
	// 		NameAvailable: to.Ptr(true),
	// 		Reason: to.Ptr(armdeviceprovisioningservices.NameUnavailabilityReasonInvalid),
	// 	},
	// }
}

func (*IotDpsResourceClient) Get 

func (client *IotDpsResourceClient) Get(ctx context.Context, provisioningServiceName string, resourceGroupName string, options *IotDpsResourceClientGetOptions) (IotDpsResourceClientGetResponse, error)

Get - Get the metadata of the provisioning service without SAS keys. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IotDpsResourceClientGetOptions contains the optional parameters for the IotDpsResourceClient.Get method.
Example (DpsGet)

Generated from example definition: 2026-08-31/DPSGet.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().Get(ctx, "myFirstProvisioningService", "myResourceGroup", 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 = armdeviceprovisioningservices.IotDpsResourceClientGetResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
	// 			Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
	// 			PrincipalID: to.Ptr("aa80bd74-a3f0-4f14-b9da-99c5351cf9d5"),
	// 			TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
	// 			UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
	// 				"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity": &armdeviceprovisioningservices.UserAssignedIdentity{
	// 					ClientID: to.Ptr("c38f618d-47f6-4260-8b3d-1dd8c130f323"),
	// 					PrincipalID: to.Ptr("f1b0b133-10dc-4985-966f-a98a04675fe9"),
	// 				},
	// 			},
	// 		},
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}
Example (DpsGetDisableLocalAuth)

Generated from example definition: 2026-08-31/DPSGet_DisableLocalAuth.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().Get(ctx, "myFirstProvisioningService", "myResourceGroup", 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 = armdeviceprovisioningservices.IotDpsResourceClientGetResponse{
	// 	ProvisioningServiceDescription: armdeviceprovisioningservices.ProvisioningServiceDescription{
	// 		Name: to.Ptr("myFirstProvisioningService"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
	// 		Etag: to.Ptr("AAAAAAAADGk="),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
	// 			AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
	// 			AuthorizationPolicies: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 			},
	// 			DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
	// 			IDScope: to.Ptr("0ne00000012"),
	// 			PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
	// 			ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
	// 			State: to.Ptr(armdeviceprovisioningservices.StateActive),
	// 			DisableLocalAuth: to.Ptr(true),
	// 		},
	// 		Resourcegroup: to.Ptr("myResourceGroup"),
	// 		SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
	// 			Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
	// 			Capacity: to.Ptr[int64](1),
	// 			Tier: to.Ptr("Standard"),
	// 		},
	// 		Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) GetOperationResult 

func (client *IotDpsResourceClient) GetOperationResult(ctx context.Context, operationID string, resourceGroupName string, provisioningServiceName string, asyncinfo string, options *IotDpsResourceClientGetOperationResultOptions) (IotDpsResourceClientGetOperationResultResponse, error)

GetOperationResult - Gets the status of a long running operation, such as create, update or delete a provisioning service. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • asyncinfo - Async header used to poll on the status of the operation, obtained while creating the long running operation.
  • options - IotDpsResourceClientGetOperationResultOptions contains the optional parameters for the IotDpsResourceClient.GetOperationResult method.
Example

Generated from example definition: 2026-08-31/DPSGetOperationResult.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().GetOperationResult(ctx, "MTY5OTNmZDctODI5Yy00N2E2LTkxNDQtMDU1NGIyYzY1ZjRl", "myResourceGroup", "myFirstProvisioningService", "1508265712453", 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 = armdeviceprovisioningservices.IotDpsResourceClientGetOperationResultResponse{
	// 	AsyncOperationResult: armdeviceprovisioningservices.AsyncOperationResult{
	// 		Status: to.Ptr("Succeeded"),
	// 	},
	// }
}

func (*IotDpsResourceClient) GetPrivateEndpointConnection 

func (client *IotDpsResourceClient) GetPrivateEndpointConnection(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *IotDpsResourceClientGetPrivateEndpointConnectionOptions) (IotDpsResourceClientGetPrivateEndpointConnectionResponse, error)

GetPrivateEndpointConnection - Get private endpoint connection properties If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Name of the provisioning service to retrieve.
  • privateEndpointConnectionName - The name of the private endpoint connection
  • options - IotDpsResourceClientGetPrivateEndpointConnectionOptions contains the optional parameters for the IotDpsResourceClient.GetPrivateEndpointConnection method.
Example

Generated from example definition: 2026-08-31/DPSGetPrivateEndpointConnection.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().GetPrivateEndpointConnection(ctx, "myResourceGroup", "myFirstProvisioningService", "myPrivateEndpointConnection", 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 = armdeviceprovisioningservices.IotDpsResourceClientGetPrivateEndpointConnectionResponse{
	// 	PrivateEndpointConnection: armdeviceprovisioningservices.PrivateEndpointConnection{
	// 		Name: to.Ptr("myPrivateEndpointConnection"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/PrivateEndpointConnections"),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/PrivateEndpointConnections/myPrivateEndpointConnection"),
	// 		Properties: &armdeviceprovisioningservices.PrivateEndpointConnectionProperties{
	// 			PrivateEndpoint: &armdeviceprovisioningservices.PrivateEndpoint{
	// 				ID: to.Ptr("/subscriptions/a9eba280-4734-4d49-878f-b5549d1d0453/resourceGroups/networkResourceGroup/providers/Microsoft.Network/privateEndpoints/myPrivateEndpoint"),
	// 			},
	// 			PrivateLinkServiceConnectionState: &armdeviceprovisioningservices.PrivateLinkServiceConnectionState{
	// 				Description: to.Ptr("Please approve my request!"),
	// 				ActionsRequired: to.Ptr("None"),
	// 				Status: to.Ptr(armdeviceprovisioningservices.PrivateLinkServiceConnectionStatusPending),
	// 			},
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) GetPrivateLinkResources 

func (client *IotDpsResourceClient) GetPrivateLinkResources(ctx context.Context, resourceGroupName string, resourceName string, groupID string, options *IotDpsResourceClientGetPrivateLinkResourcesOptions) (IotDpsResourceClientGetPrivateLinkResourcesResponse, error)

GetPrivateLinkResources - Get the specified private link resource for the given provisioning service If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Name of the provisioning service to retrieve.
  • groupID - The name of the private link resource
  • options - IotDpsResourceClientGetPrivateLinkResourcesOptions contains the optional parameters for the IotDpsResourceClient.GetPrivateLinkResources method.
Example

Generated from example definition: 2026-08-31/DPSGetPrivateLinkResources.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().GetPrivateLinkResources(ctx, "myResourceGroup", "myFirstProvisioningService", "iotDps", 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 = armdeviceprovisioningservices.IotDpsResourceClientGetPrivateLinkResourcesResponse{
	// 	GroupIDInformation: armdeviceprovisioningservices.GroupIDInformation{
	// 		Name: to.Ptr("iotDps"),
	// 		Type: to.Ptr("Microsoft.Devices/ProvisioningServices/PrivateLinkResources"),
	// 		ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/PrivateLinkResources/iotDps"),
	// 		Properties: &armdeviceprovisioningservices.GroupIDInformationProperties{
	// 			GroupID: to.Ptr("iotDps"),
	// 			RequiredMembers: []*string{
	// 				to.Ptr("iotDps"),
	// 			},
	// 			RequiredZoneNames: []*string{
	// 				to.Ptr("privatelink.azure-devices-provisioning.net"),
	// 			},
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) ListKeysForKeyName 

func (client *IotDpsResourceClient) ListKeysForKeyName(ctx context.Context, provisioningServiceName string, keyName string, resourceGroupName string, options *IotDpsResourceClientListKeysForKeyNameOptions) (IotDpsResourceClientListKeysForKeyNameResponse, error)

ListKeysForKeyName - List primary and secondary keys for a specific key name If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IotDpsResourceClientListKeysForKeyNameOptions contains the optional parameters for the IotDpsResourceClient.ListKeysForKeyName method.
Example

Generated from example definition: 2026-08-31/DPSGetKey.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().ListKeysForKeyName(ctx, "myFirstProvisioningService", "testKey", "myResourceGroup", 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 = armdeviceprovisioningservices.IotDpsResourceClientListKeysForKeyNameResponse{
	// 	SharedAccessSignatureAuthorizationRuleAccessRightsDescription: armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
	// 		KeyName: to.Ptr("testKey"),
	// 		PrimaryKey: to.Ptr("##################################"),
	// 		Rights: to.Ptr(armdeviceprovisioningservices.AccessRightsDescriptionRegistrationStatusWrite),
	// 		SecondaryKey: to.Ptr("################################"),
	// 	},
	// }
}

func (*IotDpsResourceClient) ListPrivateEndpointConnections 

func (client *IotDpsResourceClient) ListPrivateEndpointConnections(ctx context.Context, resourceGroupName string, resourceName string, options *IotDpsResourceClientListPrivateEndpointConnectionsOptions) (IotDpsResourceClientListPrivateEndpointConnectionsResponse, error)

ListPrivateEndpointConnections - List private endpoint connection properties If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Name of the provisioning service to retrieve.
  • options - IotDpsResourceClientListPrivateEndpointConnectionsOptions contains the optional parameters for the IotDpsResourceClient.ListPrivateEndpointConnections method.
Example

Generated from example definition: 2026-08-31/DPSListPrivateEndpointConnections.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().ListPrivateEndpointConnections(ctx, "myResourceGroup", "myFirstProvisioningService", 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 = armdeviceprovisioningservices.IotDpsResourceClientListPrivateEndpointConnectionsResponse{
	// 	PrivateEndpointConnectionArray: []*armdeviceprovisioningservices.PrivateEndpointConnection{
	// 		{
	// 			Name: to.Ptr("myPrivateEndpointConnection"),
	// 			Type: to.Ptr("Microsoft.Devices/ProvisioningServices/PrivateEndpointConnections"),
	// 			ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/PrivateEndpointConnections/myPrivateEndpointConnection"),
	// 			Properties: &armdeviceprovisioningservices.PrivateEndpointConnectionProperties{
	// 				PrivateEndpoint: &armdeviceprovisioningservices.PrivateEndpoint{
	// 					ID: to.Ptr("/subscriptions/a9eba280-4734-4d49-878f-b5549d1d0453/resourceGroups/networkResourceGroup/providers/Microsoft.Network/privateEndpoints/myPrivateEndpoint"),
	// 				},
	// 				PrivateLinkServiceConnectionState: &armdeviceprovisioningservices.PrivateLinkServiceConnectionState{
	// 					Description: to.Ptr("Please approve my request!"),
	// 					ActionsRequired: to.Ptr("None"),
	// 					Status: to.Ptr(armdeviceprovisioningservices.PrivateLinkServiceConnectionStatusPending),
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) ListPrivateLinkResources 

func (client *IotDpsResourceClient) ListPrivateLinkResources(ctx context.Context, resourceGroupName string, resourceName string, options *IotDpsResourceClientListPrivateLinkResourcesOptions) (IotDpsResourceClientListPrivateLinkResourcesResponse, error)

ListPrivateLinkResources - List private link resources for the given provisioning service If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - Name of the provisioning service to retrieve.
  • options - IotDpsResourceClientListPrivateLinkResourcesOptions contains the optional parameters for the IotDpsResourceClient.ListPrivateLinkResources method.
Example

Generated from example definition: 2026-08-31/DPSListPrivateLinkResources.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIotDpsResourceClient().ListPrivateLinkResources(ctx, "myResourceGroup", "myFirstProvisioningService", 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 = armdeviceprovisioningservices.IotDpsResourceClientListPrivateLinkResourcesResponse{
	// 	PrivateLinkResources: armdeviceprovisioningservices.PrivateLinkResources{
	// 		Value: []*armdeviceprovisioningservices.GroupIDInformation{
	// 			{
	// 				Name: to.Ptr("iotDps"),
	// 				Type: to.Ptr("Microsoft.Devices/ProvisioningServices/PrivateLinkResources"),
	// 				ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService/PrivateLinkResources/iotDps"),
	// 				Properties: &armdeviceprovisioningservices.GroupIDInformationProperties{
	// 					GroupID: to.Ptr("iotDps"),
	// 					RequiredMembers: []*string{
	// 						to.Ptr("iotDps"),
	// 					},
	// 					RequiredZoneNames: []*string{
	// 						to.Ptr("privatelink.azure-devices-provisioning.net"),
	// 					},
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}

func (*IotDpsResourceClient) NewListByResourceGroupPager added in v0.4.0 

func (client *IotDpsResourceClient) NewListByResourceGroupPager(resourceGroupName string, options *IotDpsResourceClientListByResourceGroupOptions) *runtime.Pager[IotDpsResourceClientListByResourceGroupResponse]

NewListByResourceGroupPager - Get a list of all provisioning services in the given resource group.

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

Generated from example definition: 2026-08-31/DPSListByResourceGroup.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIotDpsResourceClient().NewListByResourceGroupPager("myResourceGroup", 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 = armdeviceprovisioningservices.IotDpsResourceClientListByResourceGroupResponse{
		// 	ProvisioningServiceDescriptionListResult: armdeviceprovisioningservices.ProvisioningServiceDescriptionListResult{
		// 		Value: []*armdeviceprovisioningservices.ProvisioningServiceDescription{
		// 			{
		// 				Name: to.Ptr("myFirstProvisioningService"),
		// 				Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
		// 				Etag: to.Ptr("AAAAAAAADGk="),
		// 				ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
		// 				Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
		// 					Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
		// 					PrincipalID: to.Ptr("aa80bd74-a3f0-4f14-b9da-99c5351cf9d5"),
		// 					TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
		// 					UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
		// 						"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity": &armdeviceprovisioningservices.UserAssignedIdentity{
		// 							ClientID: to.Ptr("c38f618d-47f6-4260-8b3d-1dd8c130f323"),
		// 							PrincipalID: to.Ptr("f1b0b133-10dc-4985-966f-a98a04675fe9"),
		// 						},
		// 					},
		// 				},
		// 				Location: to.Ptr("eastus"),
		// 				Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
		// 					AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
		// 					DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
		// 					IDScope: to.Ptr("0ne00000012"),
		// 					PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
		// 					ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
		// 					State: to.Ptr(armdeviceprovisioningservices.StateActive),
		// 				},
		// 				Resourcegroup: to.Ptr("myResourceGroup"),
		// 				SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
		// 					Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
		// 					Capacity: to.Ptr[int64](1),
		// 					Tier: to.Ptr("Standard"),
		// 				},
		// 				Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("mySecondProvisioningService"),
		// 				Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
		// 				Etag: to.Ptr("AAAAAAAADGk="),
		// 				ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/mySecondProvisioningService"),
		// 				Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
		// 					Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
		// 					PrincipalID: to.Ptr("01341f2b-d497-4117-b5c1-1f1d50b25444"),
		// 					TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
		// 					UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
		// 						"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity2": &armdeviceprovisioningservices.UserAssignedIdentity{
		// 							ClientID: to.Ptr("8cd6d250-17dd-4c1b-9847-225237b94c55"),
		// 							PrincipalID: to.Ptr("8785a11f-848a-4d5d-a55b-e381b9e15512"),
		// 						},
		// 					},
		// 				},
		// 				Location: to.Ptr("eastus"),
		// 				Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
		// 					AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
		// 					DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
		// 					IDScope: to.Ptr("0ne00000012"),
		// 					PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
		// 					ServiceOperationsHostName: to.Ptr("mySecondProvisioningService.azure-devices-provisioning.net"),
		// 					State: to.Ptr(armdeviceprovisioningservices.StateActive),
		// 				},
		// 				Resourcegroup: to.Ptr("myResourceGroup"),
		// 				SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
		// 					Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
		// 					Capacity: to.Ptr[int64](1),
		// 					Tier: to.Ptr("Standard"),
		// 				},
		// 				Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*IotDpsResourceClient) NewListBySubscriptionPager added in v0.4.0 

func (client *IotDpsResourceClient) NewListBySubscriptionPager(options *IotDpsResourceClientListBySubscriptionOptions) *runtime.Pager[IotDpsResourceClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all the provisioning services for a given subscription id.

  • options - IotDpsResourceClientListBySubscriptionOptions contains the optional parameters for the IotDpsResourceClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2026-08-31/DPSListBySubscription.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIotDpsResourceClient().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 = armdeviceprovisioningservices.IotDpsResourceClientListBySubscriptionResponse{
		// 	ProvisioningServiceDescriptionListResult: armdeviceprovisioningservices.ProvisioningServiceDescriptionListResult{
		// 		Value: []*armdeviceprovisioningservices.ProvisioningServiceDescription{
		// 			{
		// 				Name: to.Ptr("myFirstProvisioningService"),
		// 				Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
		// 				Etag: to.Ptr("AAAAAAAADGk="),
		// 				ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/myFirstProvisioningService"),
		// 				Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
		// 					Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
		// 					PrincipalID: to.Ptr("aa80bd74-a3f0-4f14-b9da-99c5351cf9d5"),
		// 					TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
		// 					UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
		// 						"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity": &armdeviceprovisioningservices.UserAssignedIdentity{
		// 							ClientID: to.Ptr("c38f618d-47f6-4260-8b3d-1dd8c130f323"),
		// 							PrincipalID: to.Ptr("f1b0b133-10dc-4985-966f-a98a04675fe9"),
		// 						},
		// 					},
		// 				},
		// 				Location: to.Ptr("eastus"),
		// 				Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
		// 					AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
		// 					DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
		// 					IDScope: to.Ptr("0ne00000012"),
		// 					PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
		// 					ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
		// 					State: to.Ptr(armdeviceprovisioningservices.StateActive),
		// 				},
		// 				Resourcegroup: to.Ptr("myResourceGroup"),
		// 				SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
		// 					Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
		// 					Capacity: to.Ptr[int64](1),
		// 					Tier: to.Ptr("Standard"),
		// 				},
		// 				Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("mySecondProvisioningService"),
		// 				Type: to.Ptr("Microsoft.Devices/ProvisioningServices"),
		// 				Etag: to.Ptr("AAAAAAAADGk="),
		// 				ID: to.Ptr("/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourceGroups/myResourceGroup/providers/Microsoft.Devices/ProvisioningServices/mySecondProvisioningService"),
		// 				Identity: &armdeviceprovisioningservices.ManagedServiceIdentity{
		// 					Type: to.Ptr(armdeviceprovisioningservices.ManagedServiceIdentityTypeSystemAssignedUserAssigned),
		// 					PrincipalID: to.Ptr("01341f2b-d497-4117-b5c1-1f1d50b25444"),
		// 					TenantID: to.Ptr("f686d426-8d16-42db-81b7-ab578e110ccd"),
		// 					UserAssignedIdentities: map[string]*armdeviceprovisioningservices.UserAssignedIdentity{
		// 						"/subscriptions/91d12660-3dec-467a-be2a-213b5544ddc0/resourcegroups/testrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testidentity2": &armdeviceprovisioningservices.UserAssignedIdentity{
		// 							ClientID: to.Ptr("8cd6d250-17dd-4c1b-9847-225237b94c55"),
		// 							PrincipalID: to.Ptr("8785a11f-848a-4d5d-a55b-e381b9e15512"),
		// 						},
		// 					},
		// 				},
		// 				Location: to.Ptr("eastus"),
		// 				Properties: &armdeviceprovisioningservices.IotDpsPropertiesDescription{
		// 					AllocationPolicy: to.Ptr(armdeviceprovisioningservices.AllocationPolicyHashed),
		// 					DeviceProvisioningHostName: to.Ptr("global.azure-devices-provisioning.net"),
		// 					IDScope: to.Ptr("0ne00000012"),
		// 					PortalOperationsHostName: to.Ptr("myFirstProvisioningService.services.azure-devices-provisioning.net"),
		// 					ServiceOperationsHostName: to.Ptr("myFirstProvisioningService.azure-devices-provisioning.net"),
		// 					State: to.Ptr(armdeviceprovisioningservices.StateActive),
		// 				},
		// 				Resourcegroup: to.Ptr("myResourceGroup"),
		// 				SKU: &armdeviceprovisioningservices.IotDpsSKUInfo{
		// 					Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
		// 					Capacity: to.Ptr[int64](1),
		// 					Tier: to.Ptr("Standard"),
		// 				},
		// 				Subscriptionid: to.Ptr("91d12660-3dec-467a-be2a-213b5544ddc0"),
		// 				Tags: map[string]*string{
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*IotDpsResourceClient) NewListKeysPager added in v0.4.0 

func (client *IotDpsResourceClient) NewListKeysPager(provisioningServiceName string, resourceGroupName string, options *IotDpsResourceClientListKeysOptions) *runtime.Pager[IotDpsResourceClientListKeysResponse]

NewListKeysPager - List the primary and secondary keys for a provisioning service.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IotDpsResourceClientListKeysOptions contains the optional parameters for the IotDpsResourceClient.NewListKeysPager method.
Example

Generated from example definition: 2026-08-31/DPSListKeys.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIotDpsResourceClient().NewListKeysPager("myFirstProvisioningService", "myResourceGroup", 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 = armdeviceprovisioningservices.IotDpsResourceClientListKeysResponse{
		// 	SharedAccessSignatureAuthorizationRuleListResult: armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleListResult{
		// 		Value: []*armdeviceprovisioningservices.SharedAccessSignatureAuthorizationRuleAccessRightsDescription{
		// 			{
		// 				KeyName: to.Ptr("key1"),
		// 				PrimaryKey: to.Ptr("#####################################"),
		// 				Rights: to.Ptr(armdeviceprovisioningservices.AccessRightsDescriptionServiceConfig),
		// 				SecondaryKey: to.Ptr("###################################"),
		// 			},
		// 			{
		// 				KeyName: to.Ptr("key2"),
		// 				PrimaryKey: to.Ptr("#######################################"),
		// 				Rights: to.Ptr(armdeviceprovisioningservices.AccessRightsDescriptionServiceConfig),
		// 				SecondaryKey: to.Ptr("####################################="),
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*IotDpsResourceClient) NewListValidSKUsPager added in v0.4.0 

func (client *IotDpsResourceClient) NewListValidSKUsPager(provisioningServiceName string, resourceGroupName string, options *IotDpsResourceClientListValidSKUsOptions) *runtime.Pager[IotDpsResourceClientListValidSKUsResponse]

NewListValidSKUsPager - Gets the list of valid SKUs and tiers for a provisioning service.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - IotDpsResourceClientListValidSKUsOptions contains the optional parameters for the IotDpsResourceClient.NewListValidSKUsPager method.
Example

Generated from example definition: 2026-08-31/DPSGetValidSku.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.NewClientFactory("91d12660-3dec-467a-be2a-213b5544ddc0", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIotDpsResourceClient().NewListValidSKUsPager("myFirstProvisioningService", "myResourceGroup", 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 = armdeviceprovisioningservices.IotDpsResourceClientListValidSKUsResponse{
		// 	IotDpsSKUDefinitionListResult: armdeviceprovisioningservices.IotDpsSKUDefinitionListResult{
		// 		Value: []*armdeviceprovisioningservices.IotDpsSKUDefinition{
		// 			{
		// 				Name: to.Ptr(armdeviceprovisioningservices.IotDpsSKUS1),
		// 			},
		// 		},
		// 	},
		// }
	}
}

type IotDpsResourceClientBeginCreateOrUpdateOptions added in v0.2.0 

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

IotDpsResourceClientBeginCreateOrUpdateOptions contains the optional parameters for the IotDpsResourceClient.BeginCreateOrUpdate method.

type IotDpsResourceClientBeginCreateOrUpdatePrivateEndpointConnectionOptions added in v0.2.0 

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

IotDpsResourceClientBeginCreateOrUpdatePrivateEndpointConnectionOptions contains the optional parameters for the IotDpsResourceClient.BeginCreateOrUpdatePrivateEndpointConnection method.

type IotDpsResourceClientBeginDeleteOptions added in v0.2.0 

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

IotDpsResourceClientBeginDeleteOptions contains the optional parameters for the IotDpsResourceClient.BeginDelete method.

type IotDpsResourceClientBeginDeletePrivateEndpointConnectionOptions added in v0.2.0 

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

IotDpsResourceClientBeginDeletePrivateEndpointConnectionOptions contains the optional parameters for the IotDpsResourceClient.BeginDeletePrivateEndpointConnection method.

type IotDpsResourceClientBeginUpdateOptions added in v0.2.0 

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

IotDpsResourceClientBeginUpdateOptions contains the optional parameters for the IotDpsResourceClient.BeginUpdate method.

type IotDpsResourceClientCheckProvisioningServiceNameAvailabilityOptions added in v0.2.0 

type IotDpsResourceClientCheckProvisioningServiceNameAvailabilityOptions struct {
}

IotDpsResourceClientCheckProvisioningServiceNameAvailabilityOptions contains the optional parameters for the IotDpsResourceClient.CheckProvisioningServiceNameAvailability method.

type IotDpsResourceClientCheckProvisioningServiceNameAvailabilityResponse added in v0.2.0 

type IotDpsResourceClientCheckProvisioningServiceNameAvailabilityResponse struct {
	// Description of name availability.
	NameAvailabilityInfo
}

IotDpsResourceClientCheckProvisioningServiceNameAvailabilityResponse contains the response from method IotDpsResourceClient.CheckProvisioningServiceNameAvailability.

type IotDpsResourceClientCreateOrUpdatePrivateEndpointConnectionResponse added in v0.2.0 

type IotDpsResourceClientCreateOrUpdatePrivateEndpointConnectionResponse struct {
	// The private endpoint connection of a provisioning service
	PrivateEndpointConnection
}

IotDpsResourceClientCreateOrUpdatePrivateEndpointConnectionResponse contains the response from method IotDpsResourceClient.BeginCreateOrUpdatePrivateEndpointConnection.

type IotDpsResourceClientCreateOrUpdateResponse added in v0.2.0 

type IotDpsResourceClientCreateOrUpdateResponse struct {
	// The description of the provisioning service.
	ProvisioningServiceDescription
}

IotDpsResourceClientCreateOrUpdateResponse contains the response from method IotDpsResourceClient.BeginCreateOrUpdate.

type IotDpsResourceClientDeletePrivateEndpointConnectionResponse added in v0.2.0 

type IotDpsResourceClientDeletePrivateEndpointConnectionResponse struct {
	// The private endpoint connection of a provisioning service
	PrivateEndpointConnection
}

IotDpsResourceClientDeletePrivateEndpointConnectionResponse contains the response from method IotDpsResourceClient.BeginDeletePrivateEndpointConnection.

type IotDpsResourceClientDeleteResponse added in v0.2.0 

type IotDpsResourceClientDeleteResponse struct {
}

IotDpsResourceClientDeleteResponse contains the response from method IotDpsResourceClient.BeginDelete.

type IotDpsResourceClientGetOperationResultOptions added in v0.2.0 

type IotDpsResourceClientGetOperationResultOptions struct {
}

IotDpsResourceClientGetOperationResultOptions contains the optional parameters for the IotDpsResourceClient.GetOperationResult method.

type IotDpsResourceClientGetOperationResultResponse added in v0.2.0 

type IotDpsResourceClientGetOperationResultResponse struct {
	// Result of a long running operation.
	AsyncOperationResult
}

IotDpsResourceClientGetOperationResultResponse contains the response from method IotDpsResourceClient.GetOperationResult.

type IotDpsResourceClientGetOptions added in v0.2.0 

type IotDpsResourceClientGetOptions struct {
}

IotDpsResourceClientGetOptions contains the optional parameters for the IotDpsResourceClient.Get method.

type IotDpsResourceClientGetPrivateEndpointConnectionOptions added in v0.2.0 

type IotDpsResourceClientGetPrivateEndpointConnectionOptions struct {
}

IotDpsResourceClientGetPrivateEndpointConnectionOptions contains the optional parameters for the IotDpsResourceClient.GetPrivateEndpointConnection method.

type IotDpsResourceClientGetPrivateEndpointConnectionResponse added in v0.2.0 

type IotDpsResourceClientGetPrivateEndpointConnectionResponse struct {
	// The private endpoint connection of a provisioning service
	PrivateEndpointConnection
}

IotDpsResourceClientGetPrivateEndpointConnectionResponse contains the response from method IotDpsResourceClient.GetPrivateEndpointConnection.

type IotDpsResourceClientGetPrivateLinkResourcesOptions added in v0.2.0 

type IotDpsResourceClientGetPrivateLinkResourcesOptions struct {
}

IotDpsResourceClientGetPrivateLinkResourcesOptions contains the optional parameters for the IotDpsResourceClient.GetPrivateLinkResources method.

type IotDpsResourceClientGetPrivateLinkResourcesResponse added in v0.2.0 

type IotDpsResourceClientGetPrivateLinkResourcesResponse struct {
	// The group information for creating a private endpoint on a provisioning service
	GroupIDInformation
}

IotDpsResourceClientGetPrivateLinkResourcesResponse contains the response from method IotDpsResourceClient.GetPrivateLinkResources.

type IotDpsResourceClientGetResponse added in v0.2.0 

type IotDpsResourceClientGetResponse struct {
	// The description of the provisioning service.
	ProvisioningServiceDescription
}

IotDpsResourceClientGetResponse contains the response from method IotDpsResourceClient.Get.

type IotDpsResourceClientListByResourceGroupOptions added in v0.2.0 

type IotDpsResourceClientListByResourceGroupOptions struct {
}

IotDpsResourceClientListByResourceGroupOptions contains the optional parameters for the IotDpsResourceClient.NewListByResourceGroupPager method.

type IotDpsResourceClientListByResourceGroupResponse added in v0.2.0 

type IotDpsResourceClientListByResourceGroupResponse struct {
	// The response of a ProvisioningServiceDescription list operation.
	ProvisioningServiceDescriptionListResult
}

IotDpsResourceClientListByResourceGroupResponse contains the response from method IotDpsResourceClient.NewListByResourceGroupPager.

type IotDpsResourceClientListBySubscriptionOptions added in v0.2.0 

type IotDpsResourceClientListBySubscriptionOptions struct {
}

IotDpsResourceClientListBySubscriptionOptions contains the optional parameters for the IotDpsResourceClient.NewListBySubscriptionPager method.

type IotDpsResourceClientListBySubscriptionResponse added in v0.2.0 

type IotDpsResourceClientListBySubscriptionResponse struct {
	// The response of a ProvisioningServiceDescription list operation.
	ProvisioningServiceDescriptionListResult
}

IotDpsResourceClientListBySubscriptionResponse contains the response from method IotDpsResourceClient.NewListBySubscriptionPager.

type IotDpsResourceClientListKeysForKeyNameOptions added in v0.2.0 

type IotDpsResourceClientListKeysForKeyNameOptions struct {
}

IotDpsResourceClientListKeysForKeyNameOptions contains the optional parameters for the IotDpsResourceClient.ListKeysForKeyName method.

type IotDpsResourceClientListKeysForKeyNameResponse added in v0.2.0 

type IotDpsResourceClientListKeysForKeyNameResponse struct {
	// Description of the shared access key.
	SharedAccessSignatureAuthorizationRuleAccessRightsDescription
}

IotDpsResourceClientListKeysForKeyNameResponse contains the response from method IotDpsResourceClient.ListKeysForKeyName.

type IotDpsResourceClientListKeysOptions added in v0.2.0 

type IotDpsResourceClientListKeysOptions struct {
}

IotDpsResourceClientListKeysOptions contains the optional parameters for the IotDpsResourceClient.NewListKeysPager method.

type IotDpsResourceClientListKeysResponse added in v0.2.0 

type IotDpsResourceClientListKeysResponse struct {
	// List of shared access keys.
	SharedAccessSignatureAuthorizationRuleListResult
}

IotDpsResourceClientListKeysResponse contains the response from method IotDpsResourceClient.NewListKeysPager.

type IotDpsResourceClientListPrivateEndpointConnectionsOptions added in v0.2.0 

type IotDpsResourceClientListPrivateEndpointConnectionsOptions struct {
}

IotDpsResourceClientListPrivateEndpointConnectionsOptions contains the optional parameters for the IotDpsResourceClient.ListPrivateEndpointConnections method.

type IotDpsResourceClientListPrivateEndpointConnectionsResponse added in v0.2.0 

type IotDpsResourceClientListPrivateEndpointConnectionsResponse struct {
	PrivateEndpointConnectionArray []*PrivateEndpointConnection
}

IotDpsResourceClientListPrivateEndpointConnectionsResponse contains the response from method IotDpsResourceClient.ListPrivateEndpointConnections.

type IotDpsResourceClientListPrivateLinkResourcesOptions added in v0.2.0 

type IotDpsResourceClientListPrivateLinkResourcesOptions struct {
}

IotDpsResourceClientListPrivateLinkResourcesOptions contains the optional parameters for the IotDpsResourceClient.ListPrivateLinkResources method.

type IotDpsResourceClientListPrivateLinkResourcesResponse added in v0.2.0 

type IotDpsResourceClientListPrivateLinkResourcesResponse struct {
	// The available private link resources for a provisioning service
	PrivateLinkResources
}

IotDpsResourceClientListPrivateLinkResourcesResponse contains the response from method IotDpsResourceClient.ListPrivateLinkResources.

type IotDpsResourceClientListValidSKUsOptions added in v0.2.0 

type IotDpsResourceClientListValidSKUsOptions struct {
}

IotDpsResourceClientListValidSKUsOptions contains the optional parameters for the IotDpsResourceClient.NewListValidSKUsPager method.

type IotDpsResourceClientListValidSKUsResponse added in v0.2.0 

type IotDpsResourceClientListValidSKUsResponse struct {
	// List of available SKUs.
	IotDpsSKUDefinitionListResult
}

IotDpsResourceClientListValidSKUsResponse contains the response from method IotDpsResourceClient.NewListValidSKUsPager.

type IotDpsResourceClientUpdateResponse added in v0.2.0 

type IotDpsResourceClientUpdateResponse struct {
	// The description of the provisioning service.
	ProvisioningServiceDescription
}

IotDpsResourceClientUpdateResponse contains the response from method IotDpsResourceClient.BeginUpdate.

type IotDpsSKU 

type IotDpsSKU string

IotDpsSKU - Sku name. 

const (
	IotDpsSKUS1 IotDpsSKU = "S1"
)

func PossibleIotDpsSKUValues 

func PossibleIotDpsSKUValues() []IotDpsSKU

PossibleIotDpsSKUValues returns the possible values for the IotDpsSKU const type.

type IotDpsSKUDefinition 

type IotDpsSKUDefinition struct {
	// Sku name.
	Name *IotDpsSKU
}

IotDpsSKUDefinition - Available SKUs of tier and units.

func (IotDpsSKUDefinition) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type IotDpsSKUDefinition.

func (*IotDpsSKUDefinition) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotDpsSKUDefinition.

type IotDpsSKUDefinitionListResult 

type IotDpsSKUDefinitionListResult struct {
	// REQUIRED; The IotDpsSkuDefinition items on this page
	Value []*IotDpsSKUDefinition

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

IotDpsSKUDefinitionListResult - List of available SKUs.

func (IotDpsSKUDefinitionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IotDpsSKUDefinitionListResult.

func (*IotDpsSKUDefinitionListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotDpsSKUDefinitionListResult.

type IotDpsSKUInfo 

type IotDpsSKUInfo struct {
	// The number of units to provision
	Capacity *int64

	// Sku name.
	Name *IotDpsSKU

	// READ-ONLY; Pricing tier name of the provisioning service.
	Tier *string
}

IotDpsSKUInfo - List of possible provisioning service SKUs.

func (IotDpsSKUInfo) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type IotDpsSKUInfo.

func (*IotDpsSKUInfo) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotDpsSKUInfo.

type IotHubAuthenticationType 

type IotHubAuthenticationType string

IotHubAuthenticationType - IotHub MI authentication type: KeyBased, UserAssigned, SystemAssigned. 

const (
	// IotHubAuthenticationTypeKeyBased - Key Based authentication type.
	IotHubAuthenticationTypeKeyBased IotHubAuthenticationType = "KeyBased"
	// IotHubAuthenticationTypeSystemAssigned - System assigned authentication type.
	IotHubAuthenticationTypeSystemAssigned IotHubAuthenticationType = "SystemAssigned"
	// IotHubAuthenticationTypeUserAssigned - User assigned authentication type.
	IotHubAuthenticationTypeUserAssigned IotHubAuthenticationType = "UserAssigned"
)

func PossibleIotHubAuthenticationTypeValues 

func PossibleIotHubAuthenticationTypeValues() []IotHubAuthenticationType

PossibleIotHubAuthenticationTypeValues returns the possible values for the IotHubAuthenticationType const type.

type IotHubDefinitionDescription 

type IotHubDefinitionDescription struct {
	// REQUIRED; ARM region of the IoT hub.
	Location *string

	// weight to apply for a given iot h.
	AllocationWeight *int32

	// flag for applying allocationPolicy or not for a given iot hub.
	ApplyAllocationPolicy *bool

	// IotHub MI authentication type: KeyBased, UserAssigned, SystemAssigned.
	AuthenticationType *IotHubAuthenticationType

	// Connection string of the IoT hub. This is required when authenticationType is KeyBased.
	ConnectionString *string

	// Host name of the IoT hub. This is required when connectionString is not provided.
	HostName *string

	// The selected user-assigned identity resource Id associated with IoT hub. This is required when authenticationType is UserAssigned.
	SelectedUserAssignedIdentityResourceID *string

	// READ-ONLY; Host name of the IoT hub.
	Name *string
}

IotHubDefinitionDescription - Description of the IoT hub.

func (IotHubDefinitionDescription) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type IotHubDefinitionDescription.

func (*IotHubDefinitionDescription) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IotHubDefinitionDescription.

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"
	// ManagedServiceIdentityTypeSystemAssigned - System assigned managed identity.
	ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned"
	// ManagedServiceIdentityTypeSystemAssignedUserAssigned - System and user assigned managed identity.
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	// ManagedServiceIdentityTypeUserAssigned - User assigned managed identity.
	ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type NameAvailabilityInfo 

type NameAvailabilityInfo struct {
	// message containing a detailed reason name is unavailable
	Message *string

	// specifies if a name is available or not
	NameAvailable *bool

	// specifies the reason a name is unavailable
	Reason *NameUnavailabilityReason
}

NameAvailabilityInfo - Description of name availability.

func (NameAvailabilityInfo) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type NameAvailabilityInfo.

func (*NameAvailabilityInfo) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NameAvailabilityInfo.

type NameUnavailabilityReason 

type NameUnavailabilityReason string

NameUnavailabilityReason - specifies the reason a name is unavailable 

const (
	NameUnavailabilityReasonAlreadyExists NameUnavailabilityReason = "AlreadyExists"
	NameUnavailabilityReasonInvalid       NameUnavailabilityReason = "Invalid"
)

func PossibleNameUnavailabilityReasonValues 

func PossibleNameUnavailabilityReasonValues() []NameUnavailabilityReason

PossibleNameUnavailabilityReasonValues returns the possible values for the NameUnavailabilityReason const type.

type Operation 

type Operation struct {
	// The display information for the operation.
	Display *OperationDisplay

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

Operation - Represents an operation.

func (Operation) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; Name of the operation.
	Operation *string

	// READ-ONLY; Service provider: Microsoft Devices.
	Provider *string

	// READ-ONLY; Resource Type: ProvisioningServices.
	Resource *string
}

func (OperationDisplay) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationInputs 

type OperationInputs struct {
	// REQUIRED; The name of the Provisioning Service to check.
	Name *string
}

OperationInputs - Input values for operation results call.

func (OperationInputs) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationInputs.

func (*OperationInputs) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationInputs.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; [Placeholder] Description for value property
	Value []*Operation

	// [Placeholder] Description for nextLink property.
	NextLink *string
}

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

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

OperationsClient - This is the interface that implements the standard Azure Resource Manager operation that returns all supported RP operations. You should have exactly one declaration for each Azure Resource Manager service. It implements GET "/providers/Microsoft.ContosoProviderHub/operations" Don't use this type directly, use NewOperationsClient() instead.

Generated from API version 2026-08-31

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 - Contains optional client configuration. Pass nil to accept the default values.

func (*OperationsClient) NewListPager added in v0.4.0 

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

NewListPager - List the operations for the provider

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

Generated from example definition: 2026-08-31/DPSOperations.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/deviceprovisioningservices/armdeviceprovisioningservices"
	"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 := armdeviceprovisioningservices.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 = armdeviceprovisioningservices.OperationsClientListResponse{
		// 	OperationListResult: armdeviceprovisioningservices.OperationListResult{
		// 		Value: []*armdeviceprovisioningservices.Operation{
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/register/action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Register Resource Provider"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/IotHubs/diagnosticSettings/read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get Diagnostic Setting"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/IotHubs/diagnosticSettings/write"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Set Diagnostic Setting"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/IotHubs/metricDefinitions/read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Read IotHub service metric definitions"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/IotHubs/logDefinitions/read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Read IotHub service log definitions"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/operations/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get All ResourceProvider Operations"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/checkNameAvailability/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Check If IotHub name is available"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/usages/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get Subscription Usages"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get IotHub(s)"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/Write"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Create or update IotHub Resource"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/Delete"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Delete IotHub Resource"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/iotHubStats/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get IotHub Statistics"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/skus/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get valid IotHub Skus"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/listkeys/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get all IotHub Keys"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/iotHubKeys/listkeys/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get IotHub Key for the given name"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/eventHubEndpoints/consumerGroups/Write"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Create EventHub Consumer Group"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/eventHubEndpoints/consumerGroups/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get EventHub Consumer Group(s)"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/eventHubEndpoints/consumerGroups/Delete"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Delete EventHub Consumer Group"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/exportDevices/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Export Devices"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/importDevices/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Import Devices"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/jobs/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get the Job(s) on IotHub"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/quotaMetrics/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get Quota Metrics"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/routing/routes/$testall/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Routing Rule Test All"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/routing/routes/$testnew/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Routing Rule Test Route"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/iotHubs/routingEndpointsHealth/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get Endpoint Health"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/ProvisioningServices/diagnosticSettings/read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get Diagnostic Setting"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/ProvisioningServices/diagnosticSettings/write"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Set Diagnostic Setting"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/ProvisioningServices/metricDefinitions/read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Read DPS service metric definitions"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/ProvisioningServices/logDefinitions/read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Read DPS service log definitions"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("IotHubs"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/checkProvisioningServiceNameAvailability/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Check If Provisioning Service name is available"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("ProvisioningServives"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/provisioningServices/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Get Provisioning Service resource"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("ProvisioningServices"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/provisioningServices/Write"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Create Provisioning Service resource"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("ProvisioningServices"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/provisioningServices/Delete"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Delete Provisioning Service resource"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("ProvisioningServices"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/provisioningServices/skus/Read"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("Delete Provisioning Service resource"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("ProvisioningServices"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.Devices/provisioningServices/listkeys/Action"),
		// 				Display: &armdeviceprovisioningservices.OperationDisplay{
		// 					Operation: to.Ptr("get security related metadata"),
		// 					Provider: to.Ptr("Microsoft Devices"),
		// 					Resource: to.Ptr("ProvisioningServices"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

type OperationsClientListOptions added in v0.2.0 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse added in v0.2.0 

type OperationsClientListResponse struct {
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// READ-ONLY; The resource identifier.
	ID *string
}

PrivateEndpoint - The private endpoint property of a private endpoint connection

func (PrivateEndpoint) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpoint.

func (*PrivateEndpoint) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpoint.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// REQUIRED; The properties of a private endpoint connection
	Properties *PrivateEndpointConnectionProperties

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

	// READ-ONLY; The name of the resource
	Name *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
}

PrivateEndpointConnection - The private endpoint connection of a provisioning service

func (PrivateEndpointConnection) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnection.

func (*PrivateEndpointConnection) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnection.

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; The current state of a private endpoint connection
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState

	// The private endpoint property of a private endpoint connection
	PrivateEndpoint *PrivateEndpoint
}

PrivateEndpointConnectionProperties - The properties of a private endpoint connection

func (PrivateEndpointConnectionProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionProperties.

func (*PrivateEndpointConnectionProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionProperties.

type PrivateLinkResources 

type PrivateLinkResources struct {
	// The list of available private link resources for a provisioning service
	Value []*GroupIDInformation
}

PrivateLinkResources - The available private link resources for a provisioning service

func (PrivateLinkResources) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResources.

func (*PrivateLinkResources) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResources.

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// REQUIRED; The description for the current state of a private endpoint connection
	Description *string

	// REQUIRED; The status of a private endpoint connection
	Status *PrivateLinkServiceConnectionStatus

	// Actions required for a private endpoint connection
	ActionsRequired *string
}

PrivateLinkServiceConnectionState - The current state of a private endpoint connection

func (PrivateLinkServiceConnectionState) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkServiceConnectionState.

func (*PrivateLinkServiceConnectionState) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkServiceConnectionState.

type PrivateLinkServiceConnectionStatus 

type PrivateLinkServiceConnectionStatus string

PrivateLinkServiceConnectionStatus - The status of a private endpoint connection 

const (
	PrivateLinkServiceConnectionStatusApproved     PrivateLinkServiceConnectionStatus = "Approved"
	PrivateLinkServiceConnectionStatusDisconnected PrivateLinkServiceConnectionStatus = "Disconnected"
	PrivateLinkServiceConnectionStatusPending      PrivateLinkServiceConnectionStatus = "Pending"
	PrivateLinkServiceConnectionStatusRejected     PrivateLinkServiceConnectionStatus = "Rejected"
)

func PossiblePrivateLinkServiceConnectionStatusValues 

func PossiblePrivateLinkServiceConnectionStatusValues() []PrivateLinkServiceConnectionStatus

PossiblePrivateLinkServiceConnectionStatusValues returns the possible values for the PrivateLinkServiceConnectionStatus const type.

type ProvisioningServiceDescription 

type ProvisioningServiceDescription struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Service specific properties for a provisioning service
	Properties *IotDpsPropertiesDescription

	// REQUIRED; Sku info for a provisioning Service.
	SKU *IotDpsSKUInfo

	// The Etag field is *not* required. If it is provided in the response body, it must also be provided as a header per the
	// normal ETag convention.
	Etag *string

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

	// The resource group of the resource.
	Resourcegroup *string

	// The subscription id of the resource.
	Subscriptionid *string

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

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

	// READ-ONLY; The name of the resource
	Name *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
}

ProvisioningServiceDescription - The description of the provisioning service.

func (ProvisioningServiceDescription) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProvisioningServiceDescription.

func (*ProvisioningServiceDescription) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProvisioningServiceDescription.

type ProvisioningServiceDescriptionListResult 

type ProvisioningServiceDescriptionListResult struct {
	// REQUIRED; The ProvisioningServiceDescription items on this page
	Value []*ProvisioningServiceDescription

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

ProvisioningServiceDescriptionListResult - The response of a ProvisioningServiceDescription list operation.

func (ProvisioningServiceDescriptionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProvisioningServiceDescriptionListResult.

func (*ProvisioningServiceDescriptionListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProvisioningServiceDescriptionListResult.

type PublicNetworkAccess 

type PublicNetworkAccess string

PublicNetworkAccess - Whether requests from Public Network are allowed 

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

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

type SharedAccessSignatureAuthorizationRuleAccessRightsDescription 

type SharedAccessSignatureAuthorizationRuleAccessRightsDescription struct {
	// REQUIRED; Name of the key.
	KeyName *string

	// REQUIRED; Rights that this key has.
	Rights *AccessRightsDescription

	// Primary SAS key value.
	PrimaryKey *string

	// Secondary SAS key value.
	SecondaryKey *string
}

SharedAccessSignatureAuthorizationRuleAccessRightsDescription - Description of the shared access key.

func (SharedAccessSignatureAuthorizationRuleAccessRightsDescription) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type SharedAccessSignatureAuthorizationRuleAccessRightsDescription.

func (*SharedAccessSignatureAuthorizationRuleAccessRightsDescription) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SharedAccessSignatureAuthorizationRuleAccessRightsDescription.

type SharedAccessSignatureAuthorizationRuleListResult 

type SharedAccessSignatureAuthorizationRuleListResult struct {
	// REQUIRED; The SharedAccessSignatureAuthorizationRuleAccessRightsDescription items on this page
	Value []*SharedAccessSignatureAuthorizationRuleAccessRightsDescription

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

SharedAccessSignatureAuthorizationRuleListResult - List of shared access keys.

func (SharedAccessSignatureAuthorizationRuleListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SharedAccessSignatureAuthorizationRuleListResult.

func (*SharedAccessSignatureAuthorizationRuleListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SharedAccessSignatureAuthorizationRuleListResult.

type State 

type State string

State - Current state of the provisioning service. 

const (
	StateActivating       State = "Activating"
	StateActivationFailed State = "ActivationFailed"
	StateActive           State = "Active"
	StateDeleted          State = "Deleted"
	StateDeleting         State = "Deleting"
	StateDeletionFailed   State = "DeletionFailed"
	StateFailingOver      State = "FailingOver"
	StateFailoverFailed   State = "FailoverFailed"
	StateResuming         State = "Resuming"
	StateSuspended        State = "Suspended"
	StateSuspending       State = "Suspending"
	StateTransitioning    State = "Transitioning"
)

func PossibleStateValues 

func PossibleStateValues() []State

PossibleStateValues returns the possible values for the State const type.

type SystemData added in v0.3.0 

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 added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON added in v0.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TagsResource 

type TagsResource struct {
	// Resource tags
	Tags map[string]*string
}

TagsResource - A container holding only the Tags for a resource, allowing the user to update the tags on a Provisioning Service instance.

func (TagsResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TagsResource.

func (*TagsResource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TagsResource.

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 VerificationCodeRequest 

type VerificationCodeRequest struct {
	// base-64 representation of X509 certificate .cer file or just .pem file content.
	Certificate *string
}

VerificationCodeRequest - The JSON-serialized leaf certificate

func (VerificationCodeRequest) MarshalJSON added in v1.1.0 

func (v VerificationCodeRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VerificationCodeRequest.

func (*VerificationCodeRequest) UnmarshalJSON added in v1.1.0 

func (v *VerificationCodeRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VerificationCodeRequest.

type VerificationCodeResponse 

type VerificationCodeResponse struct {
	Properties *VerificationCodeResponseProperties

	// READ-ONLY; Request etag.
	Etag *string

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

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

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

VerificationCodeResponse - Description of the response of the verification code.

func (VerificationCodeResponse) MarshalJSON added in v1.1.0 

func (v VerificationCodeResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VerificationCodeResponse.

func (*VerificationCodeResponse) UnmarshalJSON added in v1.1.0 

func (v *VerificationCodeResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VerificationCodeResponse.

type VerificationCodeResponseProperties 

type VerificationCodeResponseProperties struct {
	// base-64 representation of X509 certificate .cer file or just .pem file content.
	Certificate []byte

	// Certificate created time.
	Created *string

	// Code expiry.
	Expiry *string

	// Indicate if the certificate is verified by owner of private key.
	IsVerified *bool

	// Certificate subject.
	Subject *string

	// Certificate thumbprint.
	Thumbprint *string

	// Certificate updated time.
	Updated *string

	// Verification code.
	VerificationCode *string
}

func (VerificationCodeResponseProperties) MarshalJSON 

func (v VerificationCodeResponseProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VerificationCodeResponseProperties.

func (*VerificationCodeResponseProperties) UnmarshalJSON 

func (v *VerificationCodeResponseProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VerificationCodeResponseProperties.

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.