deviceupdates

package
v0.20230505.1120847 Latest Latest
Warning

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

 Go to latest Published: May 5, 2023 License: MPL-2.0 Imports: 12 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-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 := deviceupdates.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 := deviceupdates.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 := deviceupdates.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) 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       polling.LongRunningPoller
	HttpResponse *http.Response
}

type AccountsDeleteOperationResponse 

type AccountsDeleteOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type AccountsGetOperationResponse 

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

type AccountsHeadOperationResponse 

type AccountsHeadOperationResponse struct {
	HttpResponse *http.Response
}

type AccountsListByResourceGroupCompleteResult 

type AccountsListByResourceGroupCompleteResult struct {
	Items []Account
}

type AccountsListByResourceGroupOperationResponse 

type AccountsListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]Account
	// contains filtered or unexported fields
}

func (AccountsListByResourceGroupOperationResponse) HasMore 

func (r AccountsListByResourceGroupOperationResponse) HasMore() bool

func (AccountsListByResourceGroupOperationResponse) LoadMore 

func (r AccountsListByResourceGroupOperationResponse) LoadMore(ctx context.Context) (resp AccountsListByResourceGroupOperationResponse, err error)

type AccountsListBySubscriptionCompleteResult 

type AccountsListBySubscriptionCompleteResult struct {
	Items []Account
}

type AccountsListBySubscriptionOperationResponse 

type AccountsListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]Account
	// contains filtered or unexported fields
}

func (AccountsListBySubscriptionOperationResponse) HasMore 

func (r AccountsListBySubscriptionOperationResponse) HasMore() bool

func (AccountsListBySubscriptionOperationResponse) LoadMore 

func (r AccountsListBySubscriptionOperationResponse) LoadMore(ctx context.Context) (resp AccountsListBySubscriptionOperationResponse, err error)

type AccountsUpdateOperationResponse 

type AccountsUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type AuthenticationType 

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

type CheckNameAvailabilityOperationResponse 

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

type CheckNameAvailabilityReason 

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

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 autorest.Client
	// contains filtered or unexported fields
}

func NewDeviceupdatesClientWithBaseURI 

func NewDeviceupdatesClientWithBaseURI(endpoint string) DeviceupdatesClient

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 

func (c DeviceupdatesClient) AccountsListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (resp AccountsListByResourceGroupOperationResponse, err error)

AccountsListByResourceGroup ...

func (DeviceupdatesClient) AccountsListByResourceGroupComplete 

func (c DeviceupdatesClient) AccountsListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (AccountsListByResourceGroupCompleteResult, error)

AccountsListByResourceGroupComplete retrieves all of the results into a single object

func (DeviceupdatesClient) AccountsListByResourceGroupCompleteMatchingPredicate 

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

AccountsListByResourceGroupCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DeviceupdatesClient) AccountsListBySubscription 

func (c DeviceupdatesClient) AccountsListBySubscription(ctx context.Context, id commonids.SubscriptionId) (resp AccountsListBySubscriptionOperationResponse, err error)

AccountsListBySubscription ...

func (DeviceupdatesClient) AccountsListBySubscriptionComplete 

func (c DeviceupdatesClient) AccountsListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (AccountsListBySubscriptionCompleteResult, error)

AccountsListBySubscriptionComplete retrieves all of the results into a single object

func (DeviceupdatesClient) AccountsListBySubscriptionCompleteMatchingPredicate 

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

AccountsListBySubscriptionCompleteMatchingPredicate retrieves all of the results and then applied 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 

func (c DeviceupdatesClient) CheckNameAvailability(ctx context.Context, id commonids.SubscriptionId, input CheckNameAvailabilityRequest) (result CheckNameAvailabilityOperationResponse, err error)

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) (resp InstancesListByAccountOperationResponse, err error)

InstancesListByAccount ...

func (DeviceupdatesClient) InstancesListByAccountComplete 

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

InstancesListByAccountComplete retrieves all of the results into a single object

func (DeviceupdatesClient) InstancesListByAccountCompleteMatchingPredicate 

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

InstancesListByAccountCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DeviceupdatesClient) InstancesUpdate 

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

InstancesUpdate ...

func (DeviceupdatesClient) PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties 

func (c DeviceupdatesClient) PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties(ctx context.Context, id PrivateEndpointConnectionProxyId, input PrivateEndpointUpdate) (result PrivateEndpointConnectionProxiesUpdatePrivateEndpointPropertiesOperationResponse, err error)

PrivateEndpointConnectionProxiesUpdatePrivateEndpointProperties ...

func (DeviceupdatesClient) PrivateEndpointConnectionProxiesValidate 

func (c DeviceupdatesClient) PrivateEndpointConnectionProxiesValidate(ctx context.Context, id PrivateEndpointConnectionProxyId, input PrivateEndpointConnectionProxy) (result PrivateEndpointConnectionProxiesValidateOperationResponse, err error)

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) 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       polling.LongRunningPoller
	HttpResponse *http.Response
}

type InstancesDeleteOperationResponse 

type InstancesDeleteOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type InstancesGetOperationResponse 

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

type InstancesHeadOperationResponse 

type InstancesHeadOperationResponse struct {
	HttpResponse *http.Response
}

type InstancesListByAccountCompleteResult 

type InstancesListByAccountCompleteResult struct {
	Items []Instance
}

type InstancesListByAccountOperationResponse 

type InstancesListByAccountOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]Instance
	// contains filtered or unexported fields
}

func (InstancesListByAccountOperationResponse) HasMore 

func (r InstancesListByAccountOperationResponse) HasMore() bool

func (InstancesListByAccountOperationResponse) LoadMore 

func (r InstancesListByAccountOperationResponse) LoadMore(ctx context.Context) (resp InstancesListByAccountOperationResponse, err error)

type InstancesUpdateOperationResponse 

type InstancesUpdateOperationResponse struct {
	HttpResponse *http.Response
	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"
)

type PrivateEndpointConnectionProxiesUpdatePrivateEndpointPropertiesOperationResponse 

type PrivateEndpointConnectionProxiesUpdatePrivateEndpointPropertiesOperationResponse struct {
	HttpResponse *http.Response
}

type PrivateEndpointConnectionProxiesValidateOperationResponse 

type PrivateEndpointConnectionProxiesValidateOperationResponse struct {
	HttpResponse *http.Response
}

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) ID 

func (id PrivateEndpointConnectionProxyId) ID() string

ID returns the formatted Private Endpoint Connection Proxy ID

func (PrivateEndpointConnectionProxyId) Segments 

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

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

func (PrivateEndpointConnectionProxyId) String 

func (id PrivateEndpointConnectionProxyId) String() 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"
)

type PrivateEndpointServiceConnectionStatus 

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

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"
)

type PublicNetworkAccess 

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

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"
)

type SKU 

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

type TagUpdate 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.