eventsubscriptions

package
v0.20240411.1145857 Latest Latest
Warning

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

Go to latest
Published: Apr 11, 2024 License: MPL-2.0 Imports: 15 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 ¶

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 ¶

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 ¶

ID returns the formatted Domain Event Subscription ID

func (DomainEventSubscriptionId) Segments ¶

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 (DomainEventSubscriptionsListOperationOptions) ToOData ¶

func (DomainEventSubscriptionsListOperationOptions) ToQuery ¶

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 (DomainTopicEventSubscriptionsListOperationOptions) ToOData ¶

func (DomainTopicEventSubscriptionsListOperationOptions) ToQuery ¶

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 ¶

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 ¶

CreateOrUpdate ...

func (EventSubscriptionsClient) CreateOrUpdateThenPoll ¶

CreateOrUpdateThenPoll performs CreateOrUpdate then polls until it's completed

func (EventSubscriptionsClient) Delete ¶

Delete ...

func (EventSubscriptionsClient) DeleteThenPoll ¶

DeleteThenPoll performs Delete then polls until it's completed

func (EventSubscriptionsClient) DomainEventSubscriptionsCreateOrUpdate ¶

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 ¶

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 ¶

DomainEventSubscriptionsGet ...

func (EventSubscriptionsClient) DomainEventSubscriptionsGetDeliveryAttributes ¶

DomainEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) DomainEventSubscriptionsGetFullUrl ¶

DomainEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) DomainEventSubscriptionsList ¶

DomainEventSubscriptionsList ...

func (EventSubscriptionsClient) DomainEventSubscriptionsListComplete ¶

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 ¶

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 ¶

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 ¶

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 ¶

DomainTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsGetDeliveryAttributes ¶

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

DomainTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsGetFullUrl ¶

DomainTopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsList ¶

DomainTopicEventSubscriptionsList ...

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsListComplete ¶

DomainTopicEventSubscriptionsListComplete retrieves all the results into a single object

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsListCompleteMatchingPredicate ¶

DomainTopicEventSubscriptionsListCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) DomainTopicEventSubscriptionsUpdate ¶

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 ¶

Get ...

func (EventSubscriptionsClient) GetDeliveryAttributes ¶

GetDeliveryAttributes ...

func (EventSubscriptionsClient) GetFullUrl ¶

GetFullUrl ...

func (EventSubscriptionsClient) ListByDomainTopic ¶

ListByDomainTopic ...

func (EventSubscriptionsClient) ListByDomainTopicComplete ¶

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 ¶

ListByResource ...

func (EventSubscriptionsClient) ListByResourceComplete ¶

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 ¶

ListGlobalByResourceGroup ...

func (EventSubscriptionsClient) ListGlobalByResourceGroupComplete ¶

ListGlobalByResourceGroupComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalByResourceGroupCompleteMatchingPredicate ¶

ListGlobalByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalByResourceGroupForTopicType ¶

ListGlobalByResourceGroupForTopicType ...

func (EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeComplete ¶

ListGlobalByResourceGroupForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeCompleteMatchingPredicate ¶

ListGlobalByResourceGroupForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalBySubscription ¶

ListGlobalBySubscription ...

func (EventSubscriptionsClient) ListGlobalBySubscriptionComplete ¶

ListGlobalBySubscriptionComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalBySubscriptionCompleteMatchingPredicate ¶

ListGlobalBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListGlobalBySubscriptionForTopicType ¶

ListGlobalBySubscriptionForTopicType ...

func (EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeComplete ¶

ListGlobalBySubscriptionForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeCompleteMatchingPredicate ¶

ListGlobalBySubscriptionForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalByResourceGroup ¶

ListRegionalByResourceGroup ...

func (EventSubscriptionsClient) ListRegionalByResourceGroupComplete ¶

ListRegionalByResourceGroupComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalByResourceGroupCompleteMatchingPredicate ¶

ListRegionalByResourceGroupCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalByResourceGroupForTopicType ¶

ListRegionalByResourceGroupForTopicType ...

func (EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeComplete ¶

ListRegionalByResourceGroupForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeCompleteMatchingPredicate ¶

ListRegionalByResourceGroupForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalBySubscription ¶

ListRegionalBySubscription ...

func (EventSubscriptionsClient) ListRegionalBySubscriptionComplete ¶

ListRegionalBySubscriptionComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalBySubscriptionCompleteMatchingPredicate ¶

ListRegionalBySubscriptionCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) ListRegionalBySubscriptionForTopicType ¶

ListRegionalBySubscriptionForTopicType ...

func (EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeComplete ¶

ListRegionalBySubscriptionForTopicTypeComplete retrieves all the results into a single object

func (EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeCompleteMatchingPredicate ¶

ListRegionalBySubscriptionForTopicTypeCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsCreateOrUpdate ¶

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 ¶

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 ¶

NamespaceTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsGetDeliveryAttributes ¶

NamespaceTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopic ¶

NamespaceTopicEventSubscriptionsListByNamespaceTopic ...

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopicComplete ¶

NamespaceTopicEventSubscriptionsListByNamespaceTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteMatchingPredicate ¶

NamespaceTopicEventSubscriptionsListByNamespaceTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) NamespaceTopicEventSubscriptionsUpdate ¶

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 ¶

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 ¶

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 ¶

PartnerTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsGetDeliveryAttributes ¶

PartnerTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsGetFullUrl ¶

PartnerTopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopic ¶

PartnerTopicEventSubscriptionsListByPartnerTopic ...

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopicComplete ¶

PartnerTopicEventSubscriptionsListByPartnerTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsListByPartnerTopicCompleteMatchingPredicate ¶

PartnerTopicEventSubscriptionsListByPartnerTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) PartnerTopicEventSubscriptionsUpdate ¶

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 ¶

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 ¶

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 ¶

SystemTopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsGetDeliveryAttributes ¶

SystemTopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsGetFullUrl ¶

SystemTopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopic ¶

SystemTopicEventSubscriptionsListBySystemTopic ...

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopicComplete ¶

SystemTopicEventSubscriptionsListBySystemTopicComplete retrieves all the results into a single object

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsListBySystemTopicCompleteMatchingPredicate ¶

SystemTopicEventSubscriptionsListBySystemTopicCompleteMatchingPredicate retrieves all the results and then applies the predicate

func (EventSubscriptionsClient) SystemTopicEventSubscriptionsUpdate ¶

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 ¶

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 ¶

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 ¶

TopicEventSubscriptionsGet ...

func (EventSubscriptionsClient) TopicEventSubscriptionsGetDeliveryAttributes ¶

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

TopicEventSubscriptionsGetDeliveryAttributes ...

func (EventSubscriptionsClient) TopicEventSubscriptionsGetFullUrl ¶

TopicEventSubscriptionsGetFullUrl ...

func (EventSubscriptionsClient) TopicEventSubscriptionsList ¶

TopicEventSubscriptionsList ...

func (EventSubscriptionsClient) TopicEventSubscriptionsListComplete ¶

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 ¶

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 ¶

Update ...

func (EventSubscriptionsClient) UpdateThenPoll ¶

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 ¶

type HybridConnectionEventSubscriptionDestinationProperties ¶

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

func (*HybridConnectionEventSubscriptionDestinationProperties) UnmarshalJSON ¶

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 (ListByDomainTopicOperationOptions) ToOData ¶

func (ListByDomainTopicOperationOptions) ToQuery ¶

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 (ListByResourceOperationOptions) ToOData ¶

func (ListByResourceOperationOptions) ToQuery ¶

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 (ListGlobalByResourceGroupForTopicTypeOperationOptions) ToHeaders ¶

func (ListGlobalByResourceGroupForTopicTypeOperationOptions) ToOData ¶

func (ListGlobalByResourceGroupForTopicTypeOperationOptions) ToQuery ¶

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 (ListGlobalByResourceGroupOperationOptions) ToOData ¶

func (ListGlobalByResourceGroupOperationOptions) ToQuery ¶

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 (ListGlobalBySubscriptionForTopicTypeOperationOptions) ToHeaders ¶

func (ListGlobalBySubscriptionForTopicTypeOperationOptions) ToOData ¶

func (ListGlobalBySubscriptionForTopicTypeOperationOptions) ToQuery ¶

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 (ListGlobalBySubscriptionOperationOptions) ToOData ¶

func (ListGlobalBySubscriptionOperationOptions) ToQuery ¶

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 (ListRegionalByResourceGroupForTopicTypeOperationOptions) ToHeaders ¶

func (ListRegionalByResourceGroupForTopicTypeOperationOptions) ToOData ¶

func (ListRegionalByResourceGroupForTopicTypeOperationOptions) ToQuery ¶

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 (ListRegionalByResourceGroupOperationOptions) ToOData ¶

func (ListRegionalByResourceGroupOperationOptions) ToQuery ¶

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 (ListRegionalBySubscriptionForTopicTypeOperationOptions) ToHeaders ¶

func (ListRegionalBySubscriptionForTopicTypeOperationOptions) ToOData ¶

func (ListRegionalBySubscriptionForTopicTypeOperationOptions) ToQuery ¶

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 (ListRegionalBySubscriptionOperationOptions) ToOData ¶

func (ListRegionalBySubscriptionOperationOptions) ToQuery ¶

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 ¶

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 ¶

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 (NamespaceTopicEventSubscriptionId) ID ¶

ID returns the formatted Namespace Topic Event Subscription ID

func (NamespaceTopicEventSubscriptionId) Segments ¶

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

func (NamespaceTopicEventSubscriptionId) 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 (NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToHeaders ¶

func (NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToOData ¶

func (NamespaceTopicEventSubscriptionsListByNamespaceTopicOperationOptions) ToQuery ¶

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 ¶

ID returns the formatted Partner Topic Event Subscription ID

func (PartnerTopicEventSubscriptionId) Segments ¶

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

func (PartnerTopicEventSubscriptionId) 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 (PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToHeaders ¶

func (PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToOData ¶

func (PartnerTopicEventSubscriptionsListByPartnerTopicOperationOptions) ToQuery ¶

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 ¶

ID returns the formatted Provider Location Topic Type ID

func (ProviderLocationTopicTypeId) Segments ¶

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 (ResourceGroupProviderTopicTypeId) ID ¶

ID returns the formatted Resource Group Provider Topic Type ID

func (ResourceGroupProviderTopicTypeId) Segments ¶

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

func (ResourceGroupProviderTopicTypeId) 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 ¶

ID returns the formatted Scoped Event Subscription ID

func (ScopedEventSubscriptionId) Segments ¶

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 ¶

type ServiceBusQueueEventSubscriptionDestinationProperties ¶

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

func (*ServiceBusQueueEventSubscriptionDestinationProperties) UnmarshalJSON ¶

type ServiceBusTopicEventSubscriptionDestination ¶

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

func (ServiceBusTopicEventSubscriptionDestination) MarshalJSON ¶

type ServiceBusTopicEventSubscriptionDestinationProperties ¶

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

func (*ServiceBusTopicEventSubscriptionDestinationProperties) UnmarshalJSON ¶

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 ¶

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 ¶

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 ¶

ID returns the formatted System Topic Event Subscription ID

func (SystemTopicEventSubscriptionId) Segments ¶

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

func (SystemTopicEventSubscriptionId) 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 (SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToHeaders ¶

func (SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToOData ¶

func (SystemTopicEventSubscriptionsListBySystemTopicOperationOptions) ToQuery ¶

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 ¶

ID returns the formatted Topic Event Subscription ID

func (TopicEventSubscriptionId) Segments ¶

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 (TopicEventSubscriptionsListOperationOptions) ToOData ¶

func (TopicEventSubscriptionsListOperationOptions) ToQuery ¶

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 ¶

Jump to

Keyboard shortcuts

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