accounts

package
v0.20240422.1112441 Latest Latest
Warning

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

Go to latest
Published: Apr 22, 2024 License: MPL-2.0 Imports: 14 Imported by: 0

README

github.com/hashicorp/go-azure-sdk/resource-manager/media/2021-11-01/accounts Documentation

The accounts SDK allows for interaction with the Azure Resource Manager Service media (API Version 2021-11-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/media/2021-11-01/accounts"

Client Initialization

client := accounts.NewAccountsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: AccountsClient.LocationsCheckNameAvailability

ctx := context.TODO()
id := accounts.NewLocationID("12345678-1234-9876-4563-123456789012", "locationValue")

payload := accounts.CheckNameAvailabilityInput{
	// ...
}


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

Example Usage: AccountsClient.MediaservicesCreateOrUpdate

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

payload := accounts.MediaService{
	// ...
}


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

Example Usage: AccountsClient.MediaservicesDelete

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

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

Example Usage: AccountsClient.MediaservicesGet

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

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

Example Usage: AccountsClient.MediaservicesList

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

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

Example Usage: AccountsClient.MediaservicesListBySubscription

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

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

Example Usage: AccountsClient.MediaservicesListEdgePolicies

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

payload := accounts.ListEdgePoliciesInput{
	// ...
}


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

Example Usage: AccountsClient.MediaservicesSyncStorageKeys

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

payload := accounts.SyncStorageKeysInput{
	// ...
}


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

Example Usage: AccountsClient.MediaservicesUpdate

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

payload := accounts.MediaServiceUpdate{
	// ...
}


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

Example Usage: AccountsClient.PrivateEndpointConnectionsCreateOrUpdate

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

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


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

Example Usage: AccountsClient.PrivateEndpointConnectionsDelete

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

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

Example Usage: AccountsClient.PrivateEndpointConnectionsGet

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

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

Example Usage: AccountsClient.PrivateEndpointConnectionsList

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

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

Example Usage: AccountsClient.PrivateLinkResourcesGet

ctx := context.TODO()
id := accounts.NewPrivateLinkResourceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "mediaServiceValue", "privateLinkResourceValue")

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

Example Usage: AccountsClient.PrivateLinkResourcesList

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

read, err := client.PrivateLinkResourcesList(ctx, id)
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 PossibleValuesForAccountEncryptionKeyType

func PossibleValuesForAccountEncryptionKeyType() []string

func PossibleValuesForDefaultAction

func PossibleValuesForDefaultAction() []string

func PossibleValuesForPrivateEndpointConnectionProvisioningState

func PossibleValuesForPrivateEndpointConnectionProvisioningState() []string

func PossibleValuesForPrivateEndpointServiceConnectionStatus

func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string

func PossibleValuesForProvisioningState

func PossibleValuesForProvisioningState() []string

func PossibleValuesForPublicNetworkAccess

func PossibleValuesForPublicNetworkAccess() []string

func PossibleValuesForStorageAccountType

func PossibleValuesForStorageAccountType() []string

func PossibleValuesForStorageAuthentication

func PossibleValuesForStorageAuthentication() []string

func ValidateLocationID

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

ValidateLocationID checks that 'input' can be parsed as a Location ID

func ValidateMediaServiceID

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

ValidateMediaServiceID checks that 'input' can be parsed as a Media Service 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 ValidatePrivateLinkResourceID

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

ValidatePrivateLinkResourceID checks that 'input' can be parsed as a Private Link Resource ID

Types

type AccessControl

type AccessControl struct {
	DefaultAction *DefaultAction `json:"defaultAction,omitempty"`
	IPAllowList   *[]string      `json:"ipAllowList,omitempty"`
}

type AccountEncryption

type AccountEncryption struct {
	Identity           *ResourceIdentity        `json:"identity,omitempty"`
	KeyVaultProperties *KeyVaultProperties      `json:"keyVaultProperties,omitempty"`
	Status             *string                  `json:"status,omitempty"`
	Type               AccountEncryptionKeyType `json:"type"`
}

type AccountEncryptionKeyType

type AccountEncryptionKeyType string
const (
	AccountEncryptionKeyTypeCustomerKey AccountEncryptionKeyType = "CustomerKey"
	AccountEncryptionKeyTypeSystemKey   AccountEncryptionKeyType = "SystemKey"
)

func (*AccountEncryptionKeyType) UnmarshalJSON

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

type AccountsClient

type AccountsClient struct {
	Client *resourcemanager.Client
}

func NewAccountsClientWithBaseURI

func NewAccountsClientWithBaseURI(sdkApi sdkEnv.Api) (*AccountsClient, error)

func (AccountsClient) LocationsCheckNameAvailability

func (c AccountsClient) LocationsCheckNameAvailability(ctx context.Context, id LocationId, input CheckNameAvailabilityInput) (result LocationsCheckNameAvailabilityOperationResponse, err error)

LocationsCheckNameAvailability ...

func (AccountsClient) MediaservicesCreateOrUpdate

func (c AccountsClient) MediaservicesCreateOrUpdate(ctx context.Context, id MediaServiceId, input MediaService) (result MediaservicesCreateOrUpdateOperationResponse, err error)

MediaservicesCreateOrUpdate ...

func (AccountsClient) MediaservicesCreateOrUpdateThenPoll

func (c AccountsClient) MediaservicesCreateOrUpdateThenPoll(ctx context.Context, id MediaServiceId, input MediaService) error

MediaservicesCreateOrUpdateThenPoll performs MediaservicesCreateOrUpdate then polls until it's completed

func (AccountsClient) MediaservicesDelete

func (c AccountsClient) MediaservicesDelete(ctx context.Context, id MediaServiceId) (result MediaservicesDeleteOperationResponse, err error)

MediaservicesDelete ...

func (AccountsClient) MediaservicesGet

func (c AccountsClient) MediaservicesGet(ctx context.Context, id MediaServiceId) (result MediaservicesGetOperationResponse, err error)

MediaservicesGet ...

func (AccountsClient) MediaservicesList

MediaservicesList ...

func (AccountsClient) MediaservicesListBySubscription

func (c AccountsClient) MediaservicesListBySubscription(ctx context.Context, id commonids.SubscriptionId) (result MediaservicesListBySubscriptionOperationResponse, err error)

MediaservicesListBySubscription ...

func (AccountsClient) MediaservicesListBySubscriptionComplete

func (c AccountsClient) MediaservicesListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (MediaservicesListBySubscriptionCompleteResult, error)

MediaservicesListBySubscriptionComplete retrieves all the results into a single object

func (AccountsClient) MediaservicesListBySubscriptionCompleteMatchingPredicate

func (c AccountsClient) MediaservicesListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate MediaServiceOperationPredicate) (result MediaservicesListBySubscriptionCompleteResult, err error)

MediaservicesListBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (AccountsClient) MediaservicesListComplete

MediaservicesListComplete retrieves all the results into a single object

func (AccountsClient) MediaservicesListCompleteMatchingPredicate

func (c AccountsClient) MediaservicesListCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate MediaServiceOperationPredicate) (result MediaservicesListCompleteResult, err error)

MediaservicesListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (AccountsClient) MediaservicesListEdgePolicies

func (c AccountsClient) MediaservicesListEdgePolicies(ctx context.Context, id MediaServiceId, input ListEdgePoliciesInput) (result MediaservicesListEdgePoliciesOperationResponse, err error)

MediaservicesListEdgePolicies ...

func (AccountsClient) MediaservicesSyncStorageKeys

func (c AccountsClient) MediaservicesSyncStorageKeys(ctx context.Context, id MediaServiceId, input SyncStorageKeysInput) (result MediaservicesSyncStorageKeysOperationResponse, err error)

MediaservicesSyncStorageKeys ...

func (AccountsClient) MediaservicesUpdate

MediaservicesUpdate ...

func (AccountsClient) MediaservicesUpdateThenPoll

func (c AccountsClient) MediaservicesUpdateThenPoll(ctx context.Context, id MediaServiceId, input MediaServiceUpdate) error

MediaservicesUpdateThenPoll performs MediaservicesUpdate then polls until it's completed

func (AccountsClient) PrivateEndpointConnectionsCreateOrUpdate

PrivateEndpointConnectionsCreateOrUpdate ...

func (AccountsClient) PrivateEndpointConnectionsDelete

PrivateEndpointConnectionsDelete ...

func (AccountsClient) PrivateEndpointConnectionsGet

PrivateEndpointConnectionsGet ...

func (AccountsClient) PrivateEndpointConnectionsList

func (c AccountsClient) PrivateEndpointConnectionsList(ctx context.Context, id MediaServiceId) (result PrivateEndpointConnectionsListOperationResponse, err error)

PrivateEndpointConnectionsList ...

func (AccountsClient) PrivateLinkResourcesGet

func (c AccountsClient) PrivateLinkResourcesGet(ctx context.Context, id PrivateLinkResourceId) (result PrivateLinkResourcesGetOperationResponse, err error)

PrivateLinkResourcesGet ...

func (AccountsClient) PrivateLinkResourcesList

func (c AccountsClient) PrivateLinkResourcesList(ctx context.Context, id MediaServiceId) (result PrivateLinkResourcesListOperationResponse, err error)

PrivateLinkResourcesList ...

type CheckNameAvailabilityInput

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

type DefaultAction

type DefaultAction string
const (
	DefaultActionAllow DefaultAction = "Allow"
	DefaultActionDeny  DefaultAction = "Deny"
)

func (*DefaultAction) UnmarshalJSON

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

type EdgePolicies

type EdgePolicies struct {
	UsageDataCollectionPolicy *EdgeUsageDataCollectionPolicy `json:"usageDataCollectionPolicy,omitempty"`
}

type EdgeUsageDataCollectionPolicy

type EdgeUsageDataCollectionPolicy struct {
	DataCollectionFrequency           *string                `json:"dataCollectionFrequency,omitempty"`
	DataReportingFrequency            *string                `json:"dataReportingFrequency,omitempty"`
	EventHubDetails                   *EdgeUsageDataEventHub `json:"eventHubDetails,omitempty"`
	MaxAllowedUnreportedUsageDuration *string                `json:"maxAllowedUnreportedUsageDuration,omitempty"`
}

type EdgeUsageDataEventHub

type EdgeUsageDataEventHub struct {
	Name      *string `json:"name,omitempty"`
	Namespace *string `json:"namespace,omitempty"`
	Token     *string `json:"token,omitempty"`
}

type EntityNameAvailabilityCheckOutput

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

type KeyDelivery

type KeyDelivery struct {
	AccessControl *AccessControl `json:"accessControl,omitempty"`
}

type KeyVaultProperties

type KeyVaultProperties struct {
	CurrentKeyIdentifier *string `json:"currentKeyIdentifier,omitempty"`
	KeyIdentifier        *string `json:"keyIdentifier,omitempty"`
}

type ListEdgePoliciesInput

type ListEdgePoliciesInput struct {
	DeviceId *string `json:"deviceId,omitempty"`
}

type LocationId

type LocationId struct {
	SubscriptionId string
	LocationName   string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID

func NewLocationID(subscriptionId string, locationName string) LocationId

NewLocationID returns a new LocationId struct

func ParseLocationID

func ParseLocationID(input string) (*LocationId, error)

ParseLocationID parses 'input' into a LocationId

func ParseLocationIDInsensitively

func ParseLocationIDInsensitively(input string) (*LocationId, error)

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

func (*LocationId) FromParseResult

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

func (LocationId) ID

func (id LocationId) ID() string

ID returns the formatted Location ID

func (LocationId) Segments

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

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

func (LocationId) String

func (id LocationId) String() string

String returns a human-readable description of this Location ID

type LocationsCheckNameAvailabilityOperationResponse

type LocationsCheckNameAvailabilityOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EntityNameAvailabilityCheckOutput
}

type MediaService

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

type MediaServiceId

type MediaServiceId struct {
	SubscriptionId    string
	ResourceGroupName string
	MediaServiceName  string
}

MediaServiceId is a struct representing the Resource ID for a Media Service

func NewMediaServiceID

func NewMediaServiceID(subscriptionId string, resourceGroupName string, mediaServiceName string) MediaServiceId

NewMediaServiceID returns a new MediaServiceId struct

func ParseMediaServiceID

func ParseMediaServiceID(input string) (*MediaServiceId, error)

ParseMediaServiceID parses 'input' into a MediaServiceId

func ParseMediaServiceIDInsensitively

func ParseMediaServiceIDInsensitively(input string) (*MediaServiceId, error)

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

func (*MediaServiceId) FromParseResult

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

func (MediaServiceId) ID

func (id MediaServiceId) ID() string

ID returns the formatted Media Service ID

func (MediaServiceId) Segments

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

Segments returns a slice of Resource ID Segments which comprise this Media Service ID

func (MediaServiceId) String

func (id MediaServiceId) String() string

String returns a human-readable description of this Media Service ID

type MediaServiceIdentity

type MediaServiceIdentity struct {
	PrincipalId            *string                                 `json:"principalId,omitempty"`
	TenantId               *string                                 `json:"tenantId,omitempty"`
	Type                   string                                  `json:"type"`
	UserAssignedIdentities *map[string]UserAssignedManagedIdentity `json:"userAssignedIdentities,omitempty"`
}

type MediaServiceOperationPredicate

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

func (MediaServiceOperationPredicate) Matches

type MediaServiceProperties

type MediaServiceProperties struct {
	Encryption                 *AccountEncryption           `json:"encryption,omitempty"`
	KeyDelivery                *KeyDelivery                 `json:"keyDelivery,omitempty"`
	MediaServiceId             *string                      `json:"mediaServiceId,omitempty"`
	PrivateEndpointConnections *[]PrivateEndpointConnection `json:"privateEndpointConnections,omitempty"`
	ProvisioningState          *ProvisioningState           `json:"provisioningState,omitempty"`
	PublicNetworkAccess        *PublicNetworkAccess         `json:"publicNetworkAccess,omitempty"`
	StorageAccounts            *[]StorageAccount            `json:"storageAccounts,omitempty"`
	StorageAuthentication      *StorageAuthentication       `json:"storageAuthentication,omitempty"`
}

type MediaServiceUpdate

type MediaServiceUpdate struct {
	Identity   *MediaServiceIdentity   `json:"identity,omitempty"`
	Properties *MediaServiceProperties `json:"properties,omitempty"`
	Tags       *map[string]string      `json:"tags,omitempty"`
}

type MediaservicesCreateOrUpdateOperationResponse

type MediaservicesCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *MediaService
}

type MediaservicesDeleteOperationResponse

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

type MediaservicesGetOperationResponse

type MediaservicesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *MediaService
}

type MediaservicesListBySubscriptionCompleteResult

type MediaservicesListBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []MediaService
}

type MediaservicesListBySubscriptionOperationResponse

type MediaservicesListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]MediaService
}

type MediaservicesListCompleteResult

type MediaservicesListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []MediaService
}

type MediaservicesListEdgePoliciesOperationResponse

type MediaservicesListEdgePoliciesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EdgePolicies
}

type MediaservicesListOperationResponse

type MediaservicesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]MediaService
}

type MediaservicesSyncStorageKeysOperationResponse

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

type MediaservicesUpdateOperationResponse

type MediaservicesUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *MediaService
}

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
	MediaServiceName              string
	PrivateEndpointConnectionName string
}

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

func NewPrivateEndpointConnectionID

func NewPrivateEndpointConnectionID(subscriptionId string, resourceGroupName string, mediaServiceName 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

ID returns the formatted Private Endpoint Connection ID

func (PrivateEndpointConnectionId) Segments

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 PrivateEndpointConnectionListResult

type PrivateEndpointConnectionListResult struct {
	Value *[]PrivateEndpointConnection `json:"value,omitempty"`
}

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 PrivateEndpointConnectionsCreateOrUpdateOperationResponse

type PrivateEndpointConnectionsCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnection
}

type PrivateEndpointConnectionsDeleteOperationResponse

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

type PrivateEndpointConnectionsGetOperationResponse

type PrivateEndpointConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnection
}

type PrivateEndpointConnectionsListOperationResponse

type PrivateEndpointConnectionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateEndpointConnectionListResult
}

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 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 PrivateLinkResourceId

type PrivateLinkResourceId struct {
	SubscriptionId          string
	ResourceGroupName       string
	MediaServiceName        string
	PrivateLinkResourceName string
}

PrivateLinkResourceId is a struct representing the Resource ID for a Private Link Resource

func NewPrivateLinkResourceID

func NewPrivateLinkResourceID(subscriptionId string, resourceGroupName string, mediaServiceName string, privateLinkResourceName string) PrivateLinkResourceId

NewPrivateLinkResourceID returns a new PrivateLinkResourceId struct

func ParsePrivateLinkResourceID

func ParsePrivateLinkResourceID(input string) (*PrivateLinkResourceId, error)

ParsePrivateLinkResourceID parses 'input' into a PrivateLinkResourceId

func ParsePrivateLinkResourceIDInsensitively

func ParsePrivateLinkResourceIDInsensitively(input string) (*PrivateLinkResourceId, error)

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

func (*PrivateLinkResourceId) FromParseResult

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

func (PrivateLinkResourceId) ID

func (id PrivateLinkResourceId) ID() string

ID returns the formatted Private Link Resource ID

func (PrivateLinkResourceId) Segments

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

Segments returns a slice of Resource ID Segments which comprise this Private Link Resource ID

func (PrivateLinkResourceId) String

func (id PrivateLinkResourceId) String() string

String returns a human-readable description of this Private Link Resource ID

type PrivateLinkResourceListResult

type PrivateLinkResourceListResult struct {
	Value *[]PrivateLinkResource `json:"value,omitempty"`
}

type PrivateLinkResourceProperties

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

type PrivateLinkResourcesGetOperationResponse

type PrivateLinkResourcesGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateLinkResource
}

type PrivateLinkResourcesListOperationResponse

type PrivateLinkResourcesListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *PrivateLinkResourceListResult
}

type PrivateLinkServiceConnectionState

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

type ProvisioningState

type ProvisioningState string
const (
	ProvisioningStateFailed     ProvisioningState = "Failed"
	ProvisioningStateInProgress ProvisioningState = "InProgress"
	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 ResourceIdentity

type ResourceIdentity struct {
	UseSystemAssignedIdentity bool    `json:"useSystemAssignedIdentity"`
	UserAssignedIdentity      *string `json:"userAssignedIdentity,omitempty"`
}

type StorageAccount

type StorageAccount struct {
	Id       *string            `json:"id,omitempty"`
	Identity *ResourceIdentity  `json:"identity,omitempty"`
	Status   *string            `json:"status,omitempty"`
	Type     StorageAccountType `json:"type"`
}

type StorageAccountType

type StorageAccountType string
const (
	StorageAccountTypePrimary   StorageAccountType = "Primary"
	StorageAccountTypeSecondary StorageAccountType = "Secondary"
)

func (*StorageAccountType) UnmarshalJSON

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

type StorageAuthentication

type StorageAuthentication string
const (
	StorageAuthenticationManagedIdentity StorageAuthentication = "ManagedIdentity"
	StorageAuthenticationSystem          StorageAuthentication = "System"
)

func (*StorageAuthentication) UnmarshalJSON

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

type SyncStorageKeysInput

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

type UserAssignedManagedIdentity

type UserAssignedManagedIdentity struct {
	ClientId    *string `json:"clientId,omitempty"`
	PrincipalId *string `json:"principalId,omitempty"`
}

Source Files

Jump to

Keyboard shortcuts

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