eventsubscriptions

package
v0.20240612.1122027 Latest Latest
Warning

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

 Go to latest Published: Jun 12, 2024 License: MPL-2.0 Imports: 16 Imported by: 1

README ¶

github.com/hashicorp/go-azure-sdk/resource-manager/eventgrid/2023-12-15-preview/eventsubscriptions Documentation

The eventsubscriptions SDK allows for interaction with the Azure Resource Manager Service eventgrid (API Version 2023-12-15-preview).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
import "github.com/hashicorp/go-azure-sdk/resource-manager/eventgrid/2023-12-15-preview/eventsubscriptions"

Client Initialization

client := eventsubscriptions.NewEventSubscriptionsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: EventSubscriptionsClient.CreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewScopedEventSubscriptionID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.Delete

ctx := context.TODO()
id := eventsubscriptions.NewScopedEventSubscriptionID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsCreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewDomainEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsDelete

ctx := context.TODO()
id := eventsubscriptions.NewDomainEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsGet

ctx := context.TODO()
id := eventsubscriptions.NewDomainEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsGetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewDomainEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsGetFullUrl

ctx := context.TODO()
id := eventsubscriptions.NewDomainEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsList

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

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

Example Usage: EventSubscriptionsClient.DomainEventSubscriptionsUpdate

ctx := context.TODO()
id := eventsubscriptions.NewDomainEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscriptionUpdateParameters{
	// ...
}


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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsCreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsDelete

ctx := context.TODO()
id := eventsubscriptions.NewTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsGet

ctx := context.TODO()
id := eventsubscriptions.NewTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsGetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsGetFullUrl

ctx := context.TODO()
id := eventsubscriptions.NewTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsList

ctx := context.TODO()
id := eventsubscriptions.NewDomainTopicID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue")

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

Example Usage: EventSubscriptionsClient.DomainTopicEventSubscriptionsUpdate

ctx := context.TODO()
id := eventsubscriptions.NewTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscriptionUpdateParameters{
	// ...
}


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

Example Usage: EventSubscriptionsClient.Get

ctx := context.TODO()
id := eventsubscriptions.NewScopedEventSubscriptionID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group", "eventSubscriptionValue")

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: EventSubscriptionsClient.GetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewScopedEventSubscriptionID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.GetFullUrl

ctx := context.TODO()
id := eventsubscriptions.NewScopedEventSubscriptionID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.ListByDomainTopic

ctx := context.TODO()
id := eventsubscriptions.NewDomainTopicID("12345678-1234-9876-4563-123456789012", "example-resource-group", "domainValue", "topicValue")

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

Example Usage: EventSubscriptionsClient.ListByResource

ctx := context.TODO()
id := commonids.NewScopeID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group")

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

Example Usage: EventSubscriptionsClient.ListGlobalByResourceGroup

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

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

Example Usage: EventSubscriptionsClient.ListGlobalByResourceGroupForTopicType

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

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

Example Usage: EventSubscriptionsClient.ListGlobalBySubscription

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

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

Example Usage: EventSubscriptionsClient.ListGlobalBySubscriptionForTopicType

ctx := context.TODO()
id := eventsubscriptions.NewProviderTopicTypeID("12345678-1234-9876-4563-123456789012", "topicTypeValue")

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

Example Usage: EventSubscriptionsClient.ListRegionalByResourceGroup

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

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

Example Usage: EventSubscriptionsClient.ListRegionalByResourceGroupForTopicType

ctx := context.TODO()
id := eventsubscriptions.NewProviderLocationTopicTypeID("12345678-1234-9876-4563-123456789012", "example-resource-group", "locationValue", "topicTypeValue")

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

Example Usage: EventSubscriptionsClient.ListRegionalBySubscription

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

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

Example Usage: EventSubscriptionsClient.ListRegionalBySubscriptionForTopicType

ctx := context.TODO()
id := eventsubscriptions.NewLocationTopicTypeID("12345678-1234-9876-4563-123456789012", "locationValue", "topicTypeValue")

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

Example Usage: EventSubscriptionsClient.NamespaceTopicEventSubscriptionsCreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewNamespaceTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "namespaceValue", "topicValue", "eventSubscriptionValue")

payload := eventsubscriptions.Subscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.NamespaceTopicEventSubscriptionsDelete

ctx := context.TODO()
id := eventsubscriptions.NewNamespaceTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "namespaceValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.NamespaceTopicEventSubscriptionsGet

ctx := context.TODO()
id := eventsubscriptions.NewNamespaceTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "namespaceValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.NamespaceTopicEventSubscriptionsGetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewNamespaceTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "namespaceValue", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.NamespaceTopicEventSubscriptionsListByNamespaceTopic

ctx := context.TODO()
id := eventsubscriptions.NewNamespaceTopicID("12345678-1234-9876-4563-123456789012", "example-resource-group", "namespaceValue", "topicValue")

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

Example Usage: EventSubscriptionsClient.NamespaceTopicEventSubscriptionsUpdate

ctx := context.TODO()
id := eventsubscriptions.NewNamespaceTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "namespaceValue", "topicValue", "eventSubscriptionValue")

payload := eventsubscriptions.SubscriptionUpdateParameters{
	// ...
}


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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsCreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewPartnerTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "partnerTopicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsDelete

ctx := context.TODO()
id := eventsubscriptions.NewPartnerTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "partnerTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsGet

ctx := context.TODO()
id := eventsubscriptions.NewPartnerTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "partnerTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsGetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewPartnerTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "partnerTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsGetFullUrl

ctx := context.TODO()
id := eventsubscriptions.NewPartnerTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "partnerTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsListByPartnerTopic

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

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

Example Usage: EventSubscriptionsClient.PartnerTopicEventSubscriptionsUpdate

ctx := context.TODO()
id := eventsubscriptions.NewPartnerTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "partnerTopicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscriptionUpdateParameters{
	// ...
}


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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsCreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewSystemTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "systemTopicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsDelete

ctx := context.TODO()
id := eventsubscriptions.NewSystemTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "systemTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsGet

ctx := context.TODO()
id := eventsubscriptions.NewSystemTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "systemTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsGetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewSystemTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "systemTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsGetFullUrl

ctx := context.TODO()
id := eventsubscriptions.NewSystemTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "systemTopicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsListBySystemTopic

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

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

Example Usage: EventSubscriptionsClient.SystemTopicEventSubscriptionsUpdate

ctx := context.TODO()
id := eventsubscriptions.NewSystemTopicEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "systemTopicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscriptionUpdateParameters{
	// ...
}


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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsCreateOrUpdate

ctx := context.TODO()
id := eventsubscriptions.NewEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "topicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscription{
	// ...
}


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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsDelete

ctx := context.TODO()
id := eventsubscriptions.NewEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsGet

ctx := context.TODO()
id := eventsubscriptions.NewEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsGetDeliveryAttributes

ctx := context.TODO()
id := eventsubscriptions.NewEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsGetFullUrl

ctx := context.TODO()
id := eventsubscriptions.NewEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "topicValue", "eventSubscriptionValue")

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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsList

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

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

Example Usage: EventSubscriptionsClient.TopicEventSubscriptionsUpdate

ctx := context.TODO()
id := eventsubscriptions.NewEventSubscriptionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "topicValue", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscriptionUpdateParameters{
	// ...
}


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

Example Usage: EventSubscriptionsClient.Update

ctx := context.TODO()
id := eventsubscriptions.NewScopedEventSubscriptionID("/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/some-resource-group", "eventSubscriptionValue")

payload := eventsubscriptions.EventSubscriptionUpdateParameters{
	// ...
}


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

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func PossibleValuesForAdvancedFilterOperatorType ¶ 

func PossibleValuesForAdvancedFilterOperatorType() []string

func PossibleValuesForDeadLetterEndPointType ¶ 

func PossibleValuesForDeadLetterEndPointType() []string

func PossibleValuesForDeliveryAttributeMappingType ¶ 

func PossibleValuesForDeliveryAttributeMappingType() []string

func PossibleValuesForDeliveryMode ¶ 

func PossibleValuesForDeliveryMode() []string

func PossibleValuesForDeliverySchema ¶ 

func PossibleValuesForDeliverySchema() []string

func PossibleValuesForEndpointType ¶ 

func PossibleValuesForEndpointType() []string

func PossibleValuesForEventDeliverySchema ¶ 

func PossibleValuesForEventDeliverySchema() []string

func PossibleValuesForEventSubscriptionIdentityType ¶ 

func PossibleValuesForEventSubscriptionIdentityType() []string

func PossibleValuesForEventSubscriptionProvisioningState ¶ 

func PossibleValuesForEventSubscriptionProvisioningState() []string

func PossibleValuesForFilterOperatorType ¶ 

func PossibleValuesForFilterOperatorType() []string

func PossibleValuesForMonitorAlertSeverity ¶ 

func PossibleValuesForMonitorAlertSeverity() []string

func PossibleValuesForSubscriptionProvisioningState ¶ 

func PossibleValuesForSubscriptionProvisioningState() []string

func PossibleValuesForTlsVersion ¶ 

func PossibleValuesForTlsVersion() []string

func ValidateDomainEventSubscriptionID ¶ 

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

ValidateDomainEventSubscriptionID checks that 'input' can be parsed as a Domain Event Subscription ID

func ValidateDomainID ¶ 

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

ValidateDomainID checks that 'input' can be parsed as a Domain ID

func ValidateDomainTopicID ¶ 

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

ValidateDomainTopicID checks that 'input' can be parsed as a Domain Topic ID

func ValidateEventSubscriptionID ¶ 

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

ValidateEventSubscriptionID checks that 'input' can be parsed as a Event Subscription 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 ValidateLocationTopicTypeID ¶ 

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

ValidateLocationTopicTypeID checks that 'input' can be parsed as a Location Topic Type ID

func ValidateNamespaceTopicEventSubscriptionID ¶ 

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

ValidateNamespaceTopicEventSubscriptionID checks that 'input' can be parsed as a Namespace Topic Event Subscription ID

func ValidateNamespaceTopicID ¶ 

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

ValidateNamespaceTopicID checks that 'input' can be parsed as a Namespace Topic ID

func ValidatePartnerTopicEventSubscriptionID ¶ 

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

ValidatePartnerTopicEventSubscriptionID checks that 'input' can be parsed as a Partner Topic Event Subscription ID

func ValidatePartnerTopicID ¶ 

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

ValidatePartnerTopicID checks that 'input' can be parsed as a Partner Topic ID

func ValidateProviderLocationID ¶ 

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

ValidateProviderLocationID checks that 'input' can be parsed as a Provider Location ID

func ValidateProviderLocationTopicTypeID ¶ 

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

ValidateProviderLocationTopicTypeID checks that 'input' can be parsed as a Provider Location Topic Type ID

func ValidateProviderTopicTypeID ¶ 

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

ValidateProviderTopicTypeID checks that 'input' can be parsed as a Provider Topic Type ID

func ValidateResourceGroupProviderTopicTypeID ¶ 

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

ValidateResourceGroupProviderTopicTypeID checks that 'input' can be parsed as a Resource Group Provider Topic Type ID

func ValidateScopedEventSubscriptionID ¶ 

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

ValidateScopedEventSubscriptionID checks that 'input' can be parsed as a Scoped Event Subscription ID

func ValidateSystemTopicEventSubscriptionID ¶ 

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

ValidateSystemTopicEventSubscriptionID checks that 'input' can be parsed as a System Topic Event Subscription ID

func ValidateSystemTopicID ¶ 

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

ValidateSystemTopicID checks that 'input' can be parsed as a System Topic ID

func ValidateTopicEventSubscriptionID ¶ 

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

ValidateTopicEventSubscriptionID checks that 'input' can be parsed as a Topic Event Subscription ID

func ValidateTopicID ¶ 

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

ValidateTopicID checks that 'input' can be parsed as a Topic ID

Types ¶

type AdvancedFilter ¶ 

type AdvancedFilter interface {
}

type AdvancedFilterOperatorType ¶ 

type AdvancedFilterOperatorType string
const (
	AdvancedFilterOperatorTypeBoolEquals                AdvancedFilterOperatorType = "BoolEquals"
	AdvancedFilterOperatorTypeIsNotNull                 AdvancedFilterOperatorType = "IsNotNull"
	AdvancedFilterOperatorTypeIsNullOrUndefined         AdvancedFilterOperatorType = "IsNullOrUndefined"
	AdvancedFilterOperatorTypeNumberGreaterThan         AdvancedFilterOperatorType = "NumberGreaterThan"
	AdvancedFilterOperatorTypeNumberGreaterThanOrEquals AdvancedFilterOperatorType = "NumberGreaterThanOrEquals"
	AdvancedFilterOperatorTypeNumberIn                  AdvancedFilterOperatorType = "NumberIn"
	AdvancedFilterOperatorTypeNumberInRange             AdvancedFilterOperatorType = "NumberInRange"
	AdvancedFilterOperatorTypeNumberLessThan            AdvancedFilterOperatorType = "NumberLessThan"
	AdvancedFilterOperatorTypeNumberLessThanOrEquals    AdvancedFilterOperatorType = "NumberLessThanOrEquals"
	AdvancedFilterOperatorTypeNumberNotIn               AdvancedFilterOperatorType = "NumberNotIn"
	AdvancedFilterOperatorTypeNumberNotInRange          AdvancedFilterOperatorType = "NumberNotInRange"
	AdvancedFilterOperatorTypeStringBeginsWith          AdvancedFilterOperatorType = "StringBeginsWith"
	AdvancedFilterOperatorTypeStringContains            AdvancedFilterOperatorType = "StringContains"
	AdvancedFilterOperatorTypeStringEndsWith            AdvancedFilterOperatorType = "StringEndsWith"
	AdvancedFilterOperatorTypeStringIn                  AdvancedFilterOperatorType = "StringIn"
	AdvancedFilterOperatorTypeStringNotBeginsWith       AdvancedFilterOperatorType = "StringNotBeginsWith"
	AdvancedFilterOperatorTypeStringNotContains         AdvancedFilterOperatorType = "StringNotContains"
	AdvancedFilterOperatorTypeStringNotEndsWith         AdvancedFilterOperatorType = "StringNotEndsWith"
	AdvancedFilterOperatorTypeStringNotIn               AdvancedFilterOperatorType = "StringNotIn"
)

func (*AdvancedFilterOperatorType) UnmarshalJSON ¶ 

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

type AzureFunctionEventSubscriptionDestination ¶ 

type AzureFunctionEventSubscriptionDestination struct {
	Properties *AzureFunctionEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (AzureFunctionEventSubscriptionDestination) MarshalJSON ¶ 

func (s AzureFunctionEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type AzureFunctionEventSubscriptionDestinationProperties ¶ 

type AzureFunctionEventSubscriptionDestinationProperties struct {
	DeliveryAttributeMappings     *[]DeliveryAttributeMapping `json:"deliveryAttributeMappings,omitempty"`
	MaxEventsPerBatch             *int64                      `json:"maxEventsPerBatch,omitempty"`
	PreferredBatchSizeInKilobytes *int64                      `json:"preferredBatchSizeInKilobytes,omitempty"`
	ResourceId                    *string                     `json:"resourceId,omitempty"`
}

func (*AzureFunctionEventSubscriptionDestinationProperties) UnmarshalJSON ¶ 

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

type BoolEqualsAdvancedFilter ¶ 

type BoolEqualsAdvancedFilter struct {
	Value *bool `json:"value,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (BoolEqualsAdvancedFilter) MarshalJSON ¶ 

func (s BoolEqualsAdvancedFilter) MarshalJSON() ([]byte, error)

type BoolEqualsFilter ¶ 

type BoolEqualsFilter struct {
	Value *bool `json:"value,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (BoolEqualsFilter) MarshalJSON ¶ 

func (s BoolEqualsFilter) MarshalJSON() ([]byte, error)

type CreateOrUpdateOperationResponse ¶ 

type CreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DeadLetterDestination ¶ 

type DeadLetterDestination interface {
}

type DeadLetterEndPointType ¶ 

type DeadLetterEndPointType string
const (
	DeadLetterEndPointTypeStorageBlob DeadLetterEndPointType = "StorageBlob"
)

func (*DeadLetterEndPointType) UnmarshalJSON ¶ 

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

type DeadLetterWithResourceIdentity ¶ 

type DeadLetterWithResourceIdentity struct {
	DeadLetterDestination DeadLetterDestination      `json:"deadLetterDestination"`
	Identity              *EventSubscriptionIdentity `json:"identity,omitempty"`
}

func (*DeadLetterWithResourceIdentity) UnmarshalJSON ¶ 

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

type DeleteOperationResponse ¶ 

type DeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type DeliveryAttributeListResult ¶ 

type DeliveryAttributeListResult struct {
	Value *[]DeliveryAttributeMapping `json:"value,omitempty"`
}

func (*DeliveryAttributeListResult) UnmarshalJSON ¶ 

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

type DeliveryAttributeMapping ¶ 

type DeliveryAttributeMapping interface {
}

type DeliveryAttributeMappingType ¶ 

type DeliveryAttributeMappingType string
const (
	DeliveryAttributeMappingTypeDynamic DeliveryAttributeMappingType = "Dynamic"
	DeliveryAttributeMappingTypeStatic  DeliveryAttributeMappingType = "Static"
)

func (*DeliveryAttributeMappingType) UnmarshalJSON ¶ 

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

type DeliveryConfiguration ¶ 

type DeliveryConfiguration struct {
	DeliveryMode *DeliveryMode `json:"deliveryMode,omitempty"`
	Push         *PushInfo     `json:"push,omitempty"`
	Queue        *QueueInfo    `json:"queue,omitempty"`
}

type DeliveryMode ¶ 

type DeliveryMode string
const (
	DeliveryModePush  DeliveryMode = "Push"
	DeliveryModeQueue DeliveryMode = "Queue"
)

func (*DeliveryMode) UnmarshalJSON ¶ 

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

type DeliverySchema ¶ 

type DeliverySchema string
const (
	DeliverySchemaCloudEventSchemaVOneZero DeliverySchema = "CloudEventSchemaV1_0"
)

func (*DeliverySchema) UnmarshalJSON ¶ 

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

type DeliveryWithResourceIdentity ¶ 

type DeliveryWithResourceIdentity struct {
	Destination EventSubscriptionDestination `json:"destination"`
	Identity    *EventSubscriptionIdentity   `json:"identity,omitempty"`
}

func (*DeliveryWithResourceIdentity) UnmarshalJSON ¶ 

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

type DomainEventSubscriptionId ¶ 

type DomainEventSubscriptionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	DomainName            string
	EventSubscriptionName string
}

DomainEventSubscriptionId is a struct representing the Resource ID for a Domain Event Subscription

func NewDomainEventSubscriptionID ¶ 

func NewDomainEventSubscriptionID(subscriptionId string, resourceGroupName string, domainName string, eventSubscriptionName string) DomainEventSubscriptionId

NewDomainEventSubscriptionID returns a new DomainEventSubscriptionId struct

func ParseDomainEventSubscriptionID ¶ 

func ParseDomainEventSubscriptionID(input string) (*DomainEventSubscriptionId, error)

ParseDomainEventSubscriptionID parses 'input' into a DomainEventSubscriptionId

func ParseDomainEventSubscriptionIDInsensitively ¶ 

func ParseDomainEventSubscriptionIDInsensitively(input string) (*DomainEventSubscriptionId, error)

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

func (*DomainEventSubscriptionId) FromParseResult ¶ 

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

func (DomainEventSubscriptionId) ID ¶ 

func (id DomainEventSubscriptionId) ID() string

ID returns the formatted Domain Event Subscription ID

func (DomainEventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Domain Event Subscription ID

func (DomainEventSubscriptionId) String ¶ 

func (id DomainEventSubscriptionId) String() string

String returns a human-readable description of this Domain Event Subscription ID

type DomainEventSubscriptionsCreateOrUpdateOperationResponse ¶ 

type DomainEventSubscriptionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DomainEventSubscriptionsDeleteOperationResponse ¶ 

type DomainEventSubscriptionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type DomainEventSubscriptionsGetDeliveryAttributesOperationResponse ¶ 

type DomainEventSubscriptionsGetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type DomainEventSubscriptionsGetFullUrlOperationResponse ¶ 

type DomainEventSubscriptionsGetFullUrlOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscriptionFullUrl
}

type DomainEventSubscriptionsGetOperationResponse ¶ 

type DomainEventSubscriptionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DomainEventSubscriptionsListCompleteResult ¶ 

type DomainEventSubscriptionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type DomainEventSubscriptionsListOperationOptions ¶ 

type DomainEventSubscriptionsListOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultDomainEventSubscriptionsListOperationOptions ¶ 

func DefaultDomainEventSubscriptionsListOperationOptions() DomainEventSubscriptionsListOperationOptions

func (DomainEventSubscriptionsListOperationOptions) ToHeaders ¶ 

func (o DomainEventSubscriptionsListOperationOptions) ToHeaders() *client.Headers

func (DomainEventSubscriptionsListOperationOptions) ToOData ¶ 

func (o DomainEventSubscriptionsListOperationOptions) ToOData() *odata.Query

func (DomainEventSubscriptionsListOperationOptions) ToQuery ¶ 

func (o DomainEventSubscriptionsListOperationOptions) ToQuery() *client.QueryParams

type DomainEventSubscriptionsListOperationResponse ¶ 

type DomainEventSubscriptionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type DomainEventSubscriptionsUpdateOperationResponse ¶ 

type DomainEventSubscriptionsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DomainId ¶ 

type DomainId struct {
	SubscriptionId    string
	ResourceGroupName string
	DomainName        string
}

DomainId is a struct representing the Resource ID for a Domain

func NewDomainID ¶ 

func NewDomainID(subscriptionId string, resourceGroupName string, domainName string) DomainId

NewDomainID returns a new DomainId struct

func ParseDomainID ¶ 

func ParseDomainID(input string) (*DomainId, error)

ParseDomainID parses 'input' into a DomainId

func ParseDomainIDInsensitively ¶ 

func ParseDomainIDInsensitively(input string) (*DomainId, error)

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

func (*DomainId) FromParseResult ¶ 

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

func (DomainId) ID ¶ 

func (id DomainId) ID() string

ID returns the formatted Domain ID

func (DomainId) Segments ¶ 

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

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

func (DomainId) String ¶ 

func (id DomainId) String() string

String returns a human-readable description of this Domain ID

type DomainTopicEventSubscriptionsCreateOrUpdateOperationResponse ¶ 

type DomainTopicEventSubscriptionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DomainTopicEventSubscriptionsDeleteOperationResponse ¶ 

type DomainTopicEventSubscriptionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type DomainTopicEventSubscriptionsGetDeliveryAttributesOperationResponse ¶ 

type DomainTopicEventSubscriptionsGetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type DomainTopicEventSubscriptionsGetFullUrlOperationResponse ¶ 

type DomainTopicEventSubscriptionsGetFullUrlOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscriptionFullUrl
}

type DomainTopicEventSubscriptionsGetOperationResponse ¶ 

type DomainTopicEventSubscriptionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DomainTopicEventSubscriptionsListCompleteResult ¶ 

type DomainTopicEventSubscriptionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type DomainTopicEventSubscriptionsListOperationOptions ¶ 

type DomainTopicEventSubscriptionsListOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultDomainTopicEventSubscriptionsListOperationOptions ¶ 

func DefaultDomainTopicEventSubscriptionsListOperationOptions() DomainTopicEventSubscriptionsListOperationOptions

func (DomainTopicEventSubscriptionsListOperationOptions) ToHeaders ¶ 

func (o DomainTopicEventSubscriptionsListOperationOptions) ToHeaders() *client.Headers

func (DomainTopicEventSubscriptionsListOperationOptions) ToOData ¶ 

func (o DomainTopicEventSubscriptionsListOperationOptions) ToOData() *odata.Query

func (DomainTopicEventSubscriptionsListOperationOptions) ToQuery ¶ 

func (o DomainTopicEventSubscriptionsListOperationOptions) ToQuery() *client.QueryParams

type DomainTopicEventSubscriptionsListOperationResponse ¶ 

type DomainTopicEventSubscriptionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type DomainTopicEventSubscriptionsUpdateOperationResponse ¶ 

type DomainTopicEventSubscriptionsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type DomainTopicId ¶ 

type DomainTopicId struct {
	SubscriptionId    string
	ResourceGroupName string
	DomainName        string
	TopicName         string
}

DomainTopicId is a struct representing the Resource ID for a Domain Topic

func NewDomainTopicID ¶ 

func NewDomainTopicID(subscriptionId string, resourceGroupName string, domainName string, topicName string) DomainTopicId

NewDomainTopicID returns a new DomainTopicId struct

func ParseDomainTopicID ¶ 

func ParseDomainTopicID(input string) (*DomainTopicId, error)

ParseDomainTopicID parses 'input' into a DomainTopicId

func ParseDomainTopicIDInsensitively ¶ 

func ParseDomainTopicIDInsensitively(input string) (*DomainTopicId, error)

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

func (*DomainTopicId) FromParseResult ¶ 

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

func (DomainTopicId) ID ¶ 

func (id DomainTopicId) ID() string

ID returns the formatted Domain Topic ID

func (DomainTopicId) Segments ¶ 

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

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

func (DomainTopicId) String ¶ 

func (id DomainTopicId) String() string

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

type DynamicDeliveryAttributeMapping ¶ 

type DynamicDeliveryAttributeMapping struct {
	Properties *DynamicDeliveryAttributeMappingProperties `json:"properties,omitempty"`

	// Fields inherited from DeliveryAttributeMapping
	Name *string `json:"name,omitempty"`
}

func (DynamicDeliveryAttributeMapping) MarshalJSON ¶ 

func (s DynamicDeliveryAttributeMapping) MarshalJSON() ([]byte, error)

type DynamicDeliveryAttributeMappingProperties ¶ 

type DynamicDeliveryAttributeMappingProperties struct {
	SourceField *string `json:"sourceField,omitempty"`
}

type EndpointType ¶ 

type EndpointType string
const (
	EndpointTypeAzureFunction      EndpointType = "AzureFunction"
	EndpointTypeEventHub           EndpointType = "EventHub"
	EndpointTypeHybridConnection   EndpointType = "HybridConnection"
	EndpointTypeMonitorAlert       EndpointType = "MonitorAlert"
	EndpointTypeNamespaceTopic     EndpointType = "NamespaceTopic"
	EndpointTypePartnerDestination EndpointType = "PartnerDestination"
	EndpointTypeServiceBusQueue    EndpointType = "ServiceBusQueue"
	EndpointTypeServiceBusTopic    EndpointType = "ServiceBusTopic"
	EndpointTypeStorageQueue       EndpointType = "StorageQueue"
	EndpointTypeWebHook            EndpointType = "WebHook"
)

func (*EndpointType) UnmarshalJSON ¶ 

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

type EventDeliverySchema ¶ 

type EventDeliverySchema string
const (
	EventDeliverySchemaCloudEventSchemaVOneZero EventDeliverySchema = "CloudEventSchemaV1_0"
	EventDeliverySchemaCustomInputSchema        EventDeliverySchema = "CustomInputSchema"
	EventDeliverySchemaEventGridSchema          EventDeliverySchema = "EventGridSchema"
)

func (*EventDeliverySchema) UnmarshalJSON ¶ 

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

type EventHubEventSubscriptionDestination ¶ 

type EventHubEventSubscriptionDestination struct {
	Properties *EventHubEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (EventHubEventSubscriptionDestination) MarshalJSON ¶ 

func (s EventHubEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type EventHubEventSubscriptionDestinationProperties ¶ 

type EventHubEventSubscriptionDestinationProperties struct {
	DeliveryAttributeMappings *[]DeliveryAttributeMapping `json:"deliveryAttributeMappings,omitempty"`
	ResourceId                *string                     `json:"resourceId,omitempty"`
}

func (*EventHubEventSubscriptionDestinationProperties) UnmarshalJSON ¶ 

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

type EventSubscription ¶ 

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

type EventSubscriptionDestination ¶ 

type EventSubscriptionDestination interface {
}

type EventSubscriptionFilter ¶ 

type EventSubscriptionFilter struct {
	AdvancedFilters                 *[]AdvancedFilter `json:"advancedFilters,omitempty"`
	EnableAdvancedFilteringOnArrays *bool             `json:"enableAdvancedFilteringOnArrays,omitempty"`
	IncludedEventTypes              *[]string         `json:"includedEventTypes,omitempty"`
	IsSubjectCaseSensitive          *bool             `json:"isSubjectCaseSensitive,omitempty"`
	SubjectBeginsWith               *string           `json:"subjectBeginsWith,omitempty"`
	SubjectEndsWith                 *string           `json:"subjectEndsWith,omitempty"`
}

func (*EventSubscriptionFilter) UnmarshalJSON ¶ 

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

type EventSubscriptionFullUrl ¶ 

type EventSubscriptionFullUrl struct {
	EndpointUrl *string `json:"endpointUrl,omitempty"`
}

type EventSubscriptionId ¶ 

type EventSubscriptionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	TopicName             string
	EventSubscriptionName string
}

EventSubscriptionId is a struct representing the Resource ID for a Event Subscription

func NewEventSubscriptionID ¶ 

func NewEventSubscriptionID(subscriptionId string, resourceGroupName string, topicName string, eventSubscriptionName string) EventSubscriptionId

NewEventSubscriptionID returns a new EventSubscriptionId struct

func ParseEventSubscriptionID ¶ 

func ParseEventSubscriptionID(input string) (*EventSubscriptionId, error)

ParseEventSubscriptionID parses 'input' into a EventSubscriptionId

func ParseEventSubscriptionIDInsensitively ¶ 

func ParseEventSubscriptionIDInsensitively(input string) (*EventSubscriptionId, error)

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

func (*EventSubscriptionId) FromParseResult ¶ 

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

func (EventSubscriptionId) ID ¶ 

func (id EventSubscriptionId) ID() string

ID returns the formatted Event Subscription ID

func (EventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Event Subscription ID

func (EventSubscriptionId) String ¶ 

func (id EventSubscriptionId) String() string

String returns a human-readable description of this Event Subscription ID

type EventSubscriptionIdentity ¶ 

type EventSubscriptionIdentity struct {
	Type                 *EventSubscriptionIdentityType `json:"type,omitempty"`
	UserAssignedIdentity *string                        `json:"userAssignedIdentity,omitempty"`
}

type EventSubscriptionIdentityType ¶ 

type EventSubscriptionIdentityType string
const (
	EventSubscriptionIdentityTypeSystemAssigned EventSubscriptionIdentityType = "SystemAssigned"
	EventSubscriptionIdentityTypeUserAssigned   EventSubscriptionIdentityType = "UserAssigned"
)

func (*EventSubscriptionIdentityType) UnmarshalJSON ¶ 

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

type EventSubscriptionOperationPredicate ¶ 

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

func (EventSubscriptionOperationPredicate) Matches ¶ 

func (p EventSubscriptionOperationPredicate) Matches(input EventSubscription) bool

type EventSubscriptionProperties ¶ 

type EventSubscriptionProperties struct {
	DeadLetterDestination          DeadLetterDestination               `json:"deadLetterDestination"`
	DeadLetterWithResourceIdentity *DeadLetterWithResourceIdentity     `json:"deadLetterWithResourceIdentity,omitempty"`
	DeliveryWithResourceIdentity   *DeliveryWithResourceIdentity       `json:"deliveryWithResourceIdentity,omitempty"`
	Destination                    EventSubscriptionDestination        `json:"destination"`
	EventDeliverySchema            *EventDeliverySchema                `json:"eventDeliverySchema,omitempty"`
	ExpirationTimeUtc              *string                             `json:"expirationTimeUtc,omitempty"`
	Filter                         *EventSubscriptionFilter            `json:"filter,omitempty"`
	Labels                         *[]string                           `json:"labels,omitempty"`
	ProvisioningState              *EventSubscriptionProvisioningState `json:"provisioningState,omitempty"`
	RetryPolicy                    *RetryPolicy                        `json:"retryPolicy,omitempty"`
	Topic                          *string                             `json:"topic,omitempty"`
}

func (*EventSubscriptionProperties) GetExpirationTimeUtcAsTime ¶ 

func (o *EventSubscriptionProperties) GetExpirationTimeUtcAsTime() (*time.Time, error)

func (*EventSubscriptionProperties) SetExpirationTimeUtcAsTime ¶ 

func (o *EventSubscriptionProperties) SetExpirationTimeUtcAsTime(input time.Time)

func (*EventSubscriptionProperties) UnmarshalJSON ¶ 

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

type EventSubscriptionProvisioningState ¶ 

type EventSubscriptionProvisioningState string
const (
	EventSubscriptionProvisioningStateAwaitingManualAction EventSubscriptionProvisioningState = "AwaitingManualAction"
	EventSubscriptionProvisioningStateCanceled             EventSubscriptionProvisioningState = "Canceled"
	EventSubscriptionProvisioningStateCreating             EventSubscriptionProvisioningState = "Creating"
	EventSubscriptionProvisioningStateDeleting             EventSubscriptionProvisioningState = "Deleting"
	EventSubscriptionProvisioningStateFailed               EventSubscriptionProvisioningState = "Failed"
	EventSubscriptionProvisioningStateSucceeded            EventSubscriptionProvisioningState = "Succeeded"
	EventSubscriptionProvisioningStateUpdating             EventSubscriptionProvisioningState = "Updating"
)

func (*EventSubscriptionProvisioningState) UnmarshalJSON ¶ 

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

type EventSubscriptionUpdateParameters ¶ 

type EventSubscriptionUpdateParameters struct {
	DeadLetterDestination          DeadLetterDestination           `json:"deadLetterDestination"`
	DeadLetterWithResourceIdentity *DeadLetterWithResourceIdentity `json:"deadLetterWithResourceIdentity,omitempty"`
	DeliveryWithResourceIdentity   *DeliveryWithResourceIdentity   `json:"deliveryWithResourceIdentity,omitempty"`
	Destination                    EventSubscriptionDestination    `json:"destination"`
	EventDeliverySchema            *EventDeliverySchema            `json:"eventDeliverySchema,omitempty"`
	ExpirationTimeUtc              *string                         `json:"expirationTimeUtc,omitempty"`
	Filter                         *EventSubscriptionFilter        `json:"filter,omitempty"`
	Labels                         *[]string                       `json:"labels,omitempty"`
	RetryPolicy                    *RetryPolicy                    `json:"retryPolicy,omitempty"`
}

func (*EventSubscriptionUpdateParameters) GetExpirationTimeUtcAsTime ¶ 

func (o *EventSubscriptionUpdateParameters) GetExpirationTimeUtcAsTime() (*time.Time, error)

func (*EventSubscriptionUpdateParameters) SetExpirationTimeUtcAsTime ¶ 

func (o *EventSubscriptionUpdateParameters) SetExpirationTimeUtcAsTime(input time.Time)

func (*EventSubscriptionUpdateParameters) UnmarshalJSON ¶ 

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

type EventSubscriptionsClient ¶ 

type EventSubscriptionsClient struct {
	Client *resourcemanager.Client
}

func NewEventSubscriptionsClientWithBaseURI ¶ 

func NewEventSubscriptionsClientWithBaseURI(sdkApi sdkEnv.Api) (*EventSubscriptionsClient, error)

func (EventSubscriptionsClient) CreateOrUpdate ¶ 

func (c EventSubscriptionsClient) CreateOrUpdate(ctx context.Context, id ScopedEventSubscriptionId, input EventSubscription) (result CreateOrUpdateOperationResponse, err error)

CreateOrUpdate ...

func (EventSubscriptionsClient) CreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) CreateOrUpdateThenPoll(ctx context.Context, id ScopedEventSubscriptionId, input EventSubscription) error

CreateOrUpdateThenPoll performs CreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) Delete ¶ 

func (c EventSubscriptionsClient) Delete(ctx context.Context, id ScopedEventSubscriptionId) (result DeleteOperationResponse, err error)

Delete ...

func (EventSubscriptionsClient) DeleteThenPoll ¶ 

func (c EventSubscriptionsClient) DeleteThenPoll(ctx context.Context, id ScopedEventSubscriptionId) error

DeleteThenPoll performs Delete then polls until it's completed

func (EventSubscriptionsClient) DomainEventSubscriptionsCreateOrUpdate ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsCreateOrUpdate(ctx context.Context, id DomainEventSubscriptionId, input EventSubscription) (result DomainEventSubscriptionsCreateOrUpdateOperationResponse, err error)

DomainEventSubscriptionsCreateOrUpdate ...

func (EventSubscriptionsClient) DomainEventSubscriptionsCreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsCreateOrUpdateThenPoll(ctx context.Context, id DomainEventSubscriptionId, input EventSubscription) error

DomainEventSubscriptionsCreateOrUpdateThenPoll performs DomainEventSubscriptionsCreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) DomainEventSubscriptionsDelete ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsDelete(ctx context.Context, id DomainEventSubscriptionId) (result DomainEventSubscriptionsDeleteOperationResponse, err error)

DomainEventSubscriptionsDelete ...

func (EventSubscriptionsClient) DomainEventSubscriptionsDeleteThenPoll ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsDeleteThenPoll(ctx context.Context, id DomainEventSubscriptionId) error

DomainEventSubscriptionsDeleteThenPoll performs DomainEventSubscriptionsDelete then polls until it's completed

func (EventSubscriptionsClient) DomainEventSubscriptionsGet ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsGet(ctx context.Context, id DomainEventSubscriptionId) (result DomainEventSubscriptionsGetOperationResponse, err error)

DomainEventSubscriptionsGet ...

func (EventSubscriptionsClient) DomainEventSubscriptionsGetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsGetDeliveryAttributes(ctx context.Context, id DomainEventSubscriptionId) (result DomainEventSubscriptionsGetDeliveryAttributesOperationResponse, err error)

DomainEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) DomainEventSubscriptionsGetFullUrl ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsGetFullUrl(ctx context.Context, id DomainEventSubscriptionId) (result DomainEventSubscriptionsGetFullUrlOperationResponse, err error)

DomainEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) DomainEventSubscriptionsList ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsList(ctx context.Context, id DomainId, options DomainEventSubscriptionsListOperationOptions) (result DomainEventSubscriptionsListOperationResponse, err error)

DomainEventSubscriptionsList ...

func (EventSubscriptionsClient) DomainEventSubscriptionsListComplete ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsListComplete(ctx context.Context, id DomainId, options DomainEventSubscriptionsListOperationOptions) (DomainEventSubscriptionsListCompleteResult, error)

DomainEventSubscriptionsListComplete retrieves all the results into a single object

func (EventSubscriptionsClient) DomainEventSubscriptionsListCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsListCompleteMatchingPredicate(ctx context.Context, id DomainId, options DomainEventSubscriptionsListOperationOptions, predicate EventSubscriptionOperationPredicate) (result DomainEventSubscriptionsListCompleteResult, err error)

DomainEventSubscriptionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) DomainEventSubscriptionsUpdate ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsUpdate(ctx context.Context, id DomainEventSubscriptionId, input EventSubscriptionUpdateParameters) (result DomainEventSubscriptionsUpdateOperationResponse, err error)

DomainEventSubscriptionsUpdate ...

func (EventSubscriptionsClient) DomainEventSubscriptionsUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) DomainEventSubscriptionsUpdateThenPoll(ctx context.Context, id DomainEventSubscriptionId, input EventSubscriptionUpdateParameters) error

DomainEventSubscriptionsUpdateThenPoll performs DomainEventSubscriptionsUpdate then polls until it's completed

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsCreateOrUpdate ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsCreateOrUpdate(ctx context.Context, id TopicEventSubscriptionId, input EventSubscription) (result DomainTopicEventSubscriptionsCreateOrUpdateOperationResponse, err error)

DomainTopicEventSubscriptionsCreateOrUpdate ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsCreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsCreateOrUpdateThenPoll(ctx context.Context, id TopicEventSubscriptionId, input EventSubscription) error

DomainTopicEventSubscriptionsCreateOrUpdateThenPoll performs DomainTopicEventSubscriptionsCreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsDelete ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsDelete(ctx context.Context, id TopicEventSubscriptionId) (result DomainTopicEventSubscriptionsDeleteOperationResponse, err error)

DomainTopicEventSubscriptionsDelete ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsDeleteThenPoll ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsDeleteThenPoll(ctx context.Context, id TopicEventSubscriptionId) error

DomainTopicEventSubscriptionsDeleteThenPoll performs DomainTopicEventSubscriptionsDelete then polls until it's completed

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsGet ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsGet(ctx context.Context, id TopicEventSubscriptionId) (result DomainTopicEventSubscriptionsGetOperationResponse, err error)

DomainTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsGetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsGetDeliveryAttributes(ctx context.Context, id TopicEventSubscriptionId) (result DomainTopicEventSubscriptionsGetDeliveryAttributesOperationResponse, err error)

DomainTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsGetFullUrl ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsGetFullUrl(ctx context.Context, id TopicEventSubscriptionId) (result DomainTopicEventSubscriptionsGetFullUrlOperationResponse, err error)

DomainTopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsList ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsList(ctx context.Context, id DomainTopicId, options DomainTopicEventSubscriptionsListOperationOptions) (result DomainTopicEventSubscriptionsListOperationResponse, err error)

DomainTopicEventSubscriptionsList ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsListComplete ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsListComplete(ctx context.Context, id DomainTopicId, options DomainTopicEventSubscriptionsListOperationOptions) (DomainTopicEventSubscriptionsListCompleteResult, error)

DomainTopicEventSubscriptionsListComplete retrieves all the results into a single object

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsListCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsListCompleteMatchingPredicate(ctx context.Context, id DomainTopicId, options DomainTopicEventSubscriptionsListOperationOptions, predicate EventSubscriptionOperationPredicate) (result DomainTopicEventSubscriptionsListCompleteResult, err error)

DomainTopicEventSubscriptionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsUpdate ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsUpdate(ctx context.Context, id TopicEventSubscriptionId, input EventSubscriptionUpdateParameters) (result DomainTopicEventSubscriptionsUpdateOperationResponse, err error)

DomainTopicEventSubscriptionsUpdate ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) DomainTopicEventSubscriptionsUpdateThenPoll(ctx context.Context, id TopicEventSubscriptionId, input EventSubscriptionUpdateParameters) error

DomainTopicEventSubscriptionsUpdateThenPoll performs DomainTopicEventSubscriptionsUpdate then polls until it's completed

func (EventSubscriptionsClient) Get ¶ 

func (c EventSubscriptionsClient) Get(ctx context.Context, id ScopedEventSubscriptionId) (result GetOperationResponse, err error)

Get ...

func (EventSubscriptionsClient) GetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) GetDeliveryAttributes(ctx context.Context, id ScopedEventSubscriptionId) (result GetDeliveryAttributesOperationResponse, err error)

GetDeliveryAttributes ...

func (EventSubscriptionsClient) GetFullUrl ¶ 

func (c EventSubscriptionsClient) GetFullUrl(ctx context.Context, id ScopedEventSubscriptionId) (result GetFullUrlOperationResponse, err error)

GetFullUrl ...

func (EventSubscriptionsClient) ListByDomainTopic ¶ 

func (c EventSubscriptionsClient) ListByDomainTopic(ctx context.Context, id DomainTopicId, options ListByDomainTopicOperationOptions) (result ListByDomainTopicOperationResponse, err error)

ListByDomainTopic ...

func (EventSubscriptionsClient) ListByDomainTopicComplete ¶ 

func (c EventSubscriptionsClient) ListByDomainTopicComplete(ctx context.Context, id DomainTopicId, options ListByDomainTopicOperationOptions) (ListByDomainTopicCompleteResult, error)

ListByDomainTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListByDomainTopicCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListByDomainTopicCompleteMatchingPredicate(ctx context.Context, id DomainTopicId, options ListByDomainTopicOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListByDomainTopicCompleteResult, err error)

ListByDomainTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListByResource ¶ 

func (c EventSubscriptionsClient) ListByResource(ctx context.Context, id commonids.ScopeId, options ListByResourceOperationOptions) (result ListByResourceOperationResponse, err error)

ListByResource ...

func (EventSubscriptionsClient) ListByResourceComplete ¶ 

func (c EventSubscriptionsClient) ListByResourceComplete(ctx context.Context, id commonids.ScopeId, options ListByResourceOperationOptions) (ListByResourceCompleteResult, error)

ListByResourceComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListByResourceCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListByResourceCompleteMatchingPredicate(ctx context.Context, id commonids.ScopeId, options ListByResourceOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListByResourceCompleteResult, err error)

ListByResourceCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalByResourceGroup ¶ 

func (c EventSubscriptionsClient) ListGlobalByResourceGroup(ctx context.Context, id commonids.ResourceGroupId, options ListGlobalByResourceGroupOperationOptions) (result ListGlobalByResourceGroupOperationResponse, err error)

ListGlobalByResourceGroup ...

func (EventSubscriptionsClient) ListGlobalByResourceGroupComplete ¶ 

func (c EventSubscriptionsClient) ListGlobalByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId, options ListGlobalByResourceGroupOperationOptions) (ListGlobalByResourceGroupCompleteResult, error)

ListGlobalByResourceGroupComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalByResourceGroupCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListGlobalByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, options ListGlobalByResourceGroupOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListGlobalByResourceGroupCompleteResult, err error)

ListGlobalByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalByResourceGroupForTopicType ¶ 

func (c EventSubscriptionsClient) ListGlobalByResourceGroupForTopicType(ctx context.Context, id ResourceGroupProviderTopicTypeId, options ListGlobalByResourceGroupForTopicTypeOperationOptions) (result ListGlobalByResourceGroupForTopicTypeOperationResponse, err error)

ListGlobalByResourceGroupForTopicType ...

func (EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeComplete ¶ 

func (c EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeComplete(ctx context.Context, id ResourceGroupProviderTopicTypeId, options ListGlobalByResourceGroupForTopicTypeOperationOptions) (ListGlobalByResourceGroupForTopicTypeCompleteResult, error)

ListGlobalByResourceGroupForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeCompleteMatchingPredicate(ctx context.Context, id ResourceGroupProviderTopicTypeId, options ListGlobalByResourceGroupForTopicTypeOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListGlobalByResourceGroupForTopicTypeCompleteResult, err error)

ListGlobalByResourceGroupForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalBySubscription ¶ 

func (c EventSubscriptionsClient) ListGlobalBySubscription(ctx context.Context, id commonids.SubscriptionId, options ListGlobalBySubscriptionOperationOptions) (result ListGlobalBySubscriptionOperationResponse, err error)

ListGlobalBySubscription ...

func (EventSubscriptionsClient) ListGlobalBySubscriptionComplete ¶ 

func (c EventSubscriptionsClient) ListGlobalBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId, options ListGlobalBySubscriptionOperationOptions) (ListGlobalBySubscriptionCompleteResult, error)

ListGlobalBySubscriptionComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalBySubscriptionCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListGlobalBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, options ListGlobalBySubscriptionOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListGlobalBySubscriptionCompleteResult, err error)

ListGlobalBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalBySubscriptionForTopicType ¶ 

func (c EventSubscriptionsClient) ListGlobalBySubscriptionForTopicType(ctx context.Context, id ProviderTopicTypeId, options ListGlobalBySubscriptionForTopicTypeOperationOptions) (result ListGlobalBySubscriptionForTopicTypeOperationResponse, err error)

ListGlobalBySubscriptionForTopicType ...

func (EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeComplete ¶ 

func (c EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeComplete(ctx context.Context, id ProviderTopicTypeId, options ListGlobalBySubscriptionForTopicTypeOperationOptions) (ListGlobalBySubscriptionForTopicTypeCompleteResult, error)

ListGlobalBySubscriptionForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeCompleteMatchingPredicate(ctx context.Context, id ProviderTopicTypeId, options ListGlobalBySubscriptionForTopicTypeOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListGlobalBySubscriptionForTopicTypeCompleteResult, err error)

ListGlobalBySubscriptionForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalByResourceGroup ¶ 

func (c EventSubscriptionsClient) ListRegionalByResourceGroup(ctx context.Context, id ProviderLocationId, options ListRegionalByResourceGroupOperationOptions) (result ListRegionalByResourceGroupOperationResponse, err error)

ListRegionalByResourceGroup ...

func (EventSubscriptionsClient) ListRegionalByResourceGroupComplete ¶ 

func (c EventSubscriptionsClient) ListRegionalByResourceGroupComplete(ctx context.Context, id ProviderLocationId, options ListRegionalByResourceGroupOperationOptions) (ListRegionalByResourceGroupCompleteResult, error)

ListRegionalByResourceGroupComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalByResourceGroupCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListRegionalByResourceGroupCompleteMatchingPredicate(ctx context.Context, id ProviderLocationId, options ListRegionalByResourceGroupOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListRegionalByResourceGroupCompleteResult, err error)

ListRegionalByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalByResourceGroupForTopicType ¶ 

func (c EventSubscriptionsClient) ListRegionalByResourceGroupForTopicType(ctx context.Context, id ProviderLocationTopicTypeId, options ListRegionalByResourceGroupForTopicTypeOperationOptions) (result ListRegionalByResourceGroupForTopicTypeOperationResponse, err error)

ListRegionalByResourceGroupForTopicType ...

func (EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeComplete ¶ 

func (c EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeComplete(ctx context.Context, id ProviderLocationTopicTypeId, options ListRegionalByResourceGroupForTopicTypeOperationOptions) (ListRegionalByResourceGroupForTopicTypeCompleteResult, error)

ListRegionalByResourceGroupForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeCompleteMatchingPredicate(ctx context.Context, id ProviderLocationTopicTypeId, options ListRegionalByResourceGroupForTopicTypeOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListRegionalByResourceGroupForTopicTypeCompleteResult, err error)

ListRegionalByResourceGroupForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalBySubscription ¶ 

func (c EventSubscriptionsClient) ListRegionalBySubscription(ctx context.Context, id LocationId, options ListRegionalBySubscriptionOperationOptions) (result ListRegionalBySubscriptionOperationResponse, err error)

ListRegionalBySubscription ...

func (EventSubscriptionsClient) ListRegionalBySubscriptionComplete ¶ 

func (c EventSubscriptionsClient) ListRegionalBySubscriptionComplete(ctx context.Context, id LocationId, options ListRegionalBySubscriptionOperationOptions) (ListRegionalBySubscriptionCompleteResult, error)

ListRegionalBySubscriptionComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalBySubscriptionCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListRegionalBySubscriptionCompleteMatchingPredicate(ctx context.Context, id LocationId, options ListRegionalBySubscriptionOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListRegionalBySubscriptionCompleteResult, err error)

ListRegionalBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalBySubscriptionForTopicType ¶ 

func (c EventSubscriptionsClient) ListRegionalBySubscriptionForTopicType(ctx context.Context, id LocationTopicTypeId, options ListRegionalBySubscriptionForTopicTypeOperationOptions) (result ListRegionalBySubscriptionForTopicTypeOperationResponse, err error)

ListRegionalBySubscriptionForTopicType ...

func (EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeComplete ¶ 

func (c EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeComplete(ctx context.Context, id LocationTopicTypeId, options ListRegionalBySubscriptionForTopicTypeOperationOptions) (ListRegionalBySubscriptionForTopicTypeCompleteResult, error)

ListRegionalBySubscriptionForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeCompleteMatchingPredicate(ctx context.Context, id LocationTopicTypeId, options ListRegionalBySubscriptionForTopicTypeOperationOptions, predicate EventSubscriptionOperationPredicate) (result ListRegionalBySubscriptionForTopicTypeCompleteResult, err error)

ListRegionalBySubscriptionForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsCreateOrUpdate ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsCreateOrUpdate(ctx context.Context, id NamespaceTopicEventSubscriptionId, input Subscription) (result NamespaceTopicEventSubscriptionsCreateOrUpdateOperationResponse, err error)

NamespaceTopicEventSubscriptionsCreateOrUpdate ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsCreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsCreateOrUpdateThenPoll(ctx context.Context, id NamespaceTopicEventSubscriptionId, input Subscription) error

NamespaceTopicEventSubscriptionsCreateOrUpdateThenPoll performs NamespaceTopicEventSubscriptionsCreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsDelete ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsDelete(ctx context.Context, id NamespaceTopicEventSubscriptionId) (result NamespaceTopicEventSubscriptionsDeleteOperationResponse, err error)

NamespaceTopicEventSubscriptionsDelete ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsDeleteThenPoll ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsDeleteThenPoll(ctx context.Context, id NamespaceTopicEventSubscriptionId) error

NamespaceTopicEventSubscriptionsDeleteThenPoll performs NamespaceTopicEventSubscriptionsDelete then polls until it's completed

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsGet ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsGet(ctx context.Context, id NamespaceTopicEventSubscriptionId) (result NamespaceTopicEventSubscriptionsGetOperationResponse, err error)

NamespaceTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsGetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsGetDeliveryAttributes(ctx context.Context, id NamespaceTopicEventSubscriptionId) (result NamespaceTopicEventSubscriptionsGetDeliveryAttributesOperationResponse, err error)

NamespaceTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopic ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopic(ctx context.Context, id NamespaceTopicId, options NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) (result NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationResponse, err error)

NamespaceTopicEventSubscriptionsListByNamespaceTopic ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopicComplete ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopicComplete(ctx context.Context, id NamespaceTopicId, options NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) (NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteResult, error)

NamespaceTopicEventSubscriptionsListByNamespaceTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteMatchingPredicate(ctx context.Context, id NamespaceTopicId, options NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions, predicate SubscriptionOperationPredicate) (result NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteResult, err error)

NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsUpdate ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsUpdate(ctx context.Context, id NamespaceTopicEventSubscriptionId, input SubscriptionUpdateParameters) (result NamespaceTopicEventSubscriptionsUpdateOperationResponse, err error)

NamespaceTopicEventSubscriptionsUpdate ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) NamespaceTopicEventSubscriptionsUpdateThenPoll(ctx context.Context, id NamespaceTopicEventSubscriptionId, input SubscriptionUpdateParameters) error

NamespaceTopicEventSubscriptionsUpdateThenPoll performs NamespaceTopicEventSubscriptionsUpdate then polls until it's completed

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsCreateOrUpdate ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsCreateOrUpdate(ctx context.Context, id PartnerTopicEventSubscriptionId, input EventSubscription) (result PartnerTopicEventSubscriptionsCreateOrUpdateOperationResponse, err error)

PartnerTopicEventSubscriptionsCreateOrUpdate ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsCreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsCreateOrUpdateThenPoll(ctx context.Context, id PartnerTopicEventSubscriptionId, input EventSubscription) error

PartnerTopicEventSubscriptionsCreateOrUpdateThenPoll performs PartnerTopicEventSubscriptionsCreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsDelete ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsDelete(ctx context.Context, id PartnerTopicEventSubscriptionId) (result PartnerTopicEventSubscriptionsDeleteOperationResponse, err error)

PartnerTopicEventSubscriptionsDelete ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsDeleteThenPoll ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsDeleteThenPoll(ctx context.Context, id PartnerTopicEventSubscriptionId) error

PartnerTopicEventSubscriptionsDeleteThenPoll performs PartnerTopicEventSubscriptionsDelete then polls until it's completed

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsGet ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsGet(ctx context.Context, id PartnerTopicEventSubscriptionId) (result PartnerTopicEventSubscriptionsGetOperationResponse, err error)

PartnerTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsGetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsGetDeliveryAttributes(ctx context.Context, id PartnerTopicEventSubscriptionId) (result PartnerTopicEventSubscriptionsGetDeliveryAttributesOperationResponse, err error)

PartnerTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsGetFullUrl ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsGetFullUrl(ctx context.Context, id PartnerTopicEventSubscriptionId) (result PartnerTopicEventSubscriptionsGetFullUrlOperationResponse, err error)

PartnerTopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopic ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopic(ctx context.Context, id PartnerTopicId, options PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) (result PartnerTopicEventSubscriptionsListByPartnerTopicOperationResponse, err error)

PartnerTopicEventSubscriptionsListByPartnerTopic ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopicComplete ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopicComplete(ctx context.Context, id PartnerTopicId, options PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) (PartnerTopicEventSubscriptionsListByPartnerTopicCompleteResult, error)

PartnerTopicEventSubscriptionsListByPartnerTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopicCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopicCompleteMatchingPredicate(ctx context.Context, id PartnerTopicId, options PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions, predicate EventSubscriptionOperationPredicate) (result PartnerTopicEventSubscriptionsListByPartnerTopicCompleteResult, err error)

PartnerTopicEventSubscriptionsListByPartnerTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsUpdate ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsUpdate(ctx context.Context, id PartnerTopicEventSubscriptionId, input EventSubscriptionUpdateParameters) (result PartnerTopicEventSubscriptionsUpdateOperationResponse, err error)

PartnerTopicEventSubscriptionsUpdate ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) PartnerTopicEventSubscriptionsUpdateThenPoll(ctx context.Context, id PartnerTopicEventSubscriptionId, input EventSubscriptionUpdateParameters) error

PartnerTopicEventSubscriptionsUpdateThenPoll performs PartnerTopicEventSubscriptionsUpdate then polls until it's completed

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsCreateOrUpdate ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsCreateOrUpdate(ctx context.Context, id SystemTopicEventSubscriptionId, input EventSubscription) (result SystemTopicEventSubscriptionsCreateOrUpdateOperationResponse, err error)

SystemTopicEventSubscriptionsCreateOrUpdate ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsCreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsCreateOrUpdateThenPoll(ctx context.Context, id SystemTopicEventSubscriptionId, input EventSubscription) error

SystemTopicEventSubscriptionsCreateOrUpdateThenPoll performs SystemTopicEventSubscriptionsCreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsDelete ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsDelete(ctx context.Context, id SystemTopicEventSubscriptionId) (result SystemTopicEventSubscriptionsDeleteOperationResponse, err error)

SystemTopicEventSubscriptionsDelete ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsDeleteThenPoll ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsDeleteThenPoll(ctx context.Context, id SystemTopicEventSubscriptionId) error

SystemTopicEventSubscriptionsDeleteThenPoll performs SystemTopicEventSubscriptionsDelete then polls until it's completed

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsGet ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsGet(ctx context.Context, id SystemTopicEventSubscriptionId) (result SystemTopicEventSubscriptionsGetOperationResponse, err error)

SystemTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsGetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsGetDeliveryAttributes(ctx context.Context, id SystemTopicEventSubscriptionId) (result SystemTopicEventSubscriptionsGetDeliveryAttributesOperationResponse, err error)

SystemTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsGetFullUrl ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsGetFullUrl(ctx context.Context, id SystemTopicEventSubscriptionId) (result SystemTopicEventSubscriptionsGetFullUrlOperationResponse, err error)

SystemTopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopic ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopic(ctx context.Context, id SystemTopicId, options SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) (result SystemTopicEventSubscriptionsListBySystemTopicOperationResponse, err error)

SystemTopicEventSubscriptionsListBySystemTopic ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopicComplete ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopicComplete(ctx context.Context, id SystemTopicId, options SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) (SystemTopicEventSubscriptionsListBySystemTopicCompleteResult, error)

SystemTopicEventSubscriptionsListBySystemTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopicCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopicCompleteMatchingPredicate(ctx context.Context, id SystemTopicId, options SystemTopicEventSubscriptionsListBySystemTopicOperationOptions, predicate EventSubscriptionOperationPredicate) (result SystemTopicEventSubscriptionsListBySystemTopicCompleteResult, err error)

SystemTopicEventSubscriptionsListBySystemTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsUpdate ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsUpdate(ctx context.Context, id SystemTopicEventSubscriptionId, input EventSubscriptionUpdateParameters) (result SystemTopicEventSubscriptionsUpdateOperationResponse, err error)

SystemTopicEventSubscriptionsUpdate ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) SystemTopicEventSubscriptionsUpdateThenPoll(ctx context.Context, id SystemTopicEventSubscriptionId, input EventSubscriptionUpdateParameters) error

SystemTopicEventSubscriptionsUpdateThenPoll performs SystemTopicEventSubscriptionsUpdate then polls until it's completed

func (EventSubscriptionsClient) TopicEventSubscriptionsCreateOrUpdate ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsCreateOrUpdate(ctx context.Context, id EventSubscriptionId, input EventSubscription) (result TopicEventSubscriptionsCreateOrUpdateOperationResponse, err error)

TopicEventSubscriptionsCreateOrUpdate ...

func (EventSubscriptionsClient) TopicEventSubscriptionsCreateOrUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsCreateOrUpdateThenPoll(ctx context.Context, id EventSubscriptionId, input EventSubscription) error

TopicEventSubscriptionsCreateOrUpdateThenPoll performs TopicEventSubscriptionsCreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) TopicEventSubscriptionsDelete ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsDelete(ctx context.Context, id EventSubscriptionId) (result TopicEventSubscriptionsDeleteOperationResponse, err error)

TopicEventSubscriptionsDelete ...

func (EventSubscriptionsClient) TopicEventSubscriptionsDeleteThenPoll ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsDeleteThenPoll(ctx context.Context, id EventSubscriptionId) error

TopicEventSubscriptionsDeleteThenPoll performs TopicEventSubscriptionsDelete then polls until it's completed

func (EventSubscriptionsClient) TopicEventSubscriptionsGet ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsGet(ctx context.Context, id EventSubscriptionId) (result TopicEventSubscriptionsGetOperationResponse, err error)

TopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) TopicEventSubscriptionsGetDeliveryAttributes ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsGetDeliveryAttributes(ctx context.Context, id EventSubscriptionId) (result TopicEventSubscriptionsGetDeliveryAttributesOperationResponse, err error)

TopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) TopicEventSubscriptionsGetFullUrl ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsGetFullUrl(ctx context.Context, id EventSubscriptionId) (result TopicEventSubscriptionsGetFullUrlOperationResponse, err error)

TopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) TopicEventSubscriptionsList ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsList(ctx context.Context, id TopicId, options TopicEventSubscriptionsListOperationOptions) (result TopicEventSubscriptionsListOperationResponse, err error)

TopicEventSubscriptionsList ...

func (EventSubscriptionsClient) TopicEventSubscriptionsListComplete ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsListComplete(ctx context.Context, id TopicId, options TopicEventSubscriptionsListOperationOptions) (TopicEventSubscriptionsListCompleteResult, error)

TopicEventSubscriptionsListComplete retrieves all the results into a single object

func (EventSubscriptionsClient) TopicEventSubscriptionsListCompleteMatchingPredicate ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsListCompleteMatchingPredicate(ctx context.Context, id TopicId, options TopicEventSubscriptionsListOperationOptions, predicate EventSubscriptionOperationPredicate) (result TopicEventSubscriptionsListCompleteResult, err error)

TopicEventSubscriptionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) TopicEventSubscriptionsUpdate ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsUpdate(ctx context.Context, id EventSubscriptionId, input EventSubscriptionUpdateParameters) (result TopicEventSubscriptionsUpdateOperationResponse, err error)

TopicEventSubscriptionsUpdate ...

func (EventSubscriptionsClient) TopicEventSubscriptionsUpdateThenPoll ¶ 

func (c EventSubscriptionsClient) TopicEventSubscriptionsUpdateThenPoll(ctx context.Context, id EventSubscriptionId, input EventSubscriptionUpdateParameters) error

TopicEventSubscriptionsUpdateThenPoll performs TopicEventSubscriptionsUpdate then polls until it's completed

func (EventSubscriptionsClient) Update ¶ 

func (c EventSubscriptionsClient) Update(ctx context.Context, id ScopedEventSubscriptionId, input EventSubscriptionUpdateParameters) (result UpdateOperationResponse, err error)

Update ...

func (EventSubscriptionsClient) UpdateThenPoll ¶ 

func (c EventSubscriptionsClient) UpdateThenPoll(ctx context.Context, id ScopedEventSubscriptionId, input EventSubscriptionUpdateParameters) error

UpdateThenPoll performs Update then polls until it's completed

type Filter ¶ 

type Filter interface {
}

type FilterOperatorType ¶ 

type FilterOperatorType string
const (
	FilterOperatorTypeBoolEquals                FilterOperatorType = "BoolEquals"
	FilterOperatorTypeIsNotNull                 FilterOperatorType = "IsNotNull"
	FilterOperatorTypeIsNullOrUndefined         FilterOperatorType = "IsNullOrUndefined"
	FilterOperatorTypeNumberGreaterThan         FilterOperatorType = "NumberGreaterThan"
	FilterOperatorTypeNumberGreaterThanOrEquals FilterOperatorType = "NumberGreaterThanOrEquals"
	FilterOperatorTypeNumberIn                  FilterOperatorType = "NumberIn"
	FilterOperatorTypeNumberInRange             FilterOperatorType = "NumberInRange"
	FilterOperatorTypeNumberLessThan            FilterOperatorType = "NumberLessThan"
	FilterOperatorTypeNumberLessThanOrEquals    FilterOperatorType = "NumberLessThanOrEquals"
	FilterOperatorTypeNumberNotIn               FilterOperatorType = "NumberNotIn"
	FilterOperatorTypeNumberNotInRange          FilterOperatorType = "NumberNotInRange"
	FilterOperatorTypeStringBeginsWith          FilterOperatorType = "StringBeginsWith"
	FilterOperatorTypeStringContains            FilterOperatorType = "StringContains"
	FilterOperatorTypeStringEndsWith            FilterOperatorType = "StringEndsWith"
	FilterOperatorTypeStringIn                  FilterOperatorType = "StringIn"
	FilterOperatorTypeStringNotBeginsWith       FilterOperatorType = "StringNotBeginsWith"
	FilterOperatorTypeStringNotContains         FilterOperatorType = "StringNotContains"
	FilterOperatorTypeStringNotEndsWith         FilterOperatorType = "StringNotEndsWith"
	FilterOperatorTypeStringNotIn               FilterOperatorType = "StringNotIn"
)

func (*FilterOperatorType) UnmarshalJSON ¶ 

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

type FiltersConfiguration ¶ 

type FiltersConfiguration struct {
	Filters            *[]Filter `json:"filters,omitempty"`
	IncludedEventTypes *[]string `json:"includedEventTypes,omitempty"`
}

func (*FiltersConfiguration) UnmarshalJSON ¶ 

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

type GetDeliveryAttributesOperationResponse ¶ 

type GetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type GetFullUrlOperationResponse ¶ 

type GetFullUrlOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscriptionFullUrl
}

type GetOperationResponse ¶ 

type GetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type HybridConnectionEventSubscriptionDestination ¶ 

type HybridConnectionEventSubscriptionDestination struct {
	Properties *HybridConnectionEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (HybridConnectionEventSubscriptionDestination) MarshalJSON ¶ 

func (s HybridConnectionEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type HybridConnectionEventSubscriptionDestinationProperties ¶ 

type HybridConnectionEventSubscriptionDestinationProperties struct {
	DeliveryAttributeMappings *[]DeliveryAttributeMapping `json:"deliveryAttributeMappings,omitempty"`
	ResourceId                *string                     `json:"resourceId,omitempty"`
}

func (*HybridConnectionEventSubscriptionDestinationProperties) UnmarshalJSON ¶ 

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

type IsNotNullAdvancedFilter ¶ 

type IsNotNullAdvancedFilter struct {

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (IsNotNullAdvancedFilter) MarshalJSON ¶ 

func (s IsNotNullAdvancedFilter) MarshalJSON() ([]byte, error)

type IsNotNullFilter ¶ 

type IsNotNullFilter struct {

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (IsNotNullFilter) MarshalJSON ¶ 

func (s IsNotNullFilter) MarshalJSON() ([]byte, error)

type IsNullOrUndefinedAdvancedFilter ¶ 

type IsNullOrUndefinedAdvancedFilter struct {

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (IsNullOrUndefinedAdvancedFilter) MarshalJSON ¶ 

func (s IsNullOrUndefinedAdvancedFilter) MarshalJSON() ([]byte, error)

type IsNullOrUndefinedFilter ¶ 

type IsNullOrUndefinedFilter struct {

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (IsNullOrUndefinedFilter) MarshalJSON ¶ 

func (s IsNullOrUndefinedFilter) MarshalJSON() ([]byte, error)

type ListByDomainTopicCompleteResult ¶ 

type ListByDomainTopicCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListByDomainTopicOperationOptions ¶ 

type ListByDomainTopicOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListByDomainTopicOperationOptions ¶ 

func DefaultListByDomainTopicOperationOptions() ListByDomainTopicOperationOptions

func (ListByDomainTopicOperationOptions) ToHeaders ¶ 

func (o ListByDomainTopicOperationOptions) ToHeaders() *client.Headers

func (ListByDomainTopicOperationOptions) ToOData ¶ 

func (o ListByDomainTopicOperationOptions) ToOData() *odata.Query

func (ListByDomainTopicOperationOptions) ToQuery ¶ 

func (o ListByDomainTopicOperationOptions) ToQuery() *client.QueryParams

type ListByDomainTopicOperationResponse ¶ 

type ListByDomainTopicOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListByResourceCompleteResult ¶ 

type ListByResourceCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListByResourceOperationOptions ¶ 

type ListByResourceOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListByResourceOperationOptions ¶ 

func DefaultListByResourceOperationOptions() ListByResourceOperationOptions

func (ListByResourceOperationOptions) ToHeaders ¶ 

func (o ListByResourceOperationOptions) ToHeaders() *client.Headers

func (ListByResourceOperationOptions) ToOData ¶ 

func (o ListByResourceOperationOptions) ToOData() *odata.Query

func (ListByResourceOperationOptions) ToQuery ¶ 

func (o ListByResourceOperationOptions) ToQuery() *client.QueryParams

type ListByResourceOperationResponse ¶ 

type ListByResourceOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListGlobalByResourceGroupCompleteResult ¶ 

type ListGlobalByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListGlobalByResourceGroupForTopicTypeCompleteResult ¶ 

type ListGlobalByResourceGroupForTopicTypeCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListGlobalByResourceGroupForTopicTypeOperationOptions ¶ 

type ListGlobalByResourceGroupForTopicTypeOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListGlobalByResourceGroupForTopicTypeOperationOptions ¶ 

func DefaultListGlobalByResourceGroupForTopicTypeOperationOptions() ListGlobalByResourceGroupForTopicTypeOperationOptions

func (ListGlobalByResourceGroupForTopicTypeOperationOptions) ToHeaders ¶ 

func (o ListGlobalByResourceGroupForTopicTypeOperationOptions) ToHeaders() *client.Headers

func (ListGlobalByResourceGroupForTopicTypeOperationOptions) ToOData ¶ 

func (o ListGlobalByResourceGroupForTopicTypeOperationOptions) ToOData() *odata.Query

func (ListGlobalByResourceGroupForTopicTypeOperationOptions) ToQuery ¶ 

func (o ListGlobalByResourceGroupForTopicTypeOperationOptions) ToQuery() *client.QueryParams

type ListGlobalByResourceGroupForTopicTypeOperationResponse ¶ 

type ListGlobalByResourceGroupForTopicTypeOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListGlobalByResourceGroupOperationOptions ¶ 

type ListGlobalByResourceGroupOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListGlobalByResourceGroupOperationOptions ¶ 

func DefaultListGlobalByResourceGroupOperationOptions() ListGlobalByResourceGroupOperationOptions

func (ListGlobalByResourceGroupOperationOptions) ToHeaders ¶ 

func (o ListGlobalByResourceGroupOperationOptions) ToHeaders() *client.Headers

func (ListGlobalByResourceGroupOperationOptions) ToOData ¶ 

func (o ListGlobalByResourceGroupOperationOptions) ToOData() *odata.Query

func (ListGlobalByResourceGroupOperationOptions) ToQuery ¶ 

func (o ListGlobalByResourceGroupOperationOptions) ToQuery() *client.QueryParams

type ListGlobalByResourceGroupOperationResponse ¶ 

type ListGlobalByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListGlobalBySubscriptionCompleteResult ¶ 

type ListGlobalBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListGlobalBySubscriptionForTopicTypeCompleteResult ¶ 

type ListGlobalBySubscriptionForTopicTypeCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListGlobalBySubscriptionForTopicTypeOperationOptions ¶ 

type ListGlobalBySubscriptionForTopicTypeOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListGlobalBySubscriptionForTopicTypeOperationOptions ¶ 

func DefaultListGlobalBySubscriptionForTopicTypeOperationOptions() ListGlobalBySubscriptionForTopicTypeOperationOptions

func (ListGlobalBySubscriptionForTopicTypeOperationOptions) ToHeaders ¶ 

func (o ListGlobalBySubscriptionForTopicTypeOperationOptions) ToHeaders() *client.Headers

func (ListGlobalBySubscriptionForTopicTypeOperationOptions) ToOData ¶ 

func (o ListGlobalBySubscriptionForTopicTypeOperationOptions) ToOData() *odata.Query

func (ListGlobalBySubscriptionForTopicTypeOperationOptions) ToQuery ¶ 

func (o ListGlobalBySubscriptionForTopicTypeOperationOptions) ToQuery() *client.QueryParams

type ListGlobalBySubscriptionForTopicTypeOperationResponse ¶ 

type ListGlobalBySubscriptionForTopicTypeOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListGlobalBySubscriptionOperationOptions ¶ 

type ListGlobalBySubscriptionOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListGlobalBySubscriptionOperationOptions ¶ 

func DefaultListGlobalBySubscriptionOperationOptions() ListGlobalBySubscriptionOperationOptions

func (ListGlobalBySubscriptionOperationOptions) ToHeaders ¶ 

func (o ListGlobalBySubscriptionOperationOptions) ToHeaders() *client.Headers

func (ListGlobalBySubscriptionOperationOptions) ToOData ¶ 

func (o ListGlobalBySubscriptionOperationOptions) ToOData() *odata.Query

func (ListGlobalBySubscriptionOperationOptions) ToQuery ¶ 

func (o ListGlobalBySubscriptionOperationOptions) ToQuery() *client.QueryParams

type ListGlobalBySubscriptionOperationResponse ¶ 

type ListGlobalBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListRegionalByResourceGroupCompleteResult ¶ 

type ListRegionalByResourceGroupCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListRegionalByResourceGroupForTopicTypeCompleteResult ¶ 

type ListRegionalByResourceGroupForTopicTypeCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListRegionalByResourceGroupForTopicTypeOperationOptions ¶ 

type ListRegionalByResourceGroupForTopicTypeOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListRegionalByResourceGroupForTopicTypeOperationOptions ¶ 

func DefaultListRegionalByResourceGroupForTopicTypeOperationOptions() ListRegionalByResourceGroupForTopicTypeOperationOptions

func (ListRegionalByResourceGroupForTopicTypeOperationOptions) ToHeaders ¶ 

func (o ListRegionalByResourceGroupForTopicTypeOperationOptions) ToHeaders() *client.Headers

func (ListRegionalByResourceGroupForTopicTypeOperationOptions) ToOData ¶ 

func (o ListRegionalByResourceGroupForTopicTypeOperationOptions) ToOData() *odata.Query

func (ListRegionalByResourceGroupForTopicTypeOperationOptions) ToQuery ¶ 

func (o ListRegionalByResourceGroupForTopicTypeOperationOptions) ToQuery() *client.QueryParams

type ListRegionalByResourceGroupForTopicTypeOperationResponse ¶ 

type ListRegionalByResourceGroupForTopicTypeOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListRegionalByResourceGroupOperationOptions ¶ 

type ListRegionalByResourceGroupOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListRegionalByResourceGroupOperationOptions ¶ 

func DefaultListRegionalByResourceGroupOperationOptions() ListRegionalByResourceGroupOperationOptions

func (ListRegionalByResourceGroupOperationOptions) ToHeaders ¶ 

func (o ListRegionalByResourceGroupOperationOptions) ToHeaders() *client.Headers

func (ListRegionalByResourceGroupOperationOptions) ToOData ¶ 

func (o ListRegionalByResourceGroupOperationOptions) ToOData() *odata.Query

func (ListRegionalByResourceGroupOperationOptions) ToQuery ¶ 

func (o ListRegionalByResourceGroupOperationOptions) ToQuery() *client.QueryParams

type ListRegionalByResourceGroupOperationResponse ¶ 

type ListRegionalByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListRegionalBySubscriptionCompleteResult ¶ 

type ListRegionalBySubscriptionCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListRegionalBySubscriptionForTopicTypeCompleteResult ¶ 

type ListRegionalBySubscriptionForTopicTypeCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type ListRegionalBySubscriptionForTopicTypeOperationOptions ¶ 

type ListRegionalBySubscriptionForTopicTypeOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListRegionalBySubscriptionForTopicTypeOperationOptions ¶ 

func DefaultListRegionalBySubscriptionForTopicTypeOperationOptions() ListRegionalBySubscriptionForTopicTypeOperationOptions

func (ListRegionalBySubscriptionForTopicTypeOperationOptions) ToHeaders ¶ 

func (o ListRegionalBySubscriptionForTopicTypeOperationOptions) ToHeaders() *client.Headers

func (ListRegionalBySubscriptionForTopicTypeOperationOptions) ToOData ¶ 

func (o ListRegionalBySubscriptionForTopicTypeOperationOptions) ToOData() *odata.Query

func (ListRegionalBySubscriptionForTopicTypeOperationOptions) ToQuery ¶ 

func (o ListRegionalBySubscriptionForTopicTypeOperationOptions) ToQuery() *client.QueryParams

type ListRegionalBySubscriptionForTopicTypeOperationResponse ¶ 

type ListRegionalBySubscriptionForTopicTypeOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type ListRegionalBySubscriptionOperationOptions ¶ 

type ListRegionalBySubscriptionOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultListRegionalBySubscriptionOperationOptions ¶ 

func DefaultListRegionalBySubscriptionOperationOptions() ListRegionalBySubscriptionOperationOptions

func (ListRegionalBySubscriptionOperationOptions) ToHeaders ¶ 

func (o ListRegionalBySubscriptionOperationOptions) ToHeaders() *client.Headers

func (ListRegionalBySubscriptionOperationOptions) ToOData ¶ 

func (o ListRegionalBySubscriptionOperationOptions) ToOData() *odata.Query

func (ListRegionalBySubscriptionOperationOptions) ToQuery ¶ 

func (o ListRegionalBySubscriptionOperationOptions) ToQuery() *client.QueryParams

type ListRegionalBySubscriptionOperationResponse ¶ 

type ListRegionalBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type LocationId ¶ 

type LocationId struct {
	SubscriptionId string
	LocationName   string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID ¶ 

func NewLocationID(subscriptionId string, locationName string) LocationId

NewLocationID returns a new LocationId struct

func ParseLocationID ¶ 

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

ParseLocationID parses 'input' into a LocationId

func ParseLocationIDInsensitively ¶ 

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

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

func (*LocationId) FromParseResult ¶ 

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

func (LocationId) ID ¶ 

func (id LocationId) ID() string

ID returns the formatted Location ID

func (LocationId) Segments ¶ 

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

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

func (LocationId) String ¶ 

func (id LocationId) String() string

String returns a human-readable description of this Location ID

type LocationTopicTypeId ¶ 

type LocationTopicTypeId struct {
	SubscriptionId string
	LocationName   string
	TopicTypeName  string
}

LocationTopicTypeId is a struct representing the Resource ID for a Location Topic Type

func NewLocationTopicTypeID ¶ 

func NewLocationTopicTypeID(subscriptionId string, locationName string, topicTypeName string) LocationTopicTypeId

NewLocationTopicTypeID returns a new LocationTopicTypeId struct

func ParseLocationTopicTypeID ¶ 

func ParseLocationTopicTypeID(input string) (*LocationTopicTypeId, error)

ParseLocationTopicTypeID parses 'input' into a LocationTopicTypeId

func ParseLocationTopicTypeIDInsensitively ¶ 

func ParseLocationTopicTypeIDInsensitively(input string) (*LocationTopicTypeId, error)

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

func (*LocationTopicTypeId) FromParseResult ¶ 

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

func (LocationTopicTypeId) ID ¶ 

func (id LocationTopicTypeId) ID() string

ID returns the formatted Location Topic Type ID

func (LocationTopicTypeId) Segments ¶ 

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

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

func (LocationTopicTypeId) String ¶ 

func (id LocationTopicTypeId) String() string

String returns a human-readable description of this Location Topic Type ID

type MonitorAlertEventSubscriptionDestination ¶ 

type MonitorAlertEventSubscriptionDestination struct {
	Properties *MonitorAlertEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (MonitorAlertEventSubscriptionDestination) MarshalJSON ¶ 

func (s MonitorAlertEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type MonitorAlertEventSubscriptionDestinationProperties ¶ 

type MonitorAlertEventSubscriptionDestinationProperties struct {
	ActionGroups *[]string             `json:"actionGroups,omitempty"`
	Description  *string               `json:"description,omitempty"`
	Severity     *MonitorAlertSeverity `json:"severity,omitempty"`
}

type MonitorAlertSeverity ¶ 

type MonitorAlertSeverity string
const (
	MonitorAlertSeveritySevFour  MonitorAlertSeverity = "Sev4"
	MonitorAlertSeveritySevOne   MonitorAlertSeverity = "Sev1"
	MonitorAlertSeveritySevThree MonitorAlertSeverity = "Sev3"
	MonitorAlertSeveritySevTwo   MonitorAlertSeverity = "Sev2"
	MonitorAlertSeveritySevZero  MonitorAlertSeverity = "Sev0"
)

func (*MonitorAlertSeverity) UnmarshalJSON ¶ 

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

type NamespaceTopicEventSubscriptionDestination ¶ 

type NamespaceTopicEventSubscriptionDestination struct {
	Properties *NamespaceTopicEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (NamespaceTopicEventSubscriptionDestination) MarshalJSON ¶ 

func (s NamespaceTopicEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type NamespaceTopicEventSubscriptionDestinationProperties ¶ 

type NamespaceTopicEventSubscriptionDestinationProperties struct {
	ResourceId *string `json:"resourceId,omitempty"`
}

type NamespaceTopicEventSubscriptionId ¶ 

type NamespaceTopicEventSubscriptionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	NamespaceName         string
	TopicName             string
	EventSubscriptionName string
}

NamespaceTopicEventSubscriptionId is a struct representing the Resource ID for a Namespace Topic Event Subscription

func NewNamespaceTopicEventSubscriptionID ¶ 

func NewNamespaceTopicEventSubscriptionID(subscriptionId string, resourceGroupName string, namespaceName string, topicName string, eventSubscriptionName string) NamespaceTopicEventSubscriptionId

NewNamespaceTopicEventSubscriptionID returns a new NamespaceTopicEventSubscriptionId struct

func ParseNamespaceTopicEventSubscriptionID ¶ 

func ParseNamespaceTopicEventSubscriptionID(input string) (*NamespaceTopicEventSubscriptionId, error)

ParseNamespaceTopicEventSubscriptionID parses 'input' into a NamespaceTopicEventSubscriptionId

func ParseNamespaceTopicEventSubscriptionIDInsensitively ¶ 

func ParseNamespaceTopicEventSubscriptionIDInsensitively(input string) (*NamespaceTopicEventSubscriptionId, error)

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

func (*NamespaceTopicEventSubscriptionId) FromParseResult ¶ 

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

func (NamespaceTopicEventSubscriptionId) ID ¶ 

func (id NamespaceTopicEventSubscriptionId) ID() string

ID returns the formatted Namespace Topic Event Subscription ID

func (NamespaceTopicEventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Namespace Topic Event Subscription ID

func (NamespaceTopicEventSubscriptionId) String ¶ 

func (id NamespaceTopicEventSubscriptionId) String() string

String returns a human-readable description of this Namespace Topic Event Subscription ID

type NamespaceTopicEventSubscriptionsCreateOrUpdateOperationResponse ¶ 

type NamespaceTopicEventSubscriptionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Subscription
}

type NamespaceTopicEventSubscriptionsDeleteOperationResponse ¶ 

type NamespaceTopicEventSubscriptionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type NamespaceTopicEventSubscriptionsGetDeliveryAttributesOperationResponse ¶ 

type NamespaceTopicEventSubscriptionsGetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type NamespaceTopicEventSubscriptionsGetOperationResponse ¶ 

type NamespaceTopicEventSubscriptionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Subscription
}

type NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteResult ¶ 

type NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []Subscription
}

type NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions ¶ 

type NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultNamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions ¶ 

func DefaultNamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions() NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions

func (NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToHeaders ¶ 

func (o NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToHeaders() *client.Headers

func (NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToOData ¶ 

func (o NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToOData() *odata.Query

func (NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToQuery ¶ 

func (o NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToQuery() *client.QueryParams

type NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationResponse ¶ 

type NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]Subscription
}

type NamespaceTopicEventSubscriptionsUpdateOperationResponse ¶ 

type NamespaceTopicEventSubscriptionsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *Subscription
}

type NamespaceTopicId ¶ 

type NamespaceTopicId struct {
	SubscriptionId    string
	ResourceGroupName string
	NamespaceName     string
	TopicName         string
}

NamespaceTopicId is a struct representing the Resource ID for a Namespace Topic

func NewNamespaceTopicID ¶ 

func NewNamespaceTopicID(subscriptionId string, resourceGroupName string, namespaceName string, topicName string) NamespaceTopicId

NewNamespaceTopicID returns a new NamespaceTopicId struct

func ParseNamespaceTopicID ¶ 

func ParseNamespaceTopicID(input string) (*NamespaceTopicId, error)

ParseNamespaceTopicID parses 'input' into a NamespaceTopicId

func ParseNamespaceTopicIDInsensitively ¶ 

func ParseNamespaceTopicIDInsensitively(input string) (*NamespaceTopicId, error)

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

func (*NamespaceTopicId) FromParseResult ¶ 

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

func (NamespaceTopicId) ID ¶ 

func (id NamespaceTopicId) ID() string

ID returns the formatted Namespace Topic ID

func (NamespaceTopicId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Namespace Topic ID

func (NamespaceTopicId) String ¶ 

func (id NamespaceTopicId) String() string

String returns a human-readable description of this Namespace Topic ID

type NumberGreaterThanAdvancedFilter ¶ 

type NumberGreaterThanAdvancedFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberGreaterThanAdvancedFilter) MarshalJSON ¶ 

func (s NumberGreaterThanAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberGreaterThanFilter ¶ 

type NumberGreaterThanFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberGreaterThanFilter) MarshalJSON ¶ 

func (s NumberGreaterThanFilter) MarshalJSON() ([]byte, error)

type NumberGreaterThanOrEqualsAdvancedFilter ¶ 

type NumberGreaterThanOrEqualsAdvancedFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberGreaterThanOrEqualsAdvancedFilter) MarshalJSON ¶ 

func (s NumberGreaterThanOrEqualsAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberGreaterThanOrEqualsFilter ¶ 

type NumberGreaterThanOrEqualsFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberGreaterThanOrEqualsFilter) MarshalJSON ¶ 

func (s NumberGreaterThanOrEqualsFilter) MarshalJSON() ([]byte, error)

type NumberInAdvancedFilter ¶ 

type NumberInAdvancedFilter struct {
	Values *[]float64 `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberInAdvancedFilter) MarshalJSON ¶ 

func (s NumberInAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberInFilter ¶ 

type NumberInFilter struct {
	Values *[]float64 `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberInFilter) MarshalJSON ¶ 

func (s NumberInFilter) MarshalJSON() ([]byte, error)

type NumberInRangeAdvancedFilter ¶ 

type NumberInRangeAdvancedFilter struct {
	Values *[][]float64 `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberInRangeAdvancedFilter) MarshalJSON ¶ 

func (s NumberInRangeAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberInRangeFilter ¶ 

type NumberInRangeFilter struct {
	Values *[][]float64 `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberInRangeFilter) MarshalJSON ¶ 

func (s NumberInRangeFilter) MarshalJSON() ([]byte, error)

type NumberLessThanAdvancedFilter ¶ 

type NumberLessThanAdvancedFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberLessThanAdvancedFilter) MarshalJSON ¶ 

func (s NumberLessThanAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberLessThanFilter ¶ 

type NumberLessThanFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberLessThanFilter) MarshalJSON ¶ 

func (s NumberLessThanFilter) MarshalJSON() ([]byte, error)

type NumberLessThanOrEqualsAdvancedFilter ¶ 

type NumberLessThanOrEqualsAdvancedFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberLessThanOrEqualsAdvancedFilter) MarshalJSON ¶ 

func (s NumberLessThanOrEqualsAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberLessThanOrEqualsFilter ¶ 

type NumberLessThanOrEqualsFilter struct {
	Value *float64 `json:"value,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberLessThanOrEqualsFilter) MarshalJSON ¶ 

func (s NumberLessThanOrEqualsFilter) MarshalJSON() ([]byte, error)

type NumberNotInAdvancedFilter ¶ 

type NumberNotInAdvancedFilter struct {
	Values *[]float64 `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberNotInAdvancedFilter) MarshalJSON ¶ 

func (s NumberNotInAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberNotInFilter ¶ 

type NumberNotInFilter struct {
	Values *[]float64 `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberNotInFilter) MarshalJSON ¶ 

func (s NumberNotInFilter) MarshalJSON() ([]byte, error)

type NumberNotInRangeAdvancedFilter ¶ 

type NumberNotInRangeAdvancedFilter struct {
	Values *[][]float64 `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (NumberNotInRangeAdvancedFilter) MarshalJSON ¶ 

func (s NumberNotInRangeAdvancedFilter) MarshalJSON() ([]byte, error)

type NumberNotInRangeFilter ¶ 

type NumberNotInRangeFilter struct {
	Values *[][]float64 `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (NumberNotInRangeFilter) MarshalJSON ¶ 

func (s NumberNotInRangeFilter) MarshalJSON() ([]byte, error)

type PartnerEventSubscriptionDestination ¶ 

type PartnerEventSubscriptionDestination struct {
	Properties *PartnerEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (PartnerEventSubscriptionDestination) MarshalJSON ¶ 

func (s PartnerEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type PartnerEventSubscriptionDestinationProperties ¶ 

type PartnerEventSubscriptionDestinationProperties struct {
	ResourceId *string `json:"resourceId,omitempty"`
}

type PartnerTopicEventSubscriptionId ¶ 

type PartnerTopicEventSubscriptionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	PartnerTopicName      string
	EventSubscriptionName string
}

PartnerTopicEventSubscriptionId is a struct representing the Resource ID for a Partner Topic Event Subscription

func NewPartnerTopicEventSubscriptionID ¶ 

func NewPartnerTopicEventSubscriptionID(subscriptionId string, resourceGroupName string, partnerTopicName string, eventSubscriptionName string) PartnerTopicEventSubscriptionId

NewPartnerTopicEventSubscriptionID returns a new PartnerTopicEventSubscriptionId struct

func ParsePartnerTopicEventSubscriptionID ¶ 

func ParsePartnerTopicEventSubscriptionID(input string) (*PartnerTopicEventSubscriptionId, error)

ParsePartnerTopicEventSubscriptionID parses 'input' into a PartnerTopicEventSubscriptionId

func ParsePartnerTopicEventSubscriptionIDInsensitively ¶ 

func ParsePartnerTopicEventSubscriptionIDInsensitively(input string) (*PartnerTopicEventSubscriptionId, error)

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

func (*PartnerTopicEventSubscriptionId) FromParseResult ¶ 

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

func (PartnerTopicEventSubscriptionId) ID ¶ 

func (id PartnerTopicEventSubscriptionId) ID() string

ID returns the formatted Partner Topic Event Subscription ID

func (PartnerTopicEventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Partner Topic Event Subscription ID

func (PartnerTopicEventSubscriptionId) String ¶ 

func (id PartnerTopicEventSubscriptionId) String() string

String returns a human-readable description of this Partner Topic Event Subscription ID

type PartnerTopicEventSubscriptionsCreateOrUpdateOperationResponse ¶ 

type PartnerTopicEventSubscriptionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type PartnerTopicEventSubscriptionsDeleteOperationResponse ¶ 

type PartnerTopicEventSubscriptionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type PartnerTopicEventSubscriptionsGetDeliveryAttributesOperationResponse ¶ 

type PartnerTopicEventSubscriptionsGetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type PartnerTopicEventSubscriptionsGetFullUrlOperationResponse ¶ 

type PartnerTopicEventSubscriptionsGetFullUrlOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscriptionFullUrl
}

type PartnerTopicEventSubscriptionsGetOperationResponse ¶ 

type PartnerTopicEventSubscriptionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type PartnerTopicEventSubscriptionsListByPartnerTopicCompleteResult ¶ 

type PartnerTopicEventSubscriptionsListByPartnerTopicCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions ¶ 

type PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultPartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions ¶ 

func DefaultPartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions() PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions

func (PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToHeaders ¶ 

func (o PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToHeaders() *client.Headers

func (PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToOData ¶ 

func (o PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToOData() *odata.Query

func (PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToQuery ¶ 

func (o PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToQuery() *client.QueryParams

type PartnerTopicEventSubscriptionsListByPartnerTopicOperationResponse ¶ 

type PartnerTopicEventSubscriptionsListByPartnerTopicOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type PartnerTopicEventSubscriptionsUpdateOperationResponse ¶ 

type PartnerTopicEventSubscriptionsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type PartnerTopicId ¶ 

type PartnerTopicId struct {
	SubscriptionId    string
	ResourceGroupName string
	PartnerTopicName  string
}

PartnerTopicId is a struct representing the Resource ID for a Partner Topic

func NewPartnerTopicID ¶ 

func NewPartnerTopicID(subscriptionId string, resourceGroupName string, partnerTopicName string) PartnerTopicId

NewPartnerTopicID returns a new PartnerTopicId struct

func ParsePartnerTopicID ¶ 

func ParsePartnerTopicID(input string) (*PartnerTopicId, error)

ParsePartnerTopicID parses 'input' into a PartnerTopicId

func ParsePartnerTopicIDInsensitively ¶ 

func ParsePartnerTopicIDInsensitively(input string) (*PartnerTopicId, error)

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

func (*PartnerTopicId) FromParseResult ¶ 

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

func (PartnerTopicId) ID ¶ 

func (id PartnerTopicId) ID() string

ID returns the formatted Partner Topic ID

func (PartnerTopicId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Partner Topic ID

func (PartnerTopicId) String ¶ 

func (id PartnerTopicId) String() string

String returns a human-readable description of this Partner Topic ID

type ProviderLocationId ¶ 

type ProviderLocationId struct {
	SubscriptionId    string
	ResourceGroupName string
	LocationName      string
}

ProviderLocationId is a struct representing the Resource ID for a Provider Location

func NewProviderLocationID ¶ 

func NewProviderLocationID(subscriptionId string, resourceGroupName string, locationName string) ProviderLocationId

NewProviderLocationID returns a new ProviderLocationId struct

func ParseProviderLocationID ¶ 

func ParseProviderLocationID(input string) (*ProviderLocationId, error)

ParseProviderLocationID parses 'input' into a ProviderLocationId

func ParseProviderLocationIDInsensitively ¶ 

func ParseProviderLocationIDInsensitively(input string) (*ProviderLocationId, error)

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

func (*ProviderLocationId) FromParseResult ¶ 

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

func (ProviderLocationId) ID ¶ 

func (id ProviderLocationId) ID() string

ID returns the formatted Provider Location ID

func (ProviderLocationId) Segments ¶ 

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

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

func (ProviderLocationId) String ¶ 

func (id ProviderLocationId) String() string

String returns a human-readable description of this Provider Location ID

type ProviderLocationTopicTypeId ¶ 

type ProviderLocationTopicTypeId struct {
	SubscriptionId    string
	ResourceGroupName string
	LocationName      string
	TopicTypeName     string
}

ProviderLocationTopicTypeId is a struct representing the Resource ID for a Provider Location Topic Type

func NewProviderLocationTopicTypeID ¶ 

func NewProviderLocationTopicTypeID(subscriptionId string, resourceGroupName string, locationName string, topicTypeName string) ProviderLocationTopicTypeId

NewProviderLocationTopicTypeID returns a new ProviderLocationTopicTypeId struct

func ParseProviderLocationTopicTypeID ¶ 

func ParseProviderLocationTopicTypeID(input string) (*ProviderLocationTopicTypeId, error)

ParseProviderLocationTopicTypeID parses 'input' into a ProviderLocationTopicTypeId

func ParseProviderLocationTopicTypeIDInsensitively ¶ 

func ParseProviderLocationTopicTypeIDInsensitively(input string) (*ProviderLocationTopicTypeId, error)

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

func (*ProviderLocationTopicTypeId) FromParseResult ¶ 

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

func (ProviderLocationTopicTypeId) ID ¶ 

func (id ProviderLocationTopicTypeId) ID() string

ID returns the formatted Provider Location Topic Type ID

func (ProviderLocationTopicTypeId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Provider Location Topic Type ID

func (ProviderLocationTopicTypeId) String ¶ 

func (id ProviderLocationTopicTypeId) String() string

String returns a human-readable description of this Provider Location Topic Type ID

type ProviderTopicTypeId ¶ 

type ProviderTopicTypeId struct {
	SubscriptionId string
	TopicTypeName  string
}

ProviderTopicTypeId is a struct representing the Resource ID for a Provider Topic Type

func NewProviderTopicTypeID ¶ 

func NewProviderTopicTypeID(subscriptionId string, topicTypeName string) ProviderTopicTypeId

NewProviderTopicTypeID returns a new ProviderTopicTypeId struct

func ParseProviderTopicTypeID ¶ 

func ParseProviderTopicTypeID(input string) (*ProviderTopicTypeId, error)

ParseProviderTopicTypeID parses 'input' into a ProviderTopicTypeId

func ParseProviderTopicTypeIDInsensitively ¶ 

func ParseProviderTopicTypeIDInsensitively(input string) (*ProviderTopicTypeId, error)

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

func (*ProviderTopicTypeId) FromParseResult ¶ 

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

func (ProviderTopicTypeId) ID ¶ 

func (id ProviderTopicTypeId) ID() string

ID returns the formatted Provider Topic Type ID

func (ProviderTopicTypeId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Provider Topic Type ID

func (ProviderTopicTypeId) String ¶ 

func (id ProviderTopicTypeId) String() string

String returns a human-readable description of this Provider Topic Type ID

type PushInfo ¶ 

type PushInfo struct {
	DeadLetterDestinationWithResourceIdentity *DeadLetterWithResourceIdentity `json:"deadLetterDestinationWithResourceIdentity,omitempty"`
	DeliveryWithResourceIdentity              *DeliveryWithResourceIdentity   `json:"deliveryWithResourceIdentity,omitempty"`
	EventTimeToLive                           *string                         `json:"eventTimeToLive,omitempty"`
	MaxDeliveryCount                          *int64                          `json:"maxDeliveryCount,omitempty"`
}

type QueueInfo ¶ 

type QueueInfo struct {
	DeadLetterDestinationWithResourceIdentity *DeadLetterWithResourceIdentity `json:"deadLetterDestinationWithResourceIdentity,omitempty"`
	EventTimeToLive                           *string                         `json:"eventTimeToLive,omitempty"`
	MaxDeliveryCount                          *int64                          `json:"maxDeliveryCount,omitempty"`
	ReceiveLockDurationInSeconds              *int64                          `json:"receiveLockDurationInSeconds,omitempty"`
}

type RawAdvancedFilterImpl ¶ 

type RawAdvancedFilterImpl struct {
	Type   string
	Values map[string]interface{}
}

RawAdvancedFilterImpl is returned when the Discriminated Value doesn't match any of the defined types NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround) and is used only for Deserialization (e.g. this cannot be used as a Request Payload).

type RawDeadLetterDestinationImpl ¶ 

type RawDeadLetterDestinationImpl struct {
	Type   string
	Values map[string]interface{}
}

RawDeadLetterDestinationImpl is returned when the Discriminated Value doesn't match any of the defined types NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround) and is used only for Deserialization (e.g. this cannot be used as a Request Payload).

type RawDeliveryAttributeMappingImpl ¶ 

type RawDeliveryAttributeMappingImpl struct {
	Type   string
	Values map[string]interface{}
}

RawDeliveryAttributeMappingImpl is returned when the Discriminated Value doesn't match any of the defined types NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround) and is used only for Deserialization (e.g. this cannot be used as a Request Payload).

type RawEventSubscriptionDestinationImpl ¶ 

type RawEventSubscriptionDestinationImpl struct {
	Type   string
	Values map[string]interface{}
}

RawEventSubscriptionDestinationImpl is returned when the Discriminated Value doesn't match any of the defined types NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround) and is used only for Deserialization (e.g. this cannot be used as a Request Payload).

type RawFilterImpl ¶ 

type RawFilterImpl struct {
	Type   string
	Values map[string]interface{}
}

RawFilterImpl is returned when the Discriminated Value doesn't match any of the defined types NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround) and is used only for Deserialization (e.g. this cannot be used as a Request Payload).

type ResourceGroupProviderTopicTypeId ¶ 

type ResourceGroupProviderTopicTypeId struct {
	SubscriptionId    string
	ResourceGroupName string
	TopicTypeName     string
}

ResourceGroupProviderTopicTypeId is a struct representing the Resource ID for a Resource Group Provider Topic Type

func NewResourceGroupProviderTopicTypeID ¶ 

func NewResourceGroupProviderTopicTypeID(subscriptionId string, resourceGroupName string, topicTypeName string) ResourceGroupProviderTopicTypeId

NewResourceGroupProviderTopicTypeID returns a new ResourceGroupProviderTopicTypeId struct

func ParseResourceGroupProviderTopicTypeID ¶ 

func ParseResourceGroupProviderTopicTypeID(input string) (*ResourceGroupProviderTopicTypeId, error)

ParseResourceGroupProviderTopicTypeID parses 'input' into a ResourceGroupProviderTopicTypeId

func ParseResourceGroupProviderTopicTypeIDInsensitively ¶ 

func ParseResourceGroupProviderTopicTypeIDInsensitively(input string) (*ResourceGroupProviderTopicTypeId, error)

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

func (*ResourceGroupProviderTopicTypeId) FromParseResult ¶ 

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

func (ResourceGroupProviderTopicTypeId) ID ¶ 

func (id ResourceGroupProviderTopicTypeId) ID() string

ID returns the formatted Resource Group Provider Topic Type ID

func (ResourceGroupProviderTopicTypeId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Resource Group Provider Topic Type ID

func (ResourceGroupProviderTopicTypeId) String ¶ 

func (id ResourceGroupProviderTopicTypeId) String() string

String returns a human-readable description of this Resource Group Provider Topic Type ID

type RetryPolicy ¶ 

type RetryPolicy struct {
	EventTimeToLiveInMinutes *int64 `json:"eventTimeToLiveInMinutes,omitempty"`
	MaxDeliveryAttempts      *int64 `json:"maxDeliveryAttempts,omitempty"`
}

type ScopedEventSubscriptionId ¶ 

type ScopedEventSubscriptionId struct {
	Scope                 string
	EventSubscriptionName string
}

ScopedEventSubscriptionId is a struct representing the Resource ID for a Scoped Event Subscription

func NewScopedEventSubscriptionID ¶ 

func NewScopedEventSubscriptionID(scope string, eventSubscriptionName string) ScopedEventSubscriptionId

NewScopedEventSubscriptionID returns a new ScopedEventSubscriptionId struct

func ParseScopedEventSubscriptionID ¶ 

func ParseScopedEventSubscriptionID(input string) (*ScopedEventSubscriptionId, error)

ParseScopedEventSubscriptionID parses 'input' into a ScopedEventSubscriptionId

func ParseScopedEventSubscriptionIDInsensitively ¶ 

func ParseScopedEventSubscriptionIDInsensitively(input string) (*ScopedEventSubscriptionId, error)

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

func (*ScopedEventSubscriptionId) FromParseResult ¶ 

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

func (ScopedEventSubscriptionId) ID ¶ 

func (id ScopedEventSubscriptionId) ID() string

ID returns the formatted Scoped Event Subscription ID

func (ScopedEventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Scoped Event Subscription ID

func (ScopedEventSubscriptionId) String ¶ 

func (id ScopedEventSubscriptionId) String() string

String returns a human-readable description of this Scoped Event Subscription ID

type ServiceBusQueueEventSubscriptionDestination ¶ 

type ServiceBusQueueEventSubscriptionDestination struct {
	Properties *ServiceBusQueueEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (ServiceBusQueueEventSubscriptionDestination) MarshalJSON ¶ 

func (s ServiceBusQueueEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type ServiceBusQueueEventSubscriptionDestinationProperties ¶ 

type ServiceBusQueueEventSubscriptionDestinationProperties struct {
	DeliveryAttributeMappings *[]DeliveryAttributeMapping `json:"deliveryAttributeMappings,omitempty"`
	ResourceId                *string                     `json:"resourceId,omitempty"`
}

func (*ServiceBusQueueEventSubscriptionDestinationProperties) UnmarshalJSON ¶ 

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

type ServiceBusTopicEventSubscriptionDestination ¶ 

type ServiceBusTopicEventSubscriptionDestination struct {
	Properties *ServiceBusTopicEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (ServiceBusTopicEventSubscriptionDestination) MarshalJSON ¶ 

func (s ServiceBusTopicEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type ServiceBusTopicEventSubscriptionDestinationProperties ¶ 

type ServiceBusTopicEventSubscriptionDestinationProperties struct {
	DeliveryAttributeMappings *[]DeliveryAttributeMapping `json:"deliveryAttributeMappings,omitempty"`
	ResourceId                *string                     `json:"resourceId,omitempty"`
}

func (*ServiceBusTopicEventSubscriptionDestinationProperties) UnmarshalJSON ¶ 

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

type StaticDeliveryAttributeMapping ¶ 

type StaticDeliveryAttributeMapping struct {
	Properties *StaticDeliveryAttributeMappingProperties `json:"properties,omitempty"`

	// Fields inherited from DeliveryAttributeMapping
	Name *string `json:"name,omitempty"`
}

func (StaticDeliveryAttributeMapping) MarshalJSON ¶ 

func (s StaticDeliveryAttributeMapping) MarshalJSON() ([]byte, error)

type StaticDeliveryAttributeMappingProperties ¶ 

type StaticDeliveryAttributeMappingProperties struct {
	IsSecret *bool   `json:"isSecret,omitempty"`
	Value    *string `json:"value,omitempty"`
}

type StorageBlobDeadLetterDestination ¶ 

type StorageBlobDeadLetterDestination struct {
	Properties *StorageBlobDeadLetterDestinationProperties `json:"properties,omitempty"`
}

func (StorageBlobDeadLetterDestination) MarshalJSON ¶ 

func (s StorageBlobDeadLetterDestination) MarshalJSON() ([]byte, error)

type StorageBlobDeadLetterDestinationProperties ¶ 

type StorageBlobDeadLetterDestinationProperties struct {
	BlobContainerName *string `json:"blobContainerName,omitempty"`
	ResourceId        *string `json:"resourceId,omitempty"`
}

type StorageQueueEventSubscriptionDestination ¶ 

type StorageQueueEventSubscriptionDestination struct {
	Properties *StorageQueueEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (StorageQueueEventSubscriptionDestination) MarshalJSON ¶ 

func (s StorageQueueEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type StorageQueueEventSubscriptionDestinationProperties ¶ 

type StorageQueueEventSubscriptionDestinationProperties struct {
	QueueMessageTimeToLiveInSeconds *int64  `json:"queueMessageTimeToLiveInSeconds,omitempty"`
	QueueName                       *string `json:"queueName,omitempty"`
	ResourceId                      *string `json:"resourceId,omitempty"`
}

type StringBeginsWithAdvancedFilter ¶ 

type StringBeginsWithAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringBeginsWithAdvancedFilter) MarshalJSON ¶ 

func (s StringBeginsWithAdvancedFilter) MarshalJSON() ([]byte, error)

type StringBeginsWithFilter ¶ 

type StringBeginsWithFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringBeginsWithFilter) MarshalJSON ¶ 

func (s StringBeginsWithFilter) MarshalJSON() ([]byte, error)

type StringContainsAdvancedFilter ¶ 

type StringContainsAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringContainsAdvancedFilter) MarshalJSON ¶ 

func (s StringContainsAdvancedFilter) MarshalJSON() ([]byte, error)

type StringContainsFilter ¶ 

type StringContainsFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringContainsFilter) MarshalJSON ¶ 

func (s StringContainsFilter) MarshalJSON() ([]byte, error)

type StringEndsWithAdvancedFilter ¶ 

type StringEndsWithAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringEndsWithAdvancedFilter) MarshalJSON ¶ 

func (s StringEndsWithAdvancedFilter) MarshalJSON() ([]byte, error)

type StringEndsWithFilter ¶ 

type StringEndsWithFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringEndsWithFilter) MarshalJSON ¶ 

func (s StringEndsWithFilter) MarshalJSON() ([]byte, error)

type StringInAdvancedFilter ¶ 

type StringInAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringInAdvancedFilter) MarshalJSON ¶ 

func (s StringInAdvancedFilter) MarshalJSON() ([]byte, error)

type StringInFilter ¶ 

type StringInFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringInFilter) MarshalJSON ¶ 

func (s StringInFilter) MarshalJSON() ([]byte, error)

type StringNotBeginsWithAdvancedFilter ¶ 

type StringNotBeginsWithAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringNotBeginsWithAdvancedFilter) MarshalJSON ¶ 

func (s StringNotBeginsWithAdvancedFilter) MarshalJSON() ([]byte, error)

type StringNotBeginsWithFilter ¶ 

type StringNotBeginsWithFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringNotBeginsWithFilter) MarshalJSON ¶ 

func (s StringNotBeginsWithFilter) MarshalJSON() ([]byte, error)

type StringNotContainsAdvancedFilter ¶ 

type StringNotContainsAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringNotContainsAdvancedFilter) MarshalJSON ¶ 

func (s StringNotContainsAdvancedFilter) MarshalJSON() ([]byte, error)

type StringNotContainsFilter ¶ 

type StringNotContainsFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringNotContainsFilter) MarshalJSON ¶ 

func (s StringNotContainsFilter) MarshalJSON() ([]byte, error)

type StringNotEndsWithAdvancedFilter ¶ 

type StringNotEndsWithAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringNotEndsWithAdvancedFilter) MarshalJSON ¶ 

func (s StringNotEndsWithAdvancedFilter) MarshalJSON() ([]byte, error)

type StringNotEndsWithFilter ¶ 

type StringNotEndsWithFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringNotEndsWithFilter) MarshalJSON ¶ 

func (s StringNotEndsWithFilter) MarshalJSON() ([]byte, error)

type StringNotInAdvancedFilter ¶ 

type StringNotInAdvancedFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from AdvancedFilter
	Key *string `json:"key,omitempty"`
}

func (StringNotInAdvancedFilter) MarshalJSON ¶ 

func (s StringNotInAdvancedFilter) MarshalJSON() ([]byte, error)

type StringNotInFilter ¶ 

type StringNotInFilter struct {
	Values *[]string `json:"values,omitempty"`

	// Fields inherited from Filter
	Key *string `json:"key,omitempty"`
}

func (StringNotInFilter) MarshalJSON ¶ 

func (s StringNotInFilter) MarshalJSON() ([]byte, error)

type Subscription ¶ 

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

type SubscriptionOperationPredicate ¶ 

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

func (SubscriptionOperationPredicate) Matches ¶ 

func (p SubscriptionOperationPredicate) Matches(input Subscription) bool

type SubscriptionProperties ¶ 

type SubscriptionProperties struct {
	DeliveryConfiguration *DeliveryConfiguration         `json:"deliveryConfiguration,omitempty"`
	EventDeliverySchema   *DeliverySchema                `json:"eventDeliverySchema,omitempty"`
	FiltersConfiguration  *FiltersConfiguration          `json:"filtersConfiguration,omitempty"`
	ProvisioningState     *SubscriptionProvisioningState `json:"provisioningState,omitempty"`
}

type SubscriptionProvisioningState ¶ 

type SubscriptionProvisioningState string
const (
	SubscriptionProvisioningStateAwaitingManualAction SubscriptionProvisioningState = "AwaitingManualAction"
	SubscriptionProvisioningStateCanceled             SubscriptionProvisioningState = "Canceled"
	SubscriptionProvisioningStateCreateFailed         SubscriptionProvisioningState = "CreateFailed"
	SubscriptionProvisioningStateCreating             SubscriptionProvisioningState = "Creating"
	SubscriptionProvisioningStateDeleteFailed         SubscriptionProvisioningState = "DeleteFailed"
	SubscriptionProvisioningStateDeleted              SubscriptionProvisioningState = "Deleted"
	SubscriptionProvisioningStateDeleting             SubscriptionProvisioningState = "Deleting"
	SubscriptionProvisioningStateFailed               SubscriptionProvisioningState = "Failed"
	SubscriptionProvisioningStateSucceeded            SubscriptionProvisioningState = "Succeeded"
	SubscriptionProvisioningStateUpdatedFailed        SubscriptionProvisioningState = "UpdatedFailed"
	SubscriptionProvisioningStateUpdating             SubscriptionProvisioningState = "Updating"
)

func (*SubscriptionProvisioningState) UnmarshalJSON ¶ 

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

type SubscriptionUpdateParameters ¶ 

type SubscriptionUpdateParameters struct {
	Properties *SubscriptionUpdateParametersProperties `json:"properties,omitempty"`
}

type SubscriptionUpdateParametersProperties ¶ 

type SubscriptionUpdateParametersProperties struct {
	DeliveryConfiguration *DeliveryConfiguration `json:"deliveryConfiguration,omitempty"`
	EventDeliverySchema   *DeliverySchema        `json:"eventDeliverySchema,omitempty"`
	FiltersConfiguration  *FiltersConfiguration  `json:"filtersConfiguration,omitempty"`
}

type SystemTopicEventSubscriptionId ¶ 

type SystemTopicEventSubscriptionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	SystemTopicName       string
	EventSubscriptionName string
}

SystemTopicEventSubscriptionId is a struct representing the Resource ID for a System Topic Event Subscription

func NewSystemTopicEventSubscriptionID ¶ 

func NewSystemTopicEventSubscriptionID(subscriptionId string, resourceGroupName string, systemTopicName string, eventSubscriptionName string) SystemTopicEventSubscriptionId

NewSystemTopicEventSubscriptionID returns a new SystemTopicEventSubscriptionId struct

func ParseSystemTopicEventSubscriptionID ¶ 

func ParseSystemTopicEventSubscriptionID(input string) (*SystemTopicEventSubscriptionId, error)

ParseSystemTopicEventSubscriptionID parses 'input' into a SystemTopicEventSubscriptionId

func ParseSystemTopicEventSubscriptionIDInsensitively ¶ 

func ParseSystemTopicEventSubscriptionIDInsensitively(input string) (*SystemTopicEventSubscriptionId, error)

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

func (*SystemTopicEventSubscriptionId) FromParseResult ¶ 

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

func (SystemTopicEventSubscriptionId) ID ¶ 

func (id SystemTopicEventSubscriptionId) ID() string

ID returns the formatted System Topic Event Subscription ID

func (SystemTopicEventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this System Topic Event Subscription ID

func (SystemTopicEventSubscriptionId) String ¶ 

func (id SystemTopicEventSubscriptionId) String() string

String returns a human-readable description of this System Topic Event Subscription ID

type SystemTopicEventSubscriptionsCreateOrUpdateOperationResponse ¶ 

type SystemTopicEventSubscriptionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type SystemTopicEventSubscriptionsDeleteOperationResponse ¶ 

type SystemTopicEventSubscriptionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type SystemTopicEventSubscriptionsGetDeliveryAttributesOperationResponse ¶ 

type SystemTopicEventSubscriptionsGetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type SystemTopicEventSubscriptionsGetFullUrlOperationResponse ¶ 

type SystemTopicEventSubscriptionsGetFullUrlOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscriptionFullUrl
}

type SystemTopicEventSubscriptionsGetOperationResponse ¶ 

type SystemTopicEventSubscriptionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type SystemTopicEventSubscriptionsListBySystemTopicCompleteResult ¶ 

type SystemTopicEventSubscriptionsListBySystemTopicCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type SystemTopicEventSubscriptionsListBySystemTopicOperationOptions ¶ 

type SystemTopicEventSubscriptionsListBySystemTopicOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultSystemTopicEventSubscriptionsListBySystemTopicOperationOptions ¶ 

func DefaultSystemTopicEventSubscriptionsListBySystemTopicOperationOptions() SystemTopicEventSubscriptionsListBySystemTopicOperationOptions

func (SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToHeaders ¶ 

func (o SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToHeaders() *client.Headers

func (SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToOData ¶ 

func (o SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToOData() *odata.Query

func (SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToQuery ¶ 

func (o SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToQuery() *client.QueryParams

type SystemTopicEventSubscriptionsListBySystemTopicOperationResponse ¶ 

type SystemTopicEventSubscriptionsListBySystemTopicOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type SystemTopicEventSubscriptionsUpdateOperationResponse ¶ 

type SystemTopicEventSubscriptionsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type SystemTopicId ¶ 

type SystemTopicId struct {
	SubscriptionId    string
	ResourceGroupName string
	SystemTopicName   string
}

SystemTopicId is a struct representing the Resource ID for a System Topic

func NewSystemTopicID ¶ 

func NewSystemTopicID(subscriptionId string, resourceGroupName string, systemTopicName string) SystemTopicId

NewSystemTopicID returns a new SystemTopicId struct

func ParseSystemTopicID ¶ 

func ParseSystemTopicID(input string) (*SystemTopicId, error)

ParseSystemTopicID parses 'input' into a SystemTopicId

func ParseSystemTopicIDInsensitively ¶ 

func ParseSystemTopicIDInsensitively(input string) (*SystemTopicId, error)

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

func (*SystemTopicId) FromParseResult ¶ 

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

func (SystemTopicId) ID ¶ 

func (id SystemTopicId) ID() string

ID returns the formatted System Topic ID

func (SystemTopicId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this System Topic ID

func (SystemTopicId) String ¶ 

func (id SystemTopicId) String() string

String returns a human-readable description of this System Topic ID

type TlsVersion ¶ 

type TlsVersion string
const (
	TlsVersionOnePointOne  TlsVersion = "1.1"
	TlsVersionOnePointTwo  TlsVersion = "1.2"
	TlsVersionOnePointZero TlsVersion = "1.0"
)

func (*TlsVersion) UnmarshalJSON ¶ 

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

type TopicEventSubscriptionId ¶ 

type TopicEventSubscriptionId struct {
	SubscriptionId        string
	ResourceGroupName     string
	DomainName            string
	TopicName             string
	EventSubscriptionName string
}

TopicEventSubscriptionId is a struct representing the Resource ID for a Topic Event Subscription

func NewTopicEventSubscriptionID ¶ 

func NewTopicEventSubscriptionID(subscriptionId string, resourceGroupName string, domainName string, topicName string, eventSubscriptionName string) TopicEventSubscriptionId

NewTopicEventSubscriptionID returns a new TopicEventSubscriptionId struct

func ParseTopicEventSubscriptionID ¶ 

func ParseTopicEventSubscriptionID(input string) (*TopicEventSubscriptionId, error)

ParseTopicEventSubscriptionID parses 'input' into a TopicEventSubscriptionId

func ParseTopicEventSubscriptionIDInsensitively ¶ 

func ParseTopicEventSubscriptionIDInsensitively(input string) (*TopicEventSubscriptionId, error)

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

func (*TopicEventSubscriptionId) FromParseResult ¶ 

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

func (TopicEventSubscriptionId) ID ¶ 

func (id TopicEventSubscriptionId) ID() string

ID returns the formatted Topic Event Subscription ID

func (TopicEventSubscriptionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Topic Event Subscription ID

func (TopicEventSubscriptionId) String ¶ 

func (id TopicEventSubscriptionId) String() string

String returns a human-readable description of this Topic Event Subscription ID

type TopicEventSubscriptionsCreateOrUpdateOperationResponse ¶ 

type TopicEventSubscriptionsCreateOrUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type TopicEventSubscriptionsDeleteOperationResponse ¶ 

type TopicEventSubscriptionsDeleteOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
}

type TopicEventSubscriptionsGetDeliveryAttributesOperationResponse ¶ 

type TopicEventSubscriptionsGetDeliveryAttributesOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *DeliveryAttributeListResult
}

type TopicEventSubscriptionsGetFullUrlOperationResponse ¶ 

type TopicEventSubscriptionsGetFullUrlOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscriptionFullUrl
}

type TopicEventSubscriptionsGetOperationResponse ¶ 

type TopicEventSubscriptionsGetOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type TopicEventSubscriptionsListCompleteResult ¶ 

type TopicEventSubscriptionsListCompleteResult struct {
	LatestHttpResponse *http.Response
	Items              []EventSubscription
}

type TopicEventSubscriptionsListOperationOptions ¶ 

type TopicEventSubscriptionsListOperationOptions struct {
	Filter *string
	Top    *int64
}

func DefaultTopicEventSubscriptionsListOperationOptions ¶ 

func DefaultTopicEventSubscriptionsListOperationOptions() TopicEventSubscriptionsListOperationOptions

func (TopicEventSubscriptionsListOperationOptions) ToHeaders ¶ 

func (o TopicEventSubscriptionsListOperationOptions) ToHeaders() *client.Headers

func (TopicEventSubscriptionsListOperationOptions) ToOData ¶ 

func (o TopicEventSubscriptionsListOperationOptions) ToOData() *odata.Query

func (TopicEventSubscriptionsListOperationOptions) ToQuery ¶ 

func (o TopicEventSubscriptionsListOperationOptions) ToQuery() *client.QueryParams

type TopicEventSubscriptionsListOperationResponse ¶ 

type TopicEventSubscriptionsListOperationResponse struct {
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *[]EventSubscription
}

type TopicEventSubscriptionsUpdateOperationResponse ¶ 

type TopicEventSubscriptionsUpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type TopicId ¶ 

type TopicId struct {
	SubscriptionId    string
	ResourceGroupName string
	TopicName         string
}

TopicId is a struct representing the Resource ID for a Topic

func NewTopicID ¶ 

func NewTopicID(subscriptionId string, resourceGroupName string, topicName string) TopicId

NewTopicID returns a new TopicId struct

func ParseTopicID ¶ 

func ParseTopicID(input string) (*TopicId, error)

ParseTopicID parses 'input' into a TopicId

func ParseTopicIDInsensitively ¶ 

func ParseTopicIDInsensitively(input string) (*TopicId, error)

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

func (*TopicId) FromParseResult ¶ 

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

func (TopicId) ID ¶ 

func (id TopicId) ID() string

ID returns the formatted Topic ID

func (TopicId) Segments ¶ 

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

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

func (TopicId) String ¶ 

func (id TopicId) String() string

String returns a human-readable description of this Topic ID

type UpdateOperationResponse ¶ 

type UpdateOperationResponse struct {
	Poller       pollers.Poller
	HttpResponse *http.Response
	OData        *odata.OData
	Model        *EventSubscription
}

type WebHookEventSubscriptionDestination ¶ 

type WebHookEventSubscriptionDestination struct {
	Properties *WebHookEventSubscriptionDestinationProperties `json:"properties,omitempty"`
}

func (WebHookEventSubscriptionDestination) MarshalJSON ¶ 

func (s WebHookEventSubscriptionDestination) MarshalJSON() ([]byte, error)

type WebHookEventSubscriptionDestinationProperties ¶ 

type WebHookEventSubscriptionDestinationProperties struct {
	AzureActiveDirectoryApplicationIdOrUri *string                     `json:"azureActiveDirectoryApplicationIdOrUri,omitempty"`
	AzureActiveDirectoryTenantId           *string                     `json:"azureActiveDirectoryTenantId,omitempty"`
	DeliveryAttributeMappings              *[]DeliveryAttributeMapping `json:"deliveryAttributeMappings,omitempty"`
	EndpointBaseUrl                        *string                     `json:"endpointBaseUrl,omitempty"`
	EndpointUrl                            *string                     `json:"endpointUrl,omitempty"`
	MaxEventsPerBatch                      *int64                      `json:"maxEventsPerBatch,omitempty"`
	MinimumTlsVersionAllowed               *TlsVersion                 `json:"minimumTlsVersionAllowed,omitempty"`
	PreferredBatchSizeInKilobytes          *int64                      `json:"preferredBatchSizeInKilobytes,omitempty"`
}

func (*WebHookEventSubscriptionDestinationProperties) UnmarshalJSON ¶ 

func (s *WebHookEventSubscriptionDestinationProperties) UnmarshalJSON(bytes []byte) 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.