privatelink

package
v0.20240320.1144505 Latest Latest
Warning

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

 Go to latest Published: Mar 20, 2024 License: MPL-2.0 Imports: 11 Imported by: 1

README

The privatelink SDK allows for interaction with the Azure Resource Manager Service desktopvirtualization (API Version 2021-09-03-preview).

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/desktopvirtualization/2021-09-03-preview/privatelink"

Client Initialization

client := privatelink.NewPrivateLinkClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsDeleteByHostPool

ctx := context.TODO()
id := privatelink.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "hostPoolValue", "privateEndpointConnectionValue")

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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsDeleteByWorkspace

ctx := context.TODO()
id := privatelink.NewWorkspacePrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "workspaceValue", "privateEndpointConnectionValue")

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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsGetByHostPool

ctx := context.TODO()
id := privatelink.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "hostPoolValue", "privateEndpointConnectionValue")

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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsGetByWorkspace

ctx := context.TODO()
id := privatelink.NewWorkspacePrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "workspaceValue", "privateEndpointConnectionValue")

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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsListByHostPool

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

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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsListByWorkspace

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

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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsUpdateByHostPool

ctx := context.TODO()
id := privatelink.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "hostPoolValue", "privateEndpointConnectionValue")

payload := privatelink.PrivateEndpointConnection{
	// ...
}


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

Example Usage: PrivateLinkClient.PrivateEndpointConnectionsUpdateByWorkspace

ctx := context.TODO()
id := privatelink.NewWorkspacePrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "workspaceValue", "privateEndpointConnectionValue")

payload := privatelink.PrivateEndpointConnection{
	// ...
}


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

Example Usage: PrivateLinkClient.ResourcesListByHostPool

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

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

Example Usage: PrivateLinkClient.ResourcesListByWorkspace

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForPrivateEndpointConnectionProvisioningState 

func PossibleValuesForPrivateEndpointConnectionProvisioningState() []string

func PossibleValuesForPrivateEndpointServiceConnectionStatus 

func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string

func ValidateHostPoolID 

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

ValidateHostPoolID checks that 'input' can be parsed as a Host Pool ID

func ValidatePrivateEndpointConnectionID 

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

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

func ValidateWorkspaceID 

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

ValidateWorkspaceID checks that 'input' can be parsed as a Workspace ID

func ValidateWorkspacePrivateEndpointConnectionID 

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

ValidateWorkspacePrivateEndpointConnectionID checks that 'input' can be parsed as a Workspace Private Endpoint Connection ID

Types

type HostPoolId 

type HostPoolId struct {
	SubscriptionId    string
	ResourceGroupName string
	HostPoolName      string
}

HostPoolId is a struct representing the Resource ID for a Host Pool

func NewHostPoolID 

func NewHostPoolID(subscriptionId string, resourceGroupName string, hostPoolName string) HostPoolId

NewHostPoolID returns a new HostPoolId struct

func ParseHostPoolID 

func ParseHostPoolID(input string) (*HostPoolId, error)

ParseHostPoolID parses 'input' into a HostPoolId

func ParseHostPoolIDInsensitively 

func ParseHostPoolIDInsensitively(input string) (*HostPoolId, error)

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

func (*HostPoolId) FromParseResult 

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

func (HostPoolId) ID 

func (id HostPoolId) ID() string

ID returns the formatted Host Pool ID

func (HostPoolId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Host Pool ID

func (HostPoolId) String 

func (id HostPoolId) String() string

String returns a human-readable description of this Host Pool ID

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,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type PrivateEndpointConnectionId 

type PrivateEndpointConnectionId struct {
	SubscriptionId                string
	ResourceGroupName             string
	HostPoolName                  string
	PrivateEndpointConnectionName string
}

PrivateEndpointConnectionId is a struct representing the Resource ID for a Private Endpoint Connection

func NewPrivateEndpointConnectionID 

func NewPrivateEndpointConnectionID(subscriptionId string, resourceGroupName string, hostPoolName string, privateEndpointConnectionName string) PrivateEndpointConnectionId

NewPrivateEndpointConnectionID returns a new PrivateEndpointConnectionId struct

func ParsePrivateEndpointConnectionID 

func ParsePrivateEndpointConnectionID(input string) (*PrivateEndpointConnectionId, error)

ParsePrivateEndpointConnectionID parses 'input' into a PrivateEndpointConnectionId

func ParsePrivateEndpointConnectionIDInsensitively 

func ParsePrivateEndpointConnectionIDInsensitively(input string) (*PrivateEndpointConnectionId, error)

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

func (*PrivateEndpointConnectionId) FromParseResult 

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

func (PrivateEndpointConnectionId) ID 

func (id PrivateEndpointConnectionId) ID() string

ID returns the formatted Private Endpoint Connection ID

func (PrivateEndpointConnectionId) Segments 

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

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

func (PrivateEndpointConnectionId) String 

func (id PrivateEndpointConnectionId) String() string

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

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	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 PrivateEndpointConnectionWithSystemData 

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

type PrivateEndpointConnectionWithSystemDataOperationPredicate 

type PrivateEndpointConnectionWithSystemDataOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (PrivateEndpointConnectionWithSystemDataOperationPredicate) Matches 

func (p PrivateEndpointConnectionWithSystemDataOperationPredicate) Matches(input PrivateEndpointConnectionWithSystemData) bool

type PrivateEndpointConnectionsDeleteByHostPoolOperationResponse 

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

type PrivateEndpointConnectionsDeleteByWorkspaceOperationResponse 

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

type PrivateEndpointConnectionsGetByHostPoolOperationResponse 

type PrivateEndpointConnectionsGetByHostPoolOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsGetByWorkspaceOperationResponse 

type PrivateEndpointConnectionsGetByWorkspaceOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsListByHostPoolCompleteResult 

type PrivateEndpointConnectionsListByHostPoolCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsListByHostPoolOperationResponse 

type PrivateEndpointConnectionsListByHostPoolOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsListByWorkspaceCompleteResult 

type PrivateEndpointConnectionsListByWorkspaceCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsListByWorkspaceOperationResponse 

type PrivateEndpointConnectionsListByWorkspaceOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsUpdateByHostPoolOperationResponse 

type PrivateEndpointConnectionsUpdateByHostPoolOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnectionWithSystemData
}

type PrivateEndpointConnectionsUpdateByWorkspaceOperationResponse 

type PrivateEndpointConnectionsUpdateByWorkspaceOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnectionWithSystemData
}

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 PrivateLinkClient 

type PrivateLinkClient struct {
	Client *resourcemanager.Client
}

func NewPrivateLinkClientWithBaseURI 

func NewPrivateLinkClientWithBaseURI(sdkApi sdkEnv.Api) (*PrivateLinkClient, error)

func (PrivateLinkClient) PrivateEndpointConnectionsDeleteByHostPool 

func (c PrivateLinkClient) PrivateEndpointConnectionsDeleteByHostPool(ctx context.Context, id PrivateEndpointConnectionId) (result PrivateEndpointConnectionsDeleteByHostPoolOperationResponse, err error)

PrivateEndpointConnectionsDeleteByHostPool ...

func (PrivateLinkClient) PrivateEndpointConnectionsDeleteByWorkspace 

func (c PrivateLinkClient) PrivateEndpointConnectionsDeleteByWorkspace(ctx context.Context, id WorkspacePrivateEndpointConnectionId) (result PrivateEndpointConnectionsDeleteByWorkspaceOperationResponse, err error)

PrivateEndpointConnectionsDeleteByWorkspace ...

func (PrivateLinkClient) PrivateEndpointConnectionsGetByHostPool 

func (c PrivateLinkClient) PrivateEndpointConnectionsGetByHostPool(ctx context.Context, id PrivateEndpointConnectionId) (result PrivateEndpointConnectionsGetByHostPoolOperationResponse, err error)

PrivateEndpointConnectionsGetByHostPool ...

func (PrivateLinkClient) PrivateEndpointConnectionsGetByWorkspace 

func (c PrivateLinkClient) PrivateEndpointConnectionsGetByWorkspace(ctx context.Context, id WorkspacePrivateEndpointConnectionId) (result PrivateEndpointConnectionsGetByWorkspaceOperationResponse, err error)

PrivateEndpointConnectionsGetByWorkspace ...

func (PrivateLinkClient) PrivateEndpointConnectionsListByHostPool 

func (c PrivateLinkClient) PrivateEndpointConnectionsListByHostPool(ctx context.Context, id HostPoolId) (result PrivateEndpointConnectionsListByHostPoolOperationResponse, err error)

PrivateEndpointConnectionsListByHostPool ...

func (PrivateLinkClient) PrivateEndpointConnectionsListByHostPoolComplete 

func (c PrivateLinkClient) PrivateEndpointConnectionsListByHostPoolComplete(ctx context.Context, id HostPoolId) (PrivateEndpointConnectionsListByHostPoolCompleteResult, error)

PrivateEndpointConnectionsListByHostPoolComplete retrieves all the results into a single object

func (PrivateLinkClient) PrivateEndpointConnectionsListByHostPoolCompleteMatchingPredicate 

func (c PrivateLinkClient) PrivateEndpointConnectionsListByHostPoolCompleteMatchingPredicate(ctx context.Context, id HostPoolId, predicate PrivateEndpointConnectionWithSystemDataOperationPredicate) (result PrivateEndpointConnectionsListByHostPoolCompleteResult, err error)

PrivateEndpointConnectionsListByHostPoolCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (PrivateLinkClient) PrivateEndpointConnectionsListByWorkspace 

func (c PrivateLinkClient) PrivateEndpointConnectionsListByWorkspace(ctx context.Context, id WorkspaceId) (result PrivateEndpointConnectionsListByWorkspaceOperationResponse, err error)

PrivateEndpointConnectionsListByWorkspace ...

func (PrivateLinkClient) PrivateEndpointConnectionsListByWorkspaceComplete 

func (c PrivateLinkClient) PrivateEndpointConnectionsListByWorkspaceComplete(ctx context.Context, id WorkspaceId) (PrivateEndpointConnectionsListByWorkspaceCompleteResult, error)

PrivateEndpointConnectionsListByWorkspaceComplete retrieves all the results into a single object

func (PrivateLinkClient) PrivateEndpointConnectionsListByWorkspaceCompleteMatchingPredicate 

func (c PrivateLinkClient) PrivateEndpointConnectionsListByWorkspaceCompleteMatchingPredicate(ctx context.Context, id WorkspaceId, predicate PrivateEndpointConnectionWithSystemDataOperationPredicate) (result PrivateEndpointConnectionsListByWorkspaceCompleteResult, err error)

PrivateEndpointConnectionsListByWorkspaceCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (PrivateLinkClient) PrivateEndpointConnectionsUpdateByHostPool 

func (c PrivateLinkClient) PrivateEndpointConnectionsUpdateByHostPool(ctx context.Context, id PrivateEndpointConnectionId, input PrivateEndpointConnection) (result PrivateEndpointConnectionsUpdateByHostPoolOperationResponse, err error)

PrivateEndpointConnectionsUpdateByHostPool ...

func (PrivateLinkClient) PrivateEndpointConnectionsUpdateByWorkspace 

func (c PrivateLinkClient) PrivateEndpointConnectionsUpdateByWorkspace(ctx context.Context, id WorkspacePrivateEndpointConnectionId, input PrivateEndpointConnection) (result PrivateEndpointConnectionsUpdateByWorkspaceOperationResponse, err error)

PrivateEndpointConnectionsUpdateByWorkspace ...

func (PrivateLinkClient) ResourcesListByHostPool 

func (c PrivateLinkClient) ResourcesListByHostPool(ctx context.Context, id HostPoolId) (result ResourcesListByHostPoolOperationResponse, err error)

ResourcesListByHostPool ...

func (PrivateLinkClient) ResourcesListByHostPoolComplete 

func (c PrivateLinkClient) ResourcesListByHostPoolComplete(ctx context.Context, id HostPoolId) (ResourcesListByHostPoolCompleteResult, error)

ResourcesListByHostPoolComplete retrieves all the results into a single object

func (PrivateLinkClient) ResourcesListByHostPoolCompleteMatchingPredicate 

func (c PrivateLinkClient) ResourcesListByHostPoolCompleteMatchingPredicate(ctx context.Context, id HostPoolId, predicate PrivateLinkResourceOperationPredicate) (result ResourcesListByHostPoolCompleteResult, err error)

ResourcesListByHostPoolCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (PrivateLinkClient) ResourcesListByWorkspace 

func (c PrivateLinkClient) ResourcesListByWorkspace(ctx context.Context, id WorkspaceId) (result ResourcesListByWorkspaceOperationResponse, err error)

ResourcesListByWorkspace ...

func (PrivateLinkClient) ResourcesListByWorkspaceComplete 

func (c PrivateLinkClient) ResourcesListByWorkspaceComplete(ctx context.Context, id WorkspaceId) (ResourcesListByWorkspaceCompleteResult, error)

ResourcesListByWorkspaceComplete retrieves all the results into a single object

func (PrivateLinkClient) ResourcesListByWorkspaceCompleteMatchingPredicate 

func (c PrivateLinkClient) ResourcesListByWorkspaceCompleteMatchingPredicate(ctx context.Context, id WorkspaceId, predicate PrivateLinkResourceOperationPredicate) (result ResourcesListByWorkspaceCompleteResult, err error)

ResourcesListByWorkspaceCompleteMatchingPredicate retrieves all the results and then applies the predicate

type PrivateLinkResource 

type PrivateLinkResource struct {
	Id         *string                        `json:"id,omitempty"`
	Name       *string                        `json:"name,omitempty"`
	Properties *PrivateLinkResourceProperties `json:"properties,omitempty"`
	Type       *string                        `json:"type,omitempty"`
}

type PrivateLinkResourceOperationPredicate 

type PrivateLinkResourceOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (PrivateLinkResourceOperationPredicate) Matches 

func (p PrivateLinkResourceOperationPredicate) Matches(input PrivateLinkResource) bool

type PrivateLinkResourceProperties 

type PrivateLinkResourceProperties struct {
	GroupId           *string   `json:"groupId,omitempty"`
	RequiredMembers   *[]string `json:"requiredMembers,omitempty"`
	RequiredZoneNames *[]string `json:"requiredZoneNames,omitempty"`
}

type PrivateLinkServiceConnectionState 

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

type ResourcesListByHostPoolCompleteResult 

type ResourcesListByHostPoolCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []PrivateLinkResource
}

type ResourcesListByHostPoolOperationResponse 

type ResourcesListByHostPoolOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]PrivateLinkResource
}

type ResourcesListByWorkspaceCompleteResult 

type ResourcesListByWorkspaceCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []PrivateLinkResource
}

type ResourcesListByWorkspaceOperationResponse 

type ResourcesListByWorkspaceOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]PrivateLinkResource
}

type WorkspaceId 

type WorkspaceId struct {
	SubscriptionId    string
	ResourceGroupName string
	WorkspaceName     string
}

WorkspaceId is a struct representing the Resource ID for a Workspace

func NewWorkspaceID 

func NewWorkspaceID(subscriptionId string, resourceGroupName string, workspaceName string) WorkspaceId

NewWorkspaceID returns a new WorkspaceId struct

func ParseWorkspaceID 

func ParseWorkspaceID(input string) (*WorkspaceId, error)

ParseWorkspaceID parses 'input' into a WorkspaceId

func ParseWorkspaceIDInsensitively 

func ParseWorkspaceIDInsensitively(input string) (*WorkspaceId, error)

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

func (*WorkspaceId) FromParseResult 

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

func (WorkspaceId) ID 

func (id WorkspaceId) ID() string

ID returns the formatted Workspace ID

func (WorkspaceId) Segments 

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

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

func (WorkspaceId) String 

func (id WorkspaceId) String() string

String returns a human-readable description of this Workspace ID

type WorkspacePrivateEndpointConnectionId 

type WorkspacePrivateEndpointConnectionId struct {
	SubscriptionId                string
	ResourceGroupName             string
	WorkspaceName                 string
	PrivateEndpointConnectionName string
}

WorkspacePrivateEndpointConnectionId is a struct representing the Resource ID for a Workspace Private Endpoint Connection

func NewWorkspacePrivateEndpointConnectionID 

func NewWorkspacePrivateEndpointConnectionID(subscriptionId string, resourceGroupName string, workspaceName string, privateEndpointConnectionName string) WorkspacePrivateEndpointConnectionId

NewWorkspacePrivateEndpointConnectionID returns a new WorkspacePrivateEndpointConnectionId struct

func ParseWorkspacePrivateEndpointConnectionID 

func ParseWorkspacePrivateEndpointConnectionID(input string) (*WorkspacePrivateEndpointConnectionId, error)

ParseWorkspacePrivateEndpointConnectionID parses 'input' into a WorkspacePrivateEndpointConnectionId

func ParseWorkspacePrivateEndpointConnectionIDInsensitively 

func ParseWorkspacePrivateEndpointConnectionIDInsensitively(input string) (*WorkspacePrivateEndpointConnectionId, error)

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

func (*WorkspacePrivateEndpointConnectionId) FromParseResult 

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

func (WorkspacePrivateEndpointConnectionId) ID 

func (id WorkspacePrivateEndpointConnectionId) ID() string

ID returns the formatted Workspace Private Endpoint Connection ID

func (WorkspacePrivateEndpointConnectionId) Segments 

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

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

func (WorkspacePrivateEndpointConnectionId) String 

func (id WorkspacePrivateEndpointConnectionId) String() string

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

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.