signalr

package
v0.20220831.1083255 Latest Latest
Warning

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

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

README

github.com/hashicorp/go-azure-sdk/resource-manager/signalr/2022-02-01/signalr Documentation

The signalr SDK allows for interaction with the Azure Resource Manager Service signalr (API Version 2022-02-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/2022-02-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.CustomCertificatesCreateOrUpdate

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

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


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

Example Usage: SignalRClient.CustomCertificatesDelete

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

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

Example Usage: SignalRClient.CustomCertificatesGet

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

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

Example Usage: SignalRClient.CustomCertificatesList

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

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

Example Usage: SignalRClient.CustomDomainsCreateOrUpdate

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

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


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

Example Usage: SignalRClient.CustomDomainsDelete

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

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

Example Usage: SignalRClient.CustomDomainsGet

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

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

Example Usage: SignalRClient.CustomDomainsList

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

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

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 ValidateCustomCertificateID 

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

ValidateCustomCertificateID checks that 'input' can be parsed as a Custom Certificate ID

func ValidateCustomDomainID 

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

ValidateCustomDomainID checks that 'input' can be parsed as a Custom Domain ID

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 CustomCertificate 

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

type CustomCertificateId 

type CustomCertificateId struct {
	SubscriptionId    string
	ResourceGroupName string
	ResourceName      string
	CertificateName   string
}

CustomCertificateId is a struct representing the Resource ID for a Custom Certificate

func NewCustomCertificateID 

func NewCustomCertificateID(subscriptionId string, resourceGroupName string, resourceName string, certificateName string) CustomCertificateId

NewCustomCertificateID returns a new CustomCertificateId struct

func ParseCustomCertificateID 

func ParseCustomCertificateID(input string) (*CustomCertificateId, error)

ParseCustomCertificateID parses 'input' into a CustomCertificateId

func ParseCustomCertificateIDInsensitively 

func ParseCustomCertificateIDInsensitively(input string) (*CustomCertificateId, error)

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

func (CustomCertificateId) ID 

func (id CustomCertificateId) ID() string

ID returns the formatted Custom Certificate ID

func (CustomCertificateId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Custom Certificate ID

func (CustomCertificateId) String 

func (id CustomCertificateId) String() string

String returns a human-readable description of this Custom Certificate ID

type CustomCertificateOperationPredicate 

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

func (CustomCertificateOperationPredicate) Matches 

func (p CustomCertificateOperationPredicate) Matches(input CustomCertificate) bool

type CustomCertificateProperties 

type CustomCertificateProperties struct {
	KeyVaultBaseUri       string             `json:"keyVaultBaseUri"`
	KeyVaultSecretName    string             `json:"keyVaultSecretName"`
	KeyVaultSecretVersion *string            `json:"keyVaultSecretVersion,omitempty"`
	ProvisioningState     *ProvisioningState `json:"provisioningState,omitempty"`
}

type CustomCertificatesCreateOrUpdateOperationResponse 

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

type CustomCertificatesDeleteOperationResponse 

type CustomCertificatesDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type CustomCertificatesGetOperationResponse 

type CustomCertificatesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *CustomCertificate
}

type CustomCertificatesListCompleteResult 

type CustomCertificatesListCompleteResult struct {
	Items []CustomCertificate
}

type CustomCertificatesListOperationResponse 

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

func (CustomCertificatesListOperationResponse) HasMore 

func (r CustomCertificatesListOperationResponse) HasMore() bool

func (CustomCertificatesListOperationResponse) LoadMore 

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

type CustomDomain 

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

type CustomDomainId 

type CustomDomainId struct {
	SubscriptionId    string
	ResourceGroupName string
	ResourceName      string
	Name              string
}

CustomDomainId is a struct representing the Resource ID for a Custom Domain

func NewCustomDomainID 

func NewCustomDomainID(subscriptionId string, resourceGroupName string, resourceName string, name string) CustomDomainId

NewCustomDomainID returns a new CustomDomainId struct

func ParseCustomDomainID 

func ParseCustomDomainID(input string) (*CustomDomainId, error)

ParseCustomDomainID parses 'input' into a CustomDomainId

func ParseCustomDomainIDInsensitively 

func ParseCustomDomainIDInsensitively(input string) (*CustomDomainId, error)

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

func (CustomDomainId) ID 

func (id CustomDomainId) ID() string

ID returns the formatted Custom Domain ID

func (CustomDomainId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Custom Domain ID

func (CustomDomainId) String 

func (id CustomDomainId) String() string

String returns a human-readable description of this Custom Domain ID

type CustomDomainOperationPredicate 

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

func (CustomDomainOperationPredicate) Matches 

func (p CustomDomainOperationPredicate) Matches(input CustomDomain) bool

type CustomDomainProperties 

type CustomDomainProperties struct {
	CustomCertificate ResourceReference  `json:"customCertificate"`
	DomainName        string             `json:"domainName"`
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty"`
}

type CustomDomainsCreateOrUpdateOperationResponse 

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

type CustomDomainsDeleteOperationResponse 

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

type CustomDomainsGetOperationResponse 

type CustomDomainsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *CustomDomain
}

type CustomDomainsListCompleteResult 

type CustomDomainsListCompleteResult struct {
	Items []CustomDomain
}

type CustomDomainsListOperationResponse 

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

func (CustomDomainsListOperationResponse) HasMore 

func (r CustomDomainsListOperationResponse) HasMore() bool

func (CustomDomainsListOperationResponse) LoadMore 

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

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 (r ListByResourceGroupOperationResponse) HasMore() bool

func (ListByResourceGroupOperationResponse) LoadMore 

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

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 (r ListBySubscriptionOperationResponse) HasMore() bool

func (ListBySubscriptionOperationResponse) LoadMore 

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

type ListKeysOperationResponse 

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

type ListSkusOperationResponse 

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

type LiveTraceCategory 

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

type LiveTraceConfiguration 

type LiveTraceConfiguration struct {
	Categories *[]LiveTraceCategory `json:"categories,omitempty"`
	Enabled    *string              `json:"enabled,omitempty"`
}

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 

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 PrivateEndpointConnectionOperationPredicate 

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

func (PrivateEndpointConnectionOperationPredicate) Matches 

func (p PrivateEndpointConnectionOperationPredicate) Matches(input PrivateEndpointConnection) bool

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 (r PrivateEndpointConnectionsListOperationResponse) HasMore() bool

func (PrivateEndpointConnectionsListOperationResponse) LoadMore 

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

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 

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"`
	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 (r PrivateLinkResourcesListOperationResponse) HasMore() bool

func (PrivateLinkResourcesListOperationResponse) LoadMore 

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

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 ResourceReference 

type ResourceReference struct {
	Id *string `json:"id,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 

func (id SharedPrivateLinkResourceId) ID() string

ID returns the formatted Shared Private Link Resource ID

func (SharedPrivateLinkResourceId) Segments 

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

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 

func (p SharedPrivateLinkResourceOperationPredicate) Matches(input SharedPrivateLinkResource) bool

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 (r SharedPrivateLinkResourcesListOperationResponse) HasMore() bool

func (SharedPrivateLinkResourcesListOperationResponse) LoadMore 

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

type SignalRClient 

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

func NewSignalRClientWithBaseURI 

func NewSignalRClientWithBaseURI(endpoint string) SignalRClient

func (SignalRClient) CheckNameAvailability 

func (c SignalRClient) CheckNameAvailability(ctx context.Context, id LocationId, input NameAvailabilityParameters) (result CheckNameAvailabilityOperationResponse, err error)

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

func (c SignalRClient) CustomCertificatesCreateOrUpdate(ctx context.Context, id CustomCertificateId, input CustomCertificate) (result CustomCertificatesCreateOrUpdateOperationResponse, err error)

CustomCertificatesCreateOrUpdate ...

func (SignalRClient) CustomCertificatesCreateOrUpdateThenPoll 

func (c SignalRClient) CustomCertificatesCreateOrUpdateThenPoll(ctx context.Context, id CustomCertificateId, input CustomCertificate) error

CustomCertificatesCreateOrUpdateThenPoll performs CustomCertificatesCreateOrUpdate then polls until it's completed

func (SignalRClient) CustomCertificatesDelete 

func (c SignalRClient) CustomCertificatesDelete(ctx context.Context, id CustomCertificateId) (result CustomCertificatesDeleteOperationResponse, err error)

CustomCertificatesDelete ...

func (SignalRClient) CustomCertificatesGet 

func (c SignalRClient) CustomCertificatesGet(ctx context.Context, id CustomCertificateId) (result CustomCertificatesGetOperationResponse, err error)

CustomCertificatesGet ...

func (SignalRClient) CustomCertificatesList 

func (c SignalRClient) CustomCertificatesList(ctx context.Context, id SignalRId) (resp CustomCertificatesListOperationResponse, err error)

CustomCertificatesList ...

func (SignalRClient) CustomCertificatesListComplete 

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

CustomCertificatesListComplete retrieves all of the results into a single object

func (SignalRClient) CustomCertificatesListCompleteMatchingPredicate 

func (c SignalRClient) CustomCertificatesListCompleteMatchingPredicate(ctx context.Context, id SignalRId, predicate CustomCertificateOperationPredicate) (resp CustomCertificatesListCompleteResult, err error)

CustomCertificatesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (SignalRClient) CustomDomainsCreateOrUpdate 

func (c SignalRClient) CustomDomainsCreateOrUpdate(ctx context.Context, id CustomDomainId, input CustomDomain) (result CustomDomainsCreateOrUpdateOperationResponse, err error)

CustomDomainsCreateOrUpdate ...

func (SignalRClient) CustomDomainsCreateOrUpdateThenPoll 

func (c SignalRClient) CustomDomainsCreateOrUpdateThenPoll(ctx context.Context, id CustomDomainId, input CustomDomain) error

CustomDomainsCreateOrUpdateThenPoll performs CustomDomainsCreateOrUpdate then polls until it's completed

func (SignalRClient) CustomDomainsDelete 

func (c SignalRClient) CustomDomainsDelete(ctx context.Context, id CustomDomainId) (result CustomDomainsDeleteOperationResponse, err error)

CustomDomainsDelete ...

func (SignalRClient) CustomDomainsDeleteThenPoll 

func (c SignalRClient) CustomDomainsDeleteThenPoll(ctx context.Context, id CustomDomainId) error

CustomDomainsDeleteThenPoll performs CustomDomainsDelete then polls until it's completed

func (SignalRClient) CustomDomainsGet 

func (c SignalRClient) CustomDomainsGet(ctx context.Context, id CustomDomainId) (result CustomDomainsGetOperationResponse, err error)

CustomDomainsGet ...

func (SignalRClient) CustomDomainsList 

func (c SignalRClient) CustomDomainsList(ctx context.Context, id SignalRId) (resp CustomDomainsListOperationResponse, err error)

CustomDomainsList ...

func (SignalRClient) CustomDomainsListComplete 

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

CustomDomainsListComplete retrieves all of the results into a single object

func (SignalRClient) CustomDomainsListCompleteMatchingPredicate 

func (c SignalRClient) CustomDomainsListCompleteMatchingPredicate(ctx context.Context, id SignalRId, predicate CustomDomainOperationPredicate) (resp CustomDomainsListCompleteResult, err error)

CustomDomainsListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

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 

func (c SignalRClient) ListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (resp ListByResourceGroupOperationResponse, err error)

ListByResourceGroup ...

func (SignalRClient) ListByResourceGroupComplete 

func (c SignalRClient) ListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (ListByResourceGroupCompleteResult, error)

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 

func (c SignalRClient) ListBySubscription(ctx context.Context, id commonids.SubscriptionId) (resp ListBySubscriptionOperationResponse, err error)

ListBySubscription ...

func (SignalRClient) ListBySubscriptionComplete 

func (c SignalRClient) ListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (ListBySubscriptionCompleteResult, error)

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 

func (c SignalRClient) PrivateEndpointConnectionsGet(ctx context.Context, id PrivateEndpointConnectionId) (result PrivateEndpointConnectionsGetOperationResponse, err error)

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 

func (c SignalRClient) PrivateEndpointConnectionsUpdate(ctx context.Context, id PrivateEndpointConnectionId, input PrivateEndpointConnection) (result PrivateEndpointConnectionsUpdateOperationResponse, err error)

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 

func (c SignalRClient) RegenerateKey(ctx context.Context, id SignalRId, input RegenerateKeyParameters) (result RegenerateKeyOperationResponse, err error)

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 

func (c SignalRClient) SharedPrivateLinkResourcesCreateOrUpdate(ctx context.Context, id SharedPrivateLinkResourceId, input SharedPrivateLinkResource) (result SharedPrivateLinkResourcesCreateOrUpdateOperationResponse, err error)

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 

func (c SignalRClient) SharedPrivateLinkResourcesGet(ctx context.Context, id SharedPrivateLinkResourceId) (result SharedPrivateLinkResourcesGetOperationResponse, err error)

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"`
	LiveTraceConfiguration     *LiveTraceConfiguration      `json:"liveTraceConfiguration,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 

func (p SignalRResourceOperationPredicate) Matches(input SignalRResource) bool

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 

func (p SignalRUsageOperationPredicate) Matches(input SignalRUsage) bool

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 

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

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.