signalr

package
v0.20220915.1142222 Latest Latest
Warning

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

Go to latest
Published: Sep 15, 2022 License: MPL-2.0 Imports: 12 Imported by: 0

README

github.com/hashicorp/go-azure-sdk/resource-manager/signalr/2021-10-01/signalr Documentation

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

Client Initialization

client := signalr.NewSignalRClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: SignalRClient.CheckNameAvailability

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

payload := signalr.NameAvailabilityParameters{
	// ...
}


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: SignalRClient.CreateOrUpdate

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

payload := signalr.SignalRResource{
	// ...
}


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

Example Usage: SignalRClient.Delete

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

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

Example Usage: SignalRClient.Get

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

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

Example Usage: SignalRClient.ListByResourceGroup

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

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

Example Usage: SignalRClient.ListBySubscription

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

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

Example Usage: SignalRClient.ListKeys

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

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

Example Usage: SignalRClient.ListSkus

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

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

Example Usage: SignalRClient.PrivateEndpointConnectionsDelete

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

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

Example Usage: SignalRClient.PrivateEndpointConnectionsGet

ctx := context.TODO()
id := signalr.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "resourceValue", "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: SignalRClient.PrivateEndpointConnectionsList

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

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

Example Usage: SignalRClient.PrivateEndpointConnectionsUpdate

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

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


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

Example Usage: SignalRClient.PrivateLinkResourcesList

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

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

Example Usage: SignalRClient.RegenerateKey

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

payload := signalr.RegenerateKeyParameters{
	// ...
}


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

Example Usage: SignalRClient.Restart

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

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

Example Usage: SignalRClient.SharedPrivateLinkResourcesCreateOrUpdate

ctx := context.TODO()
id := signalr.NewSharedPrivateLinkResourceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "resourceValue", "sharedPrivateLinkResourceValue")

payload := signalr.SharedPrivateLinkResource{
	// ...
}


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

Example Usage: SignalRClient.SharedPrivateLinkResourcesDelete

ctx := context.TODO()
id := signalr.NewSharedPrivateLinkResourceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "resourceValue", "sharedPrivateLinkResourceValue")

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

Example Usage: SignalRClient.SharedPrivateLinkResourcesGet

ctx := context.TODO()
id := signalr.NewSharedPrivateLinkResourceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "resourceValue", "sharedPrivateLinkResourceValue")

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

Example Usage: SignalRClient.SharedPrivateLinkResourcesList

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

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

Example Usage: SignalRClient.Update

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

payload := signalr.SignalRResource{
	// ...
}


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

Example Usage: SignalRClient.UsagesList

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

// alternatively `client.UsagesList(ctx, id)` can be used to do batched pagination
items, err := client.UsagesListComplete(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 PossibleValuesForACLAction

func PossibleValuesForACLAction() []string

func PossibleValuesForFeatureFlags

func PossibleValuesForFeatureFlags() []string

func PossibleValuesForKeyType

func PossibleValuesForKeyType() []string

func PossibleValuesForPrivateLinkServiceConnectionStatus

func PossibleValuesForPrivateLinkServiceConnectionStatus() []string

func PossibleValuesForProvisioningState

func PossibleValuesForProvisioningState() []string

func PossibleValuesForScaleType

func PossibleValuesForScaleType() []string

func PossibleValuesForServiceKind

func PossibleValuesForServiceKind() []string

func PossibleValuesForSharedPrivateLinkResourceStatus

func PossibleValuesForSharedPrivateLinkResourceStatus() []string

func PossibleValuesForSignalRRequestType

func PossibleValuesForSignalRRequestType() []string

func PossibleValuesForSignalRSkuTier

func PossibleValuesForSignalRSkuTier() []string

func PossibleValuesForUpstreamAuthType

func PossibleValuesForUpstreamAuthType() []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 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 ValidateSharedPrivateLinkResourceID

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

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

func ValidateSignalRID

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

ValidateSignalRID checks that 'input' can be parsed as a Signal R ID

Types

type ACLAction

type ACLAction string
const (
	ACLActionAllow ACLAction = "Allow"
	ACLActionDeny  ACLAction = "Deny"
)

type CheckNameAvailabilityOperationResponse

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

type CreateOrUpdateOperationResponse

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

type DeleteOperationResponse

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

type FeatureFlags

type FeatureFlags string
const (
	FeatureFlagsEnableConnectivityLogs FeatureFlags = "EnableConnectivityLogs"
	FeatureFlagsEnableLiveTrace        FeatureFlags = "EnableLiveTrace"
	FeatureFlagsEnableMessagingLogs    FeatureFlags = "EnableMessagingLogs"
	FeatureFlagsServiceMode            FeatureFlags = "ServiceMode"
)

type GetOperationResponse

type GetOperationResponse struct {
	HttpResponse *http.Response
	Model        *SignalRResource
}

type KeyType

type KeyType string
const (
	KeyTypePrimary   KeyType = "Primary"
	KeyTypeSalt      KeyType = "Salt"
	KeyTypeSecondary KeyType = "Secondary"
)

type ListByResourceGroupCompleteResult

type ListByResourceGroupCompleteResult struct {
	Items []SignalRResource
}

type ListByResourceGroupOperationResponse

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

func (ListByResourceGroupOperationResponse) HasMore

func (ListByResourceGroupOperationResponse) LoadMore

type ListBySubscriptionCompleteResult

type ListBySubscriptionCompleteResult struct {
	Items []SignalRResource
}

type ListBySubscriptionOperationResponse

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

func (ListBySubscriptionOperationResponse) HasMore

func (ListBySubscriptionOperationResponse) LoadMore

type ListKeysOperationResponse

type ListKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *SignalRKeys
}

type ListSkusOperationResponse

type ListSkusOperationResponse struct {
	HttpResponse *http.Response
	Model        *SkuList
}

type LocationId

type LocationId struct {
	SubscriptionId string
	Location       string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID

func NewLocationID(subscriptionId string, location 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) 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 ManagedIdentitySettings

type ManagedIdentitySettings struct {
	Resource *string `json:"resource,omitempty"`
}

type NameAvailability

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

type NameAvailabilityParameters

type NameAvailabilityParameters struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type NetworkACL

type NetworkACL struct {
	Allow *[]SignalRRequestType `json:"allow,omitempty"`
	Deny  *[]SignalRRequestType `json:"deny,omitempty"`
}

type PrivateEndpoint

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

type PrivateEndpointACL

type PrivateEndpointACL struct {
	Allow *[]SignalRRequestType `json:"allow,omitempty"`
	Deny  *[]SignalRRequestType `json:"deny,omitempty"`
	Name  string                `json:"name"`
}

type PrivateEndpointConnection

type PrivateEndpointConnection 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 PrivateEndpointConnectionId

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

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

func NewPrivateEndpointConnectionID

func NewPrivateEndpointConnectionID(subscriptionId string, resourceGroupName string, resourceName 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) 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 PrivateEndpointConnectionOperationPredicate

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

func (PrivateEndpointConnectionOperationPredicate) Matches

type PrivateEndpointConnectionProperties

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

type PrivateEndpointConnectionsDeleteOperationResponse

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

type PrivateEndpointConnectionsGetOperationResponse

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

type PrivateEndpointConnectionsListCompleteResult

type PrivateEndpointConnectionsListCompleteResult struct {
	Items []PrivateEndpointConnection
}

type PrivateEndpointConnectionsListOperationResponse

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

func (PrivateEndpointConnectionsListOperationResponse) HasMore

func (PrivateEndpointConnectionsListOperationResponse) LoadMore

type PrivateEndpointConnectionsUpdateOperationResponse

type PrivateEndpointConnectionsUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *PrivateEndpointConnection
}

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

type PrivateLinkResourceProperties

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

type PrivateLinkResourcesListCompleteResult

type PrivateLinkResourcesListCompleteResult struct {
	Items []PrivateLinkResource
}

type PrivateLinkResourcesListOperationResponse

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

func (PrivateLinkResourcesListOperationResponse) HasMore

func (PrivateLinkResourcesListOperationResponse) LoadMore

type PrivateLinkServiceConnectionState

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

type PrivateLinkServiceConnectionStatus

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

type ProvisioningState

type ProvisioningState string
const (
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateCreating  ProvisioningState = "Creating"
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateMoving    ProvisioningState = "Moving"
	ProvisioningStateRunning   ProvisioningState = "Running"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	ProvisioningStateUnknown   ProvisioningState = "Unknown"
	ProvisioningStateUpdating  ProvisioningState = "Updating"
)

type RegenerateKeyOperationResponse

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

type RegenerateKeyParameters

type RegenerateKeyParameters struct {
	KeyType *KeyType `json:"keyType,omitempty"`
}

type ResourceLogCategory

type ResourceLogCategory struct {
	Enabled *string `json:"enabled,omitempty"`
	Name    *string `json:"name,omitempty"`
}

type ResourceLogConfiguration

type ResourceLogConfiguration struct {
	Categories *[]ResourceLogCategory `json:"categories,omitempty"`
}

type ResourceSku

type ResourceSku struct {
	Capacity *int64          `json:"capacity,omitempty"`
	Family   *string         `json:"family,omitempty"`
	Name     string          `json:"name"`
	Size     *string         `json:"size,omitempty"`
	Tier     *SignalRSkuTier `json:"tier,omitempty"`
}

type RestartOperationResponse

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

type ScaleType

type ScaleType string
const (
	ScaleTypeAutomatic ScaleType = "Automatic"
	ScaleTypeManual    ScaleType = "Manual"
	ScaleTypeNone      ScaleType = "None"
)

type ServerlessUpstreamSettings

type ServerlessUpstreamSettings struct {
	Templates *[]UpstreamTemplate `json:"templates,omitempty"`
}

type ServiceKind

type ServiceKind string
const (
	ServiceKindRawWebSockets ServiceKind = "RawWebSockets"
	ServiceKindSignalR       ServiceKind = "SignalR"
)

type ShareablePrivateLinkResourceProperties

type ShareablePrivateLinkResourceProperties struct {
	Description *string `json:"description,omitempty"`
	GroupId     *string `json:"groupId,omitempty"`
	Type        *string `json:"type,omitempty"`
}

type ShareablePrivateLinkResourceType

type ShareablePrivateLinkResourceType struct {
	Name       *string                                 `json:"name,omitempty"`
	Properties *ShareablePrivateLinkResourceProperties `json:"properties,omitempty"`
}

type SharedPrivateLinkResource

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

type SharedPrivateLinkResourceId

type SharedPrivateLinkResourceId struct {
	SubscriptionId                string
	ResourceGroupName             string
	ResourceName                  string
	SharedPrivateLinkResourceName string
}

SharedPrivateLinkResourceId is a struct representing the Resource ID for a Shared Private Link Resource

func NewSharedPrivateLinkResourceID

func NewSharedPrivateLinkResourceID(subscriptionId string, resourceGroupName string, resourceName string, sharedPrivateLinkResourceName string) SharedPrivateLinkResourceId

NewSharedPrivateLinkResourceID returns a new SharedPrivateLinkResourceId struct

func ParseSharedPrivateLinkResourceID

func ParseSharedPrivateLinkResourceID(input string) (*SharedPrivateLinkResourceId, error)

ParseSharedPrivateLinkResourceID parses 'input' into a SharedPrivateLinkResourceId

func ParseSharedPrivateLinkResourceIDInsensitively

func ParseSharedPrivateLinkResourceIDInsensitively(input string) (*SharedPrivateLinkResourceId, error)

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

func (SharedPrivateLinkResourceId) ID

ID returns the formatted Shared Private Link Resource ID

func (SharedPrivateLinkResourceId) Segments

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

func (SharedPrivateLinkResourceId) String

func (id SharedPrivateLinkResourceId) String() string

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

type SharedPrivateLinkResourceOperationPredicate

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

func (SharedPrivateLinkResourceOperationPredicate) Matches

type SharedPrivateLinkResourceProperties

type SharedPrivateLinkResourceProperties struct {
	GroupId               string                           `json:"groupId"`
	PrivateLinkResourceId string                           `json:"privateLinkResourceId"`
	ProvisioningState     *ProvisioningState               `json:"provisioningState,omitempty"`
	RequestMessage        *string                          `json:"requestMessage,omitempty"`
	Status                *SharedPrivateLinkResourceStatus `json:"status,omitempty"`
}

type SharedPrivateLinkResourceStatus

type SharedPrivateLinkResourceStatus string
const (
	SharedPrivateLinkResourceStatusApproved     SharedPrivateLinkResourceStatus = "Approved"
	SharedPrivateLinkResourceStatusDisconnected SharedPrivateLinkResourceStatus = "Disconnected"
	SharedPrivateLinkResourceStatusPending      SharedPrivateLinkResourceStatus = "Pending"
	SharedPrivateLinkResourceStatusRejected     SharedPrivateLinkResourceStatus = "Rejected"
	SharedPrivateLinkResourceStatusTimeout      SharedPrivateLinkResourceStatus = "Timeout"
)

type SharedPrivateLinkResourcesCreateOrUpdateOperationResponse

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

type SharedPrivateLinkResourcesDeleteOperationResponse

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

type SharedPrivateLinkResourcesGetOperationResponse

type SharedPrivateLinkResourcesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *SharedPrivateLinkResource
}

type SharedPrivateLinkResourcesListCompleteResult

type SharedPrivateLinkResourcesListCompleteResult struct {
	Items []SharedPrivateLinkResource
}

type SharedPrivateLinkResourcesListOperationResponse

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

func (SharedPrivateLinkResourcesListOperationResponse) HasMore

func (SharedPrivateLinkResourcesListOperationResponse) LoadMore

type SignalRClient

type SignalRClient struct {
	Client autorest.Client
	// contains filtered or unexported fields
}

func NewSignalRClientWithBaseURI

func NewSignalRClientWithBaseURI(endpoint string) SignalRClient

func (SignalRClient) CheckNameAvailability

CheckNameAvailability ...

func (SignalRClient) CreateOrUpdate

func (c SignalRClient) CreateOrUpdate(ctx context.Context, id SignalRId, input SignalRResource) (result CreateOrUpdateOperationResponse, err error)

CreateOrUpdate ...

func (SignalRClient) CreateOrUpdateThenPoll

func (c SignalRClient) CreateOrUpdateThenPoll(ctx context.Context, id SignalRId, input SignalRResource) error

CreateOrUpdateThenPoll performs CreateOrUpdate then polls until it's completed

func (SignalRClient) Delete

func (c SignalRClient) Delete(ctx context.Context, id SignalRId) (result DeleteOperationResponse, err error)

Delete ...

func (SignalRClient) DeleteThenPoll

func (c SignalRClient) DeleteThenPoll(ctx context.Context, id SignalRId) error

DeleteThenPoll performs Delete then polls until it's completed

func (SignalRClient) Get

func (c SignalRClient) Get(ctx context.Context, id SignalRId) (result GetOperationResponse, err error)

Get ...

func (SignalRClient) ListByResourceGroup

ListByResourceGroup ...

func (SignalRClient) ListByResourceGroupComplete

ListByResourceGroupComplete retrieves all of the results into a single object

func (SignalRClient) ListByResourceGroupCompleteMatchingPredicate

func (c SignalRClient) ListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate SignalRResourceOperationPredicate) (resp ListByResourceGroupCompleteResult, err error)

ListByResourceGroupCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (SignalRClient) ListBySubscription

ListBySubscription ...

func (SignalRClient) ListBySubscriptionComplete

ListBySubscriptionComplete retrieves all of the results into a single object

func (SignalRClient) ListBySubscriptionCompleteMatchingPredicate

func (c SignalRClient) ListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate SignalRResourceOperationPredicate) (resp ListBySubscriptionCompleteResult, err error)

ListBySubscriptionCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (SignalRClient) ListKeys

func (c SignalRClient) ListKeys(ctx context.Context, id SignalRId) (result ListKeysOperationResponse, err error)

ListKeys ...

func (SignalRClient) ListSkus

func (c SignalRClient) ListSkus(ctx context.Context, id SignalRId) (result ListSkusOperationResponse, err error)

ListSkus ...

func (SignalRClient) PrivateEndpointConnectionsDelete

func (c SignalRClient) PrivateEndpointConnectionsDelete(ctx context.Context, id PrivateEndpointConnectionId) (result PrivateEndpointConnectionsDeleteOperationResponse, err error)

PrivateEndpointConnectionsDelete ...

func (SignalRClient) PrivateEndpointConnectionsDeleteThenPoll

func (c SignalRClient) PrivateEndpointConnectionsDeleteThenPoll(ctx context.Context, id PrivateEndpointConnectionId) error

PrivateEndpointConnectionsDeleteThenPoll performs PrivateEndpointConnectionsDelete then polls until it's completed

func (SignalRClient) PrivateEndpointConnectionsGet

PrivateEndpointConnectionsGet ...

func (SignalRClient) PrivateEndpointConnectionsList

func (c SignalRClient) PrivateEndpointConnectionsList(ctx context.Context, id SignalRId) (resp PrivateEndpointConnectionsListOperationResponse, err error)

PrivateEndpointConnectionsList ...

func (SignalRClient) PrivateEndpointConnectionsListComplete

func (c SignalRClient) PrivateEndpointConnectionsListComplete(ctx context.Context, id SignalRId) (PrivateEndpointConnectionsListCompleteResult, error)

PrivateEndpointConnectionsListComplete retrieves all of the results into a single object

func (SignalRClient) PrivateEndpointConnectionsListCompleteMatchingPredicate

func (c SignalRClient) PrivateEndpointConnectionsListCompleteMatchingPredicate(ctx context.Context, id SignalRId, predicate PrivateEndpointConnectionOperationPredicate) (resp PrivateEndpointConnectionsListCompleteResult, err error)

PrivateEndpointConnectionsListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (SignalRClient) PrivateEndpointConnectionsUpdate

PrivateEndpointConnectionsUpdate ...

func (SignalRClient) PrivateLinkResourcesList

func (c SignalRClient) PrivateLinkResourcesList(ctx context.Context, id SignalRId) (resp PrivateLinkResourcesListOperationResponse, err error)

PrivateLinkResourcesList ...

func (SignalRClient) PrivateLinkResourcesListComplete

func (c SignalRClient) PrivateLinkResourcesListComplete(ctx context.Context, id SignalRId) (PrivateLinkResourcesListCompleteResult, error)

PrivateLinkResourcesListComplete retrieves all of the results into a single object

func (SignalRClient) PrivateLinkResourcesListCompleteMatchingPredicate

func (c SignalRClient) PrivateLinkResourcesListCompleteMatchingPredicate(ctx context.Context, id SignalRId, predicate PrivateLinkResourceOperationPredicate) (resp PrivateLinkResourcesListCompleteResult, err error)

PrivateLinkResourcesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (SignalRClient) RegenerateKey

RegenerateKey ...

func (SignalRClient) RegenerateKeyThenPoll

func (c SignalRClient) RegenerateKeyThenPoll(ctx context.Context, id SignalRId, input RegenerateKeyParameters) error

RegenerateKeyThenPoll performs RegenerateKey then polls until it's completed

func (SignalRClient) Restart

func (c SignalRClient) Restart(ctx context.Context, id SignalRId) (result RestartOperationResponse, err error)

Restart ...

func (SignalRClient) RestartThenPoll

func (c SignalRClient) RestartThenPoll(ctx context.Context, id SignalRId) error

RestartThenPoll performs Restart then polls until it's completed

func (SignalRClient) SharedPrivateLinkResourcesCreateOrUpdate

SharedPrivateLinkResourcesCreateOrUpdate ...

func (SignalRClient) SharedPrivateLinkResourcesCreateOrUpdateThenPoll

func (c SignalRClient) SharedPrivateLinkResourcesCreateOrUpdateThenPoll(ctx context.Context, id SharedPrivateLinkResourceId, input SharedPrivateLinkResource) error

SharedPrivateLinkResourcesCreateOrUpdateThenPoll performs SharedPrivateLinkResourcesCreateOrUpdate then polls until it's completed

func (SignalRClient) SharedPrivateLinkResourcesDelete

func (c SignalRClient) SharedPrivateLinkResourcesDelete(ctx context.Context, id SharedPrivateLinkResourceId) (result SharedPrivateLinkResourcesDeleteOperationResponse, err error)

SharedPrivateLinkResourcesDelete ...

func (SignalRClient) SharedPrivateLinkResourcesDeleteThenPoll

func (c SignalRClient) SharedPrivateLinkResourcesDeleteThenPoll(ctx context.Context, id SharedPrivateLinkResourceId) error

SharedPrivateLinkResourcesDeleteThenPoll performs SharedPrivateLinkResourcesDelete then polls until it's completed

func (SignalRClient) SharedPrivateLinkResourcesGet

SharedPrivateLinkResourcesGet ...

func (SignalRClient) SharedPrivateLinkResourcesList

func (c SignalRClient) SharedPrivateLinkResourcesList(ctx context.Context, id SignalRId) (resp SharedPrivateLinkResourcesListOperationResponse, err error)

SharedPrivateLinkResourcesList ...

func (SignalRClient) SharedPrivateLinkResourcesListComplete

func (c SignalRClient) SharedPrivateLinkResourcesListComplete(ctx context.Context, id SignalRId) (SharedPrivateLinkResourcesListCompleteResult, error)

SharedPrivateLinkResourcesListComplete retrieves all of the results into a single object

func (SignalRClient) SharedPrivateLinkResourcesListCompleteMatchingPredicate

func (c SignalRClient) SharedPrivateLinkResourcesListCompleteMatchingPredicate(ctx context.Context, id SignalRId, predicate SharedPrivateLinkResourceOperationPredicate) (resp SharedPrivateLinkResourcesListCompleteResult, err error)

SharedPrivateLinkResourcesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (SignalRClient) Update

func (c SignalRClient) Update(ctx context.Context, id SignalRId, input SignalRResource) (result UpdateOperationResponse, err error)

Update ...

func (SignalRClient) UpdateThenPoll

func (c SignalRClient) UpdateThenPoll(ctx context.Context, id SignalRId, input SignalRResource) error

UpdateThenPoll performs Update then polls until it's completed

func (SignalRClient) UsagesList

func (c SignalRClient) UsagesList(ctx context.Context, id LocationId) (resp UsagesListOperationResponse, err error)

UsagesList ...

func (SignalRClient) UsagesListComplete

func (c SignalRClient) UsagesListComplete(ctx context.Context, id LocationId) (UsagesListCompleteResult, error)

UsagesListComplete retrieves all of the results into a single object

func (SignalRClient) UsagesListCompleteMatchingPredicate

func (c SignalRClient) UsagesListCompleteMatchingPredicate(ctx context.Context, id LocationId, predicate SignalRUsageOperationPredicate) (resp UsagesListCompleteResult, err error)

UsagesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

type SignalRCorsSettings

type SignalRCorsSettings struct {
	AllowedOrigins *[]string `json:"allowedOrigins,omitempty"`
}

type SignalRFeature

type SignalRFeature struct {
	Flag       FeatureFlags       `json:"flag"`
	Properties *map[string]string `json:"properties,omitempty"`
	Value      string             `json:"value"`
}

type SignalRId

type SignalRId struct {
	SubscriptionId    string
	ResourceGroupName string
	ResourceName      string
}

SignalRId is a struct representing the Resource ID for a Signal R

func NewSignalRID

func NewSignalRID(subscriptionId string, resourceGroupName string, resourceName string) SignalRId

NewSignalRID returns a new SignalRId struct

func ParseSignalRID

func ParseSignalRID(input string) (*SignalRId, error)

ParseSignalRID parses 'input' into a SignalRId

func ParseSignalRIDInsensitively

func ParseSignalRIDInsensitively(input string) (*SignalRId, error)

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

func (SignalRId) ID

func (id SignalRId) ID() string

ID returns the formatted Signal R ID

func (SignalRId) Segments

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

Segments returns a slice of Resource ID Segments which comprise this Signal R ID

func (SignalRId) String

func (id SignalRId) String() string

String returns a human-readable description of this Signal R ID

type SignalRKeys

type SignalRKeys struct {
	PrimaryConnectionString   *string `json:"primaryConnectionString,omitempty"`
	PrimaryKey                *string `json:"primaryKey,omitempty"`
	SecondaryConnectionString *string `json:"secondaryConnectionString,omitempty"`
	SecondaryKey              *string `json:"secondaryKey,omitempty"`
}

type SignalRNetworkACLs

type SignalRNetworkACLs struct {
	DefaultAction    *ACLAction            `json:"defaultAction,omitempty"`
	PrivateEndpoints *[]PrivateEndpointACL `json:"privateEndpoints,omitempty"`
	PublicNetwork    *NetworkACL           `json:"publicNetwork,omitempty"`
}

type SignalRProperties

type SignalRProperties struct {
	Cors                       *SignalRCorsSettings         `json:"cors,omitempty"`
	DisableAadAuth             *bool                        `json:"disableAadAuth,omitempty"`
	DisableLocalAuth           *bool                        `json:"disableLocalAuth,omitempty"`
	ExternalIP                 *string                      `json:"externalIP,omitempty"`
	Features                   *[]SignalRFeature            `json:"features,omitempty"`
	HostName                   *string                      `json:"hostName,omitempty"`
	HostNamePrefix             *string                      `json:"hostNamePrefix,omitempty"`
	NetworkACLs                *SignalRNetworkACLs          `json:"networkACLs,omitempty"`
	PrivateEndpointConnections *[]PrivateEndpointConnection `json:"privateEndpointConnections,omitempty"`
	ProvisioningState          *ProvisioningState           `json:"provisioningState,omitempty"`
	PublicNetworkAccess        *string                      `json:"publicNetworkAccess,omitempty"`
	PublicPort                 *int64                       `json:"publicPort,omitempty"`
	ResourceLogConfiguration   *ResourceLogConfiguration    `json:"resourceLogConfiguration,omitempty"`
	ServerPort                 *int64                       `json:"serverPort,omitempty"`
	SharedPrivateLinkResources *[]SharedPrivateLinkResource `json:"sharedPrivateLinkResources,omitempty"`
	Tls                        *SignalRTlsSettings          `json:"tls,omitempty"`
	Upstream                   *ServerlessUpstreamSettings  `json:"upstream,omitempty"`
	Version                    *string                      `json:"version,omitempty"`
}

type SignalRRequestType

type SignalRRequestType string
const (
	SignalRRequestTypeClientConnection SignalRRequestType = "ClientConnection"
	SignalRRequestTypeRESTAPI          SignalRRequestType = "RESTAPI"
	SignalRRequestTypeServerConnection SignalRRequestType = "ServerConnection"
	SignalRRequestTypeTrace            SignalRRequestType = "Trace"
)

type SignalRResource

type SignalRResource struct {
	Id         *string                           `json:"id,omitempty"`
	Identity   *identity.SystemOrUserAssignedMap `json:"identity,omitempty"`
	Kind       *ServiceKind                      `json:"kind,omitempty"`
	Location   *string                           `json:"location,omitempty"`
	Name       *string                           `json:"name,omitempty"`
	Properties *SignalRProperties                `json:"properties,omitempty"`
	Sku        *ResourceSku                      `json:"sku,omitempty"`
	SystemData *systemdata.SystemData            `json:"systemData,omitempty"`
	Tags       *map[string]string                `json:"tags,omitempty"`
	Type       *string                           `json:"type,omitempty"`
}

type SignalRResourceOperationPredicate

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

func (SignalRResourceOperationPredicate) Matches

type SignalRSkuTier

type SignalRSkuTier string
const (
	SignalRSkuTierBasic    SignalRSkuTier = "Basic"
	SignalRSkuTierFree     SignalRSkuTier = "Free"
	SignalRSkuTierPremium  SignalRSkuTier = "Premium"
	SignalRSkuTierStandard SignalRSkuTier = "Standard"
)

type SignalRTlsSettings

type SignalRTlsSettings struct {
	ClientCertEnabled *bool `json:"clientCertEnabled,omitempty"`
}

type SignalRUsage

type SignalRUsage struct {
	CurrentValue *int64            `json:"currentValue,omitempty"`
	Id           *string           `json:"id,omitempty"`
	Limit        *int64            `json:"limit,omitempty"`
	Name         *SignalRUsageName `json:"name,omitempty"`
	Unit         *string           `json:"unit,omitempty"`
}

type SignalRUsageName

type SignalRUsageName struct {
	LocalizedValue *string `json:"localizedValue,omitempty"`
	Value          *string `json:"value,omitempty"`
}

type SignalRUsageOperationPredicate

type SignalRUsageOperationPredicate struct {
	CurrentValue *int64
	Id           *string
	Limit        *int64
	Unit         *string
}

func (SignalRUsageOperationPredicate) Matches

type Sku

type Sku struct {
	Capacity     *SkuCapacity `json:"capacity,omitempty"`
	ResourceType *string      `json:"resourceType,omitempty"`
	Sku          *ResourceSku `json:"sku,omitempty"`
}

type SkuCapacity

type SkuCapacity struct {
	AllowedValues *[]int64   `json:"allowedValues,omitempty"`
	Default       *int64     `json:"default,omitempty"`
	Maximum       *int64     `json:"maximum,omitempty"`
	Minimum       *int64     `json:"minimum,omitempty"`
	ScaleType     *ScaleType `json:"scaleType,omitempty"`
}

type SkuList

type SkuList struct {
	NextLink *string `json:"nextLink,omitempty"`
	Value    *[]Sku  `json:"value,omitempty"`
}

type UpdateOperationResponse

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

type UpstreamAuthSettings

type UpstreamAuthSettings struct {
	ManagedIdentity *ManagedIdentitySettings `json:"managedIdentity,omitempty"`
	Type            *UpstreamAuthType        `json:"type,omitempty"`
}

type UpstreamAuthType

type UpstreamAuthType string
const (
	UpstreamAuthTypeManagedIdentity UpstreamAuthType = "ManagedIdentity"
	UpstreamAuthTypeNone            UpstreamAuthType = "None"
)

type UpstreamTemplate

type UpstreamTemplate struct {
	Auth            *UpstreamAuthSettings `json:"auth,omitempty"`
	CategoryPattern *string               `json:"categoryPattern,omitempty"`
	EventPattern    *string               `json:"eventPattern,omitempty"`
	HubPattern      *string               `json:"hubPattern,omitempty"`
	UrlTemplate     string                `json:"urlTemplate"`
}

type UsagesListCompleteResult

type UsagesListCompleteResult struct {
	Items []SignalRUsage
}

type UsagesListOperationResponse

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

func (UsagesListOperationResponse) HasMore

func (r UsagesListOperationResponse) HasMore() bool

func (UsagesListOperationResponse) LoadMore

Source Files

Jump to

Keyboard shortcuts

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