deviceupdates

package
v0.20240521.1091020 Latest Latest
Warning

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

Go to latest
Published: May 21, 2024 License: MPL-2.0 Imports: 15 Imported by: 1

README

github.com/hashicorp/go-azure-sdk/resource-manager/deviceupdate/2022-10-01/deviceupdates Documentation

The deviceupdates SDK allows for interaction with the Azure Resource Manager Service deviceupdate (API Version 2022-10-01).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
import "github.com/hashicorp/go-azure-sdk/resource-manager/deviceupdate/2022-10-01/deviceupdates"

Client Initialization

client := deviceupdates.NewDeviceupdatesClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: DeviceupdatesClient.AccountsCreate

ctx := context.TODO()
id := deviceupdates.NewAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

payload := deviceupdates.Account{
	// ...
}


if err := client.AccountsCreateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: DeviceupdatesClient.AccountsDelete

ctx := context.TODO()
id := deviceupdates.NewAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

if err := client.AccountsDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: DeviceupdatesClient.AccountsGet

ctx := context.TODO()
id := deviceupdates.NewAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

read, err := client.AccountsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.AccountsHead

ctx := context.TODO()
id := deviceupdates.NewAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

read, err := client.AccountsHead(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.AccountsListByResourceGroup

ctx := context.TODO()
id := commonids.NewResourceGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group")

// alternatively `client.AccountsListByResourceGroup(ctx, id)` can be used to do batched pagination
items, err := client.AccountsListByResourceGroupComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DeviceupdatesClient.AccountsListBySubscription

ctx := context.TODO()
id := commonids.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

// alternatively `client.AccountsListBySubscription(ctx, id)` can be used to do batched pagination
items, err := client.AccountsListBySubscriptionComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DeviceupdatesClient.AccountsUpdate

ctx := context.TODO()
id := deviceupdates.NewAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

payload := deviceupdates.AccountUpdate{
	// ...
}


if err := client.AccountsUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: DeviceupdatesClient.CheckNameAvailability

ctx := context.TODO()
id := commonids.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

payload := deviceupdates.CheckNameAvailabilityRequest{
	// ...
}


read, err := client.CheckNameAvailability(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.InstancesCreate

ctx := context.TODO()
id := deviceupdates.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "instanceValue")

payload := deviceupdates.Instance{
	// ...
}


if err := client.InstancesCreateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: DeviceupdatesClient.InstancesDelete

ctx := context.TODO()
id := deviceupdates.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "instanceValue")

if err := client.InstancesDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: DeviceupdatesClient.InstancesGet

ctx := context.TODO()
id := deviceupdates.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "instanceValue")

read, err := client.InstancesGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.InstancesHead

ctx := context.TODO()
id := deviceupdates.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "instanceValue")

read, err := client.InstancesHead(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.InstancesListByAccount

ctx := context.TODO()
id := deviceupdates.NewAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

// alternatively `client.InstancesListByAccount(ctx, id)` can be used to do batched pagination
items, err := client.InstancesListByAccountComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DeviceupdatesClient.InstancesUpdate

ctx := context.TODO()
id := deviceupdates.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "instanceValue")

payload := deviceupdates.TagUpdate{
	// ...
}


read, err := client.InstancesUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties

ctx := context.TODO()
id := deviceupdates.NewPrivateEndpointConnectionProxyID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "privateEndpointConnectionProxyIdValue")

payload := deviceupdates.PrivateEndpointUpdate{
	// ...
}


read, err := client.PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DeviceupdatesClient.PrivateEndpointConnectionProxiesValidate

ctx := context.TODO()
id := deviceupdates.NewPrivateEndpointConnectionProxyID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "privateEndpointConnectionProxyIdValue")

payload := deviceupdates.PrivateEndpointConnectionProxy{
	// ...
}


read, err := client.PrivateEndpointConnectionProxiesValidate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForAuthenticationType

func PossibleValuesForAuthenticationType() []string

func PossibleValuesForCheckNameAvailabilityReason

func PossibleValuesForCheckNameAvailabilityReason() []string

func PossibleValuesForPrivateEndpointConnectionProvisioningState

func PossibleValuesForPrivateEndpointConnectionProvisioningState() []string

func PossibleValuesForPrivateEndpointConnectionProxyProvisioningState

func PossibleValuesForPrivateEndpointConnectionProxyProvisioningState() []string

func PossibleValuesForPrivateEndpointServiceConnectionStatus

func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string

func PossibleValuesForProvisioningState

func PossibleValuesForProvisioningState() []string

func PossibleValuesForPublicNetworkAccess

func PossibleValuesForPublicNetworkAccess() []string

func PossibleValuesForRole

func PossibleValuesForRole() []string

func PossibleValuesForSKU

func PossibleValuesForSKU() []string

func ValidateAccountID

func ValidateAccountID(input interface{}, key string) (warnings []string, errors []error)

ValidateAccountID checks that 'input' can be parsed as a Account ID

func ValidateInstanceID

func ValidateInstanceID(input interface{}, key string) (warnings []string, errors []error)

ValidateInstanceID checks that 'input' can be parsed as a Instance ID

func ValidatePrivateEndpointConnectionProxyID

func ValidatePrivateEndpointConnectionProxyID(input interface{}, key string) (warnings []string, errors []error)

ValidatePrivateEndpointConnectionProxyID checks that 'input' can be parsed as a Private Endpoint Connection Proxy ID

Types

type Account

type Account struct {
	Id         *string                                  `json:"id,omitempty"`
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Location   string                                   `json:"location"`
	Name       *string                                  `json:"name,omitempty"`
	Properties *AccountProperties                       `json:"properties,omitempty"`
	SystemData *systemdata.SystemData                   `json:"systemData,omitempty"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type AccountId

type AccountId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
}

AccountId is a struct representing the Resource ID for a Account

func NewAccountID

func NewAccountID(subscriptionId string, resourceGroupName string, accountName string) AccountId

NewAccountID returns a new AccountId struct

func ParseAccountID

func ParseAccountID(input string) (*AccountId, error)

ParseAccountID parses 'input' into a AccountId

func ParseAccountIDInsensitively

func ParseAccountIDInsensitively(input string) (*AccountId, error)

ParseAccountIDInsensitively parses 'input' case-insensitively into a AccountId note: this method should only be used for API response data and not user input

func (*AccountId) FromParseResult

func (id *AccountId) FromParseResult(input resourceids.ParseResult) error

func (AccountId) ID

func (id AccountId) ID() string

ID returns the formatted Account ID

func (AccountId) Segments

func (id AccountId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Account ID

func (AccountId) String

func (id AccountId) String() string

String returns a human-readable description of this Account ID

type AccountOperationPredicate

type AccountOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (AccountOperationPredicate) Matches

func (p AccountOperationPredicate) Matches(input Account) bool

type AccountProperties

type AccountProperties struct {
	HostName                   *string                      `json:"hostName,omitempty"`
	Locations                  *[]Location                  `json:"locations,omitempty"`
	PrivateEndpointConnections *[]PrivateEndpointConnection `json:"privateEndpointConnections,omitempty"`
	ProvisioningState          *ProvisioningState           `json:"provisioningState,omitempty"`
	PublicNetworkAccess        *PublicNetworkAccess         `json:"publicNetworkAccess,omitempty"`
	Sku                        *SKU                         `json:"sku,omitempty"`
}

type AccountUpdate

type AccountUpdate struct {
	Identity *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Location *string                                  `json:"location,omitempty"`
	Tags     *map[string]string                       `json:"tags,omitempty"`
}

type AccountsCreateOperationResponse

type AccountsCreateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Account
}

type AccountsDeleteOperationResponse

type AccountsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type AccountsGetOperationResponse

type AccountsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Account
}

type AccountsHeadOperationResponse

type AccountsHeadOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type AccountsListByResourceGroupCompleteResult

type AccountsListByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Account
}

type AccountsListByResourceGroupOperationResponse

type AccountsListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Account
}

type AccountsListBySubscriptionCompleteResult

type AccountsListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Account
}

type AccountsListBySubscriptionOperationResponse

type AccountsListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Account
}

type AccountsUpdateOperationResponse

type AccountsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Account
}

type AuthenticationType

type AuthenticationType string
const (
	AuthenticationTypeKeyBased AuthenticationType = "KeyBased"
)

func (*AuthenticationType) UnmarshalJSON

func (s *AuthenticationType) UnmarshalJSON(bytes []byte) error

type CheckNameAvailabilityOperationResponse

type CheckNameAvailabilityOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *CheckNameAvailabilityResponse
}

type CheckNameAvailabilityReason

type CheckNameAvailabilityReason string
const (
	CheckNameAvailabilityReasonAlreadyExists CheckNameAvailabilityReason = "AlreadyExists"
	CheckNameAvailabilityReasonInvalid       CheckNameAvailabilityReason = "Invalid"
)

func (*CheckNameAvailabilityReason) UnmarshalJSON

func (s *CheckNameAvailabilityReason) UnmarshalJSON(bytes []byte) error

type CheckNameAvailabilityRequest

type CheckNameAvailabilityRequest struct {
	Name *string `json:"name,omitempty"`
	Type *string `json:"type,omitempty"`
}

type CheckNameAvailabilityResponse

type CheckNameAvailabilityResponse struct {
	Message       *string                      `json:"message,omitempty"`
	NameAvailable *bool                        `json:"nameAvailable,omitempty"`
	Reason        *CheckNameAvailabilityReason `json:"reason,omitempty"`
}

type ConnectionDetails

type ConnectionDetails struct {
	GroupId          *string `json:"groupId,omitempty"`
	Id               *string `json:"id,omitempty"`
	LinkIdentifier   *string `json:"linkIdentifier,omitempty"`
	MemberName       *string `json:"memberName,omitempty"`
	PrivateIPAddress *string `json:"privateIpAddress,omitempty"`
}

type DeviceupdatesClient

type DeviceupdatesClient struct {
	Client *resourcemanager.Client
}

func NewDeviceupdatesClientWithBaseURI

func NewDeviceupdatesClientWithBaseURI(sdkApi sdkEnv.Api) (*DeviceupdatesClient, error)

func (DeviceupdatesClient) AccountsCreate

func (c DeviceupdatesClient) AccountsCreate(ctx context.Context, id AccountId, input Account) (result AccountsCreateOperationResponse, err error)

AccountsCreate ...

func (DeviceupdatesClient) AccountsCreateThenPoll

func (c DeviceupdatesClient) AccountsCreateThenPoll(ctx context.Context, id AccountId, input Account) error

AccountsCreateThenPoll performs AccountsCreate then polls until it's completed

func (DeviceupdatesClient) AccountsDelete

func (c DeviceupdatesClient) AccountsDelete(ctx context.Context, id AccountId) (result AccountsDeleteOperationResponse, err error)

AccountsDelete ...

func (DeviceupdatesClient) AccountsDeleteThenPoll

func (c DeviceupdatesClient) AccountsDeleteThenPoll(ctx context.Context, id AccountId) error

AccountsDeleteThenPoll performs AccountsDelete then polls until it's completed

func (DeviceupdatesClient) AccountsGet

func (c DeviceupdatesClient) AccountsGet(ctx context.Context, id AccountId) (result AccountsGetOperationResponse, err error)

AccountsGet ...

func (DeviceupdatesClient) AccountsHead

func (c DeviceupdatesClient) AccountsHead(ctx context.Context, id AccountId) (result AccountsHeadOperationResponse, err error)

AccountsHead ...

func (DeviceupdatesClient) AccountsListByResourceGroup

AccountsListByResourceGroup ...

func (DeviceupdatesClient) AccountsListByResourceGroupComplete

AccountsListByResourceGroupComplete retrieves all the results into a single object

func (DeviceupdatesClient) AccountsListByResourceGroupCompleteMatchingPredicate

func (c DeviceupdatesClient) AccountsListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate AccountOperationPredicate) (result AccountsListByResourceGroupCompleteResult, err error)

AccountsListByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (DeviceupdatesClient) AccountsListBySubscription

AccountsListBySubscription ...

func (DeviceupdatesClient) AccountsListBySubscriptionComplete

AccountsListBySubscriptionComplete retrieves all the results into a single object

func (DeviceupdatesClient) AccountsListBySubscriptionCompleteMatchingPredicate

func (c DeviceupdatesClient) AccountsListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate AccountOperationPredicate) (result AccountsListBySubscriptionCompleteResult, err error)

AccountsListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (DeviceupdatesClient) AccountsUpdate

func (c DeviceupdatesClient) AccountsUpdate(ctx context.Context, id AccountId, input AccountUpdate) (result AccountsUpdateOperationResponse, err error)

AccountsUpdate ...

func (DeviceupdatesClient) AccountsUpdateThenPoll

func (c DeviceupdatesClient) AccountsUpdateThenPoll(ctx context.Context, id AccountId, input AccountUpdate) error

AccountsUpdateThenPoll performs AccountsUpdate then polls until it's completed

func (DeviceupdatesClient) CheckNameAvailability

CheckNameAvailability ...

func (DeviceupdatesClient) InstancesCreate

func (c DeviceupdatesClient) InstancesCreate(ctx context.Context, id InstanceId, input Instance) (result InstancesCreateOperationResponse, err error)

InstancesCreate ...

func (DeviceupdatesClient) InstancesCreateThenPoll

func (c DeviceupdatesClient) InstancesCreateThenPoll(ctx context.Context, id InstanceId, input Instance) error

InstancesCreateThenPoll performs InstancesCreate then polls until it's completed

func (DeviceupdatesClient) InstancesDelete

func (c DeviceupdatesClient) InstancesDelete(ctx context.Context, id InstanceId) (result InstancesDeleteOperationResponse, err error)

InstancesDelete ...

func (DeviceupdatesClient) InstancesDeleteThenPoll

func (c DeviceupdatesClient) InstancesDeleteThenPoll(ctx context.Context, id InstanceId) error

InstancesDeleteThenPoll performs InstancesDelete then polls until it's completed

func (DeviceupdatesClient) InstancesGet

func (c DeviceupdatesClient) InstancesGet(ctx context.Context, id InstanceId) (result InstancesGetOperationResponse, err error)

InstancesGet ...

func (DeviceupdatesClient) InstancesHead

func (c DeviceupdatesClient) InstancesHead(ctx context.Context, id InstanceId) (result InstancesHeadOperationResponse, err error)

InstancesHead ...

func (DeviceupdatesClient) InstancesListByAccount

func (c DeviceupdatesClient) InstancesListByAccount(ctx context.Context, id AccountId) (result InstancesListByAccountOperationResponse, err error)

InstancesListByAccount ...

func (DeviceupdatesClient) InstancesListByAccountComplete

func (c DeviceupdatesClient) InstancesListByAccountComplete(ctx context.Context, id AccountId) (InstancesListByAccountCompleteResult, error)

InstancesListByAccountComplete retrieves all the results into a single object

func (DeviceupdatesClient) InstancesListByAccountCompleteMatchingPredicate

func (c DeviceupdatesClient) InstancesListByAccountCompleteMatchingPredicate(ctx context.Context, id AccountId, predicate InstanceOperationPredicate) (result InstancesListByAccountCompleteResult, err error)

InstancesListByAccountCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (DeviceupdatesClient) InstancesUpdate

func (c DeviceupdatesClient) InstancesUpdate(ctx context.Context, id InstanceId, input TagUpdate) (result InstancesUpdateOperationResponse, err error)

InstancesUpdate ...

func (DeviceupdatesClient) PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties

PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties ...

func (DeviceupdatesClient) PrivateEndpointConnectionProxiesValidate

PrivateEndpointConnectionProxiesValidate ...

type DiagnosticStorageProperties

type DiagnosticStorageProperties struct {
	AuthenticationType AuthenticationType `json:"authenticationType"`
	ConnectionString   *string            `json:"connectionString,omitempty"`
	ResourceId         string             `json:"resourceId"`
}

type GroupConnectivityInformation

type GroupConnectivityInformation struct {
	CustomerVisibleFqdns        *[]string `json:"customerVisibleFqdns,omitempty"`
	GroupId                     *string   `json:"groupId,omitempty"`
	InternalFqdn                *string   `json:"internalFqdn,omitempty"`
	MemberName                  *string   `json:"memberName,omitempty"`
	PrivateLinkServiceArmRegion *string   `json:"privateLinkServiceArmRegion,omitempty"`
	RedirectMapId               *string   `json:"redirectMapId,omitempty"`
}

type Instance

type Instance struct {
	Id         *string                `json:"id,omitempty"`
	Location   string                 `json:"location"`
	Name       *string                `json:"name,omitempty"`
	Properties InstanceProperties     `json:"properties"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Tags       *map[string]string     `json:"tags,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type InstanceId

type InstanceId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	InstanceName      string
}

InstanceId is a struct representing the Resource ID for a Instance

func NewInstanceID

func NewInstanceID(subscriptionId string, resourceGroupName string, accountName string, instanceName string) InstanceId

NewInstanceID returns a new InstanceId struct

func ParseInstanceID

func ParseInstanceID(input string) (*InstanceId, error)

ParseInstanceID parses 'input' into a InstanceId

func ParseInstanceIDInsensitively

func ParseInstanceIDInsensitively(input string) (*InstanceId, error)

ParseInstanceIDInsensitively parses 'input' case-insensitively into a InstanceId note: this method should only be used for API response data and not user input

func (*InstanceId) FromParseResult

func (id *InstanceId) FromParseResult(input resourceids.ParseResult) error

func (InstanceId) ID

func (id InstanceId) ID() string

ID returns the formatted Instance ID

func (InstanceId) Segments

func (id InstanceId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Instance ID

func (InstanceId) String

func (id InstanceId) String() string

String returns a human-readable description of this Instance ID

type InstanceOperationPredicate

type InstanceOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (InstanceOperationPredicate) Matches

func (p InstanceOperationPredicate) Matches(input Instance) bool

type InstanceProperties

type InstanceProperties struct {
	AccountName                 *string                      `json:"accountName,omitempty"`
	DiagnosticStorageProperties *DiagnosticStorageProperties `json:"diagnosticStorageProperties,omitempty"`
	EnableDiagnostics           *bool                        `json:"enableDiagnostics,omitempty"`
	IotHubs                     *[]IotHubSettings            `json:"iotHubs,omitempty"`
	ProvisioningState           *ProvisioningState           `json:"provisioningState,omitempty"`
}

type InstancesCreateOperationResponse

type InstancesCreateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Instance
}

type InstancesDeleteOperationResponse

type InstancesDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type InstancesGetOperationResponse

type InstancesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Instance
}

type InstancesHeadOperationResponse

type InstancesHeadOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type InstancesListByAccountCompleteResult

type InstancesListByAccountCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Instance
}

type InstancesListByAccountOperationResponse

type InstancesListByAccountOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Instance
}

type InstancesUpdateOperationResponse

type InstancesUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Instance
}

type IotHubSettings

type IotHubSettings struct {
	ResourceId string `json:"resourceId"`
}

type Location

type Location struct {
	Name *string `json:"name,omitempty"`
	Role *Role   `json:"role,omitempty"`
}

type PrivateEndpoint

type PrivateEndpoint struct {
	Id *string `json:"id,omitempty"`
}

type PrivateEndpointConnection

type PrivateEndpointConnection struct {
	Id         *string                             `json:"id,omitempty"`
	Name       *string                             `json:"name,omitempty"`
	Properties PrivateEndpointConnectionProperties `json:"properties"`
	SystemData *systemdata.SystemData              `json:"systemData,omitempty"`
	Type       *string                             `json:"type,omitempty"`
}

type PrivateEndpointConnectionProperties

type PrivateEndpointConnectionProperties struct {
	GroupIds                          *[]string                                   `json:"groupIds,omitempty"`
	PrivateEndpoint                   *PrivateEndpoint                            `json:"privateEndpoint,omitempty"`
	PrivateLinkServiceConnectionState PrivateLinkServiceConnectionState           `json:"privateLinkServiceConnectionState"`
	ProvisioningState                 *PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty"`
}

type PrivateEndpointConnectionProvisioningState

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

func (*PrivateEndpointConnectionProvisioningState) UnmarshalJSON

func (s *PrivateEndpointConnectionProvisioningState) UnmarshalJSON(bytes []byte) error

type PrivateEndpointConnectionProxiesUpdatePrivateEndpointPropertiesOperationResponse

type PrivateEndpointConnectionProxiesUpdatePrivateEndpointPropertiesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type PrivateEndpointConnectionProxiesValidateOperationResponse

type PrivateEndpointConnectionProxiesValidateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
}

type PrivateEndpointConnectionProxy

type PrivateEndpointConnectionProxy struct {
	ETag                  *string                                   `json:"eTag,omitempty"`
	Id                    *string                                   `json:"id,omitempty"`
	Name                  *string                                   `json:"name,omitempty"`
	Properties            *PrivateEndpointConnectionProxyProperties `json:"properties,omitempty"`
	RemotePrivateEndpoint *RemotePrivateEndpoint                    `json:"remotePrivateEndpoint,omitempty"`
	Status                *string                                   `json:"status,omitempty"`
	SystemData            *systemdata.SystemData                    `json:"systemData,omitempty"`
	Type                  *string                                   `json:"type,omitempty"`
}

type PrivateEndpointConnectionProxyId

type PrivateEndpointConnectionProxyId struct {
	SubscriptionId                   string
	ResourceGroupName                string
	AccountName                      string
	PrivateEndpointConnectionProxyId string
}

PrivateEndpointConnectionProxyId is a struct representing the Resource ID for a Private Endpoint Connection Proxy

func NewPrivateEndpointConnectionProxyID

func NewPrivateEndpointConnectionProxyID(subscriptionId string, resourceGroupName string, accountName string, privateEndpointConnectionProxyId string) PrivateEndpointConnectionProxyId

NewPrivateEndpointConnectionProxyID returns a new PrivateEndpointConnectionProxyId struct

func ParsePrivateEndpointConnectionProxyID

func ParsePrivateEndpointConnectionProxyID(input string) (*PrivateEndpointConnectionProxyId, error)

ParsePrivateEndpointConnectionProxyID parses 'input' into a PrivateEndpointConnectionProxyId

func ParsePrivateEndpointConnectionProxyIDInsensitively

func ParsePrivateEndpointConnectionProxyIDInsensitively(input string) (*PrivateEndpointConnectionProxyId, error)

ParsePrivateEndpointConnectionProxyIDInsensitively parses 'input' case-insensitively into a PrivateEndpointConnectionProxyId note: this method should only be used for API response data and not user input

func (*PrivateEndpointConnectionProxyId) FromParseResult

func (PrivateEndpointConnectionProxyId) ID

ID returns the formatted Private Endpoint Connection Proxy ID

func (PrivateEndpointConnectionProxyId) Segments

Segments returns a slice of Resource ID Segments which comprise this Private Endpoint Connection Proxy ID

func (PrivateEndpointConnectionProxyId) String

String returns a human-readable description of this Private Endpoint Connection Proxy ID

type PrivateEndpointConnectionProxyProperties

type PrivateEndpointConnectionProxyProperties struct {
	ProvisioningState *PrivateEndpointConnectionProxyProvisioningState `json:"provisioningState,omitempty"`
}

type PrivateEndpointConnectionProxyProvisioningState

type PrivateEndpointConnectionProxyProvisioningState string
const (
	PrivateEndpointConnectionProxyProvisioningStateCreating  PrivateEndpointConnectionProxyProvisioningState = "Creating"
	PrivateEndpointConnectionProxyProvisioningStateDeleting  PrivateEndpointConnectionProxyProvisioningState = "Deleting"
	PrivateEndpointConnectionProxyProvisioningStateFailed    PrivateEndpointConnectionProxyProvisioningState = "Failed"
	PrivateEndpointConnectionProxyProvisioningStateSucceeded PrivateEndpointConnectionProxyProvisioningState = "Succeeded"
)

func (*PrivateEndpointConnectionProxyProvisioningState) UnmarshalJSON

type PrivateEndpointServiceConnectionStatus

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

func (*PrivateEndpointServiceConnectionStatus) UnmarshalJSON

func (s *PrivateEndpointServiceConnectionStatus) UnmarshalJSON(bytes []byte) error

type PrivateEndpointUpdate

type PrivateEndpointUpdate struct {
	Id                      *string `json:"id,omitempty"`
	ImmutableResourceId     *string `json:"immutableResourceId,omitempty"`
	ImmutableSubscriptionId *string `json:"immutableSubscriptionId,omitempty"`
	Location                *string `json:"location,omitempty"`
	VnetTrafficTag          *string `json:"vnetTrafficTag,omitempty"`
}

type PrivateLinkServiceConnection

type PrivateLinkServiceConnection struct {
	GroupIds       *[]string `json:"groupIds,omitempty"`
	Name           *string   `json:"name,omitempty"`
	RequestMessage *string   `json:"requestMessage,omitempty"`
}

type PrivateLinkServiceConnectionState

type PrivateLinkServiceConnectionState struct {
	ActionsRequired *string                                 `json:"actionsRequired,omitempty"`
	Description     *string                                 `json:"description,omitempty"`
	Status          *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"`
}

type PrivateLinkServiceProxy

type PrivateLinkServiceProxy struct {
	GroupConnectivityInformation            *[]GroupConnectivityInformation    `json:"groupConnectivityInformation,omitempty"`
	Id                                      *string                            `json:"id,omitempty"`
	RemotePrivateEndpointConnection         *RemotePrivateEndpointConnection   `json:"remotePrivateEndpointConnection,omitempty"`
	RemotePrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"remotePrivateLinkServiceConnectionState,omitempty"`
}

type ProvisioningState

type ProvisioningState string
const (
	ProvisioningStateAccepted  ProvisioningState = "Accepted"
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateCreating  ProvisioningState = "Creating"
	ProvisioningStateDeleted   ProvisioningState = "Deleted"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
)

func (*ProvisioningState) UnmarshalJSON

func (s *ProvisioningState) UnmarshalJSON(bytes []byte) error

type PublicNetworkAccess

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

func (*PublicNetworkAccess) UnmarshalJSON

func (s *PublicNetworkAccess) UnmarshalJSON(bytes []byte) error

type RemotePrivateEndpoint

type RemotePrivateEndpoint struct {
	ConnectionDetails                   *[]ConnectionDetails            `json:"connectionDetails,omitempty"`
	Id                                  *string                         `json:"id,omitempty"`
	ImmutableResourceId                 *string                         `json:"immutableResourceId,omitempty"`
	ImmutableSubscriptionId             *string                         `json:"immutableSubscriptionId,omitempty"`
	Location                            *string                         `json:"location,omitempty"`
	ManualPrivateLinkServiceConnections *[]PrivateLinkServiceConnection `json:"manualPrivateLinkServiceConnections,omitempty"`
	PrivateLinkServiceConnections       *[]PrivateLinkServiceConnection `json:"privateLinkServiceConnections,omitempty"`
	PrivateLinkServiceProxies           *[]PrivateLinkServiceProxy      `json:"privateLinkServiceProxies,omitempty"`
	VnetTrafficTag                      *string                         `json:"vnetTrafficTag,omitempty"`
}

type RemotePrivateEndpointConnection

type RemotePrivateEndpointConnection struct {
	Id *string `json:"id,omitempty"`
}

type Role

type Role string
const (
	RoleFailover Role = "Failover"
	RolePrimary  Role = "Primary"
)

func (*Role) UnmarshalJSON

func (s *Role) UnmarshalJSON(bytes []byte) error

type SKU

type SKU string
const (
	SKUFree     SKU = "Free"
	SKUStandard SKU = "Standard"
)

func (*SKU) UnmarshalJSON

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

type TagUpdate

type TagUpdate struct {
	Tags *map[string]string `json:"tags,omitempty"`
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL