iot

package
v3.33.0 Latest Latest
Warning

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

 Go to latest Published: Dec 7, 2020 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ConsumerGroup 

type ConsumerGroup struct {
	pulumi.CustomResourceState

	// The name of the Event Hub-compatible endpoint in the IoT hub. Changing this forces a new resource to be created.
	EventhubEndpointName pulumi.StringOutput `pulumi:"eventhubEndpointName"`
	// The name of the IoT Hub. Changing this forces a new resource to be created.
	IothubName pulumi.StringOutput `pulumi:"iothubName"`
	// The name of this Consumer Group. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group that contains the IoT hub. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Consumer Group within an IotHub

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West US"),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("testing"),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewConsumerGroup(ctx, "exampleConsumerGroup", &iot.ConsumerGroupArgs{
			IothubName:           exampleIoTHub.Name,
			EventhubEndpointName: pulumi.String("events"),
			ResourceGroupName:    exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub Consumer Groups can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/consumerGroup:ConsumerGroup group1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/eventHubEndpoints/events/ConsumerGroups/group1

```

func GetConsumerGroup 

func GetConsumerGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConsumerGroupState, opts ...pulumi.ResourceOption) (*ConsumerGroup, error)

GetConsumerGroup gets an existing ConsumerGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewConsumerGroup 

func NewConsumerGroup(ctx *pulumi.Context,
	name string, args *ConsumerGroupArgs, opts ...pulumi.ResourceOption) (*ConsumerGroup, error)

NewConsumerGroup registers a new resource with the given unique name, arguments, and options.

func (ConsumerGroup) ElementType added in v3.31.1 

func (ConsumerGroup) ElementType() reflect.Type

func (ConsumerGroup) ToConsumerGroupOutput added in v3.31.1 

func (i ConsumerGroup) ToConsumerGroupOutput() ConsumerGroupOutput

func (ConsumerGroup) ToConsumerGroupOutputWithContext added in v3.31.1 

func (i ConsumerGroup) ToConsumerGroupOutputWithContext(ctx context.Context) ConsumerGroupOutput

type ConsumerGroupArgs 

type ConsumerGroupArgs struct {
	// The name of the Event Hub-compatible endpoint in the IoT hub. Changing this forces a new resource to be created.
	EventhubEndpointName pulumi.StringInput
	// The name of the IoT Hub. Changing this forces a new resource to be created.
	IothubName pulumi.StringInput
	// The name of this Consumer Group. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the resource group that contains the IoT hub. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a ConsumerGroup resource.

func (ConsumerGroupArgs) ElementType 

func (ConsumerGroupArgs) ElementType() reflect.Type

type ConsumerGroupInput added in v3.31.1 

type ConsumerGroupInput interface {
	pulumi.Input

	ToConsumerGroupOutput() ConsumerGroupOutput
	ToConsumerGroupOutputWithContext(ctx context.Context) ConsumerGroupOutput
}

type ConsumerGroupOutput added in v3.31.1 

type ConsumerGroupOutput struct {
	*pulumi.OutputState
}

func (ConsumerGroupOutput) ElementType added in v3.31.1 

func (ConsumerGroupOutput) ElementType() reflect.Type

func (ConsumerGroupOutput) ToConsumerGroupOutput added in v3.31.1 

func (o ConsumerGroupOutput) ToConsumerGroupOutput() ConsumerGroupOutput

func (ConsumerGroupOutput) ToConsumerGroupOutputWithContext added in v3.31.1 

func (o ConsumerGroupOutput) ToConsumerGroupOutputWithContext(ctx context.Context) ConsumerGroupOutput

type ConsumerGroupState 

type ConsumerGroupState struct {
	// The name of the Event Hub-compatible endpoint in the IoT hub. Changing this forces a new resource to be created.
	EventhubEndpointName pulumi.StringPtrInput
	// The name of the IoT Hub. Changing this forces a new resource to be created.
	IothubName pulumi.StringPtrInput
	// The name of this Consumer Group. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the resource group that contains the IoT hub. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
}

func (ConsumerGroupState) ElementType 

func (ConsumerGroupState) ElementType() reflect.Type

type DpsSharedAccessPolicy 

type DpsSharedAccessPolicy struct {
	pulumi.CustomResourceState

	// Adds `EnrollmentRead` permission to this Shared Access Account. It allows read access to enrollment data.
	EnrollmentRead pulumi.BoolPtrOutput `pulumi:"enrollmentRead"`
	// Adds `EnrollmentWrite` permission to this Shared Access Account. It allows write access to enrollment data.
	EnrollmentWrite pulumi.BoolPtrOutput `pulumi:"enrollmentWrite"`
	// The name of the IoT Hub Device Provisioning service to which this Shared Access Policy belongs. Changing this forces a new resource to be created.
	IothubDpsName pulumi.StringOutput `pulumi:"iothubDpsName"`
	// Specifies the name of the IotHub Shared Access Policy resource. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The primary connection string of the Shared Access Policy.
	PrimaryConnectionString pulumi.StringOutput `pulumi:"primaryConnectionString"`
	// The primary key used to create the authentication token.
	PrimaryKey pulumi.StringOutput `pulumi:"primaryKey"`
	// Adds `RegistrationStatusRead` permission to this Shared Access Account. It allows read access to device registrations.
	RegistrationRead pulumi.BoolPtrOutput `pulumi:"registrationRead"`
	// Adds `RegistrationStatusWrite` permission to this Shared Access Account. It allows write access to device registrations.
	RegistrationWrite pulumi.BoolPtrOutput `pulumi:"registrationWrite"`
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// The secondary connection string of the Shared Access Policy.
	SecondaryConnectionString pulumi.StringOutput `pulumi:"secondaryConnectionString"`
	// The secondary key used to create the authentication token.
	SecondaryKey pulumi.StringOutput `pulumi:"secondaryKey"`
	// Adds `ServiceConfig` permission to this Shared Access Account. It allows configuration of the Device Provisioning Service.
	ServiceConfig pulumi.BoolPtrOutput `pulumi:"serviceConfig"`
}

Manages an IotHub Device Provisioning Service Shared Access Policy

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleIotHubDps, err := iot.NewIotHubDps(ctx, "exampleIotHubDps", &iot.IotHubDpsArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IotHubDpsSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewDpsSharedAccessPolicy(ctx, "exampleDpsSharedAccessPolicy", &iot.DpsSharedAccessPolicyArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubDpsName:     exampleIotHubDps.Name,
			EnrollmentWrite:   pulumi.Bool(true),
			EnrollmentRead:    pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub Device Provisioning Service Shared Access Policies can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/dpsSharedAccessPolicy:DpsSharedAccessPolicy shared_access_policy1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/provisioningServices/dps1/keys/shared_access_policy1

```

func GetDpsSharedAccessPolicy 

func GetDpsSharedAccessPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DpsSharedAccessPolicyState, opts ...pulumi.ResourceOption) (*DpsSharedAccessPolicy, error)

GetDpsSharedAccessPolicy gets an existing DpsSharedAccessPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDpsSharedAccessPolicy 

func NewDpsSharedAccessPolicy(ctx *pulumi.Context,
	name string, args *DpsSharedAccessPolicyArgs, opts ...pulumi.ResourceOption) (*DpsSharedAccessPolicy, error)

NewDpsSharedAccessPolicy registers a new resource with the given unique name, arguments, and options.

func (DpsSharedAccessPolicy) ElementType added in v3.31.1 

func (DpsSharedAccessPolicy) ElementType() reflect.Type

func (DpsSharedAccessPolicy) ToDpsSharedAccessPolicyOutput added in v3.31.1 

func (i DpsSharedAccessPolicy) ToDpsSharedAccessPolicyOutput() DpsSharedAccessPolicyOutput

func (DpsSharedAccessPolicy) ToDpsSharedAccessPolicyOutputWithContext added in v3.31.1 

func (i DpsSharedAccessPolicy) ToDpsSharedAccessPolicyOutputWithContext(ctx context.Context) DpsSharedAccessPolicyOutput

type DpsSharedAccessPolicyArgs 

type DpsSharedAccessPolicyArgs struct {
	// Adds `EnrollmentRead` permission to this Shared Access Account. It allows read access to enrollment data.
	EnrollmentRead pulumi.BoolPtrInput
	// Adds `EnrollmentWrite` permission to this Shared Access Account. It allows write access to enrollment data.
	EnrollmentWrite pulumi.BoolPtrInput
	// The name of the IoT Hub Device Provisioning service to which this Shared Access Policy belongs. Changing this forces a new resource to be created.
	IothubDpsName pulumi.StringInput
	// Specifies the name of the IotHub Shared Access Policy resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// Adds `RegistrationStatusRead` permission to this Shared Access Account. It allows read access to device registrations.
	RegistrationRead pulumi.BoolPtrInput
	// Adds `RegistrationStatusWrite` permission to this Shared Access Account. It allows write access to device registrations.
	RegistrationWrite pulumi.BoolPtrInput
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// Adds `ServiceConfig` permission to this Shared Access Account. It allows configuration of the Device Provisioning Service.
	ServiceConfig pulumi.BoolPtrInput
}

The set of arguments for constructing a DpsSharedAccessPolicy resource.

func (DpsSharedAccessPolicyArgs) ElementType 

func (DpsSharedAccessPolicyArgs) ElementType() reflect.Type

type DpsSharedAccessPolicyInput added in v3.31.1 

type DpsSharedAccessPolicyInput interface {
	pulumi.Input

	ToDpsSharedAccessPolicyOutput() DpsSharedAccessPolicyOutput
	ToDpsSharedAccessPolicyOutputWithContext(ctx context.Context) DpsSharedAccessPolicyOutput
}

type DpsSharedAccessPolicyOutput added in v3.31.1 

type DpsSharedAccessPolicyOutput struct {
	*pulumi.OutputState
}

func (DpsSharedAccessPolicyOutput) ElementType added in v3.31.1 

func (DpsSharedAccessPolicyOutput) ElementType() reflect.Type

func (DpsSharedAccessPolicyOutput) ToDpsSharedAccessPolicyOutput added in v3.31.1 

func (o DpsSharedAccessPolicyOutput) ToDpsSharedAccessPolicyOutput() DpsSharedAccessPolicyOutput

func (DpsSharedAccessPolicyOutput) ToDpsSharedAccessPolicyOutputWithContext added in v3.31.1 

func (o DpsSharedAccessPolicyOutput) ToDpsSharedAccessPolicyOutputWithContext(ctx context.Context) DpsSharedAccessPolicyOutput

type DpsSharedAccessPolicyState 

type DpsSharedAccessPolicyState struct {
	// Adds `EnrollmentRead` permission to this Shared Access Account. It allows read access to enrollment data.
	EnrollmentRead pulumi.BoolPtrInput
	// Adds `EnrollmentWrite` permission to this Shared Access Account. It allows write access to enrollment data.
	EnrollmentWrite pulumi.BoolPtrInput
	// The name of the IoT Hub Device Provisioning service to which this Shared Access Policy belongs. Changing this forces a new resource to be created.
	IothubDpsName pulumi.StringPtrInput
	// Specifies the name of the IotHub Shared Access Policy resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The primary connection string of the Shared Access Policy.
	PrimaryConnectionString pulumi.StringPtrInput
	// The primary key used to create the authentication token.
	PrimaryKey pulumi.StringPtrInput
	// Adds `RegistrationStatusRead` permission to this Shared Access Account. It allows read access to device registrations.
	RegistrationRead pulumi.BoolPtrInput
	// Adds `RegistrationStatusWrite` permission to this Shared Access Account. It allows write access to device registrations.
	RegistrationWrite pulumi.BoolPtrInput
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// The secondary connection string of the Shared Access Policy.
	SecondaryConnectionString pulumi.StringPtrInput
	// The secondary key used to create the authentication token.
	SecondaryKey pulumi.StringPtrInput
	// Adds `ServiceConfig` permission to this Shared Access Account. It allows configuration of the Device Provisioning Service.
	ServiceConfig pulumi.BoolPtrInput
}

func (DpsSharedAccessPolicyState) ElementType 

func (DpsSharedAccessPolicyState) ElementType() reflect.Type

type EndpointEventhub 

type EndpointEventhub struct {
	pulumi.CustomResourceState

	// The connection string for the endpoint.
	ConnectionString pulumi.StringOutput `pulumi:"connectionString"`
	IothubName       pulumi.StringOutput `pulumi:"iothubName"`
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringOutput `pulumi:"name"`
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages an IotHub EventHub Endpoint

> **NOTE:** Endpoints can be defined either directly on the `iot.IoTHub` resource, or using the `azurerm_iothub_endpoint_*` resources - but the two ways of defining the endpoints cannot be used together. If both are used against the same IoTHub, spurious changes will occur. Also, defining a `azurerm_iothub_endpoint_*` resource and another endpoint of a different type directly on the `iot.IoTHub` resource is not supported.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/eventhub"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("East US"),
		})
		if err != nil {
			return err
		}
		exampleEventHubNamespace, err := eventhub.NewEventHubNamespace(ctx, "exampleEventHubNamespace", &eventhub.EventHubNamespaceArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku:               pulumi.String("Basic"),
		})
		if err != nil {
			return err
		}
		exampleEventHub, err := eventhub.NewEventHub(ctx, "exampleEventHub", &eventhub.EventHubArgs{
			NamespaceName:     exampleEventHubNamespace.Name,
			ResourceGroupName: exampleResourceGroup.Name,
			PartitionCount:    pulumi.Int(2),
			MessageRetention:  pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		exampleAuthorizationRule, err := eventhub.NewAuthorizationRule(ctx, "exampleAuthorizationRule", &eventhub.AuthorizationRuleArgs{
			NamespaceName:     exampleEventHubNamespace.Name,
			EventhubName:      exampleEventHub.Name,
			ResourceGroupName: exampleResourceGroup.Name,
			Listen:            pulumi.Bool(false),
			Send:              pulumi.Bool(true),
			Manage:            pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("B1"),
				Tier:     pulumi.String("Basic"),
				Capacity: pulumi.Int(1),
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewEndpointEventhub(ctx, "exampleEndpointEventhub", &iot.EndpointEventhubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubName:        exampleIoTHub.Name,
			ConnectionString:  exampleAuthorizationRule.PrimaryConnectionString,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub EventHub Endpoint can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/endpointEventhub:EndpointEventhub eventhub1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/Endpoints/eventhub_endpoint1

```

func GetEndpointEventhub 

func GetEndpointEventhub(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointEventhubState, opts ...pulumi.ResourceOption) (*EndpointEventhub, error)

GetEndpointEventhub gets an existing EndpointEventhub resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEndpointEventhub 

func NewEndpointEventhub(ctx *pulumi.Context,
	name string, args *EndpointEventhubArgs, opts ...pulumi.ResourceOption) (*EndpointEventhub, error)

NewEndpointEventhub registers a new resource with the given unique name, arguments, and options.

func (EndpointEventhub) ElementType added in v3.31.1 

func (EndpointEventhub) ElementType() reflect.Type

func (EndpointEventhub) ToEndpointEventhubOutput added in v3.31.1 

func (i EndpointEventhub) ToEndpointEventhubOutput() EndpointEventhubOutput

func (EndpointEventhub) ToEndpointEventhubOutputWithContext added in v3.31.1 

func (i EndpointEventhub) ToEndpointEventhubOutputWithContext(ctx context.Context) EndpointEventhubOutput

type EndpointEventhubArgs 

type EndpointEventhubArgs struct {
	// The connection string for the endpoint.
	ConnectionString pulumi.StringInput
	IothubName       pulumi.StringInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringPtrInput
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a EndpointEventhub resource.

func (EndpointEventhubArgs) ElementType 

func (EndpointEventhubArgs) ElementType() reflect.Type

type EndpointEventhubInput added in v3.31.1 

type EndpointEventhubInput interface {
	pulumi.Input

	ToEndpointEventhubOutput() EndpointEventhubOutput
	ToEndpointEventhubOutputWithContext(ctx context.Context) EndpointEventhubOutput
}

type EndpointEventhubOutput added in v3.31.1 

type EndpointEventhubOutput struct {
	*pulumi.OutputState
}

func (EndpointEventhubOutput) ElementType added in v3.31.1 

func (EndpointEventhubOutput) ElementType() reflect.Type

func (EndpointEventhubOutput) ToEndpointEventhubOutput added in v3.31.1 

func (o EndpointEventhubOutput) ToEndpointEventhubOutput() EndpointEventhubOutput

func (EndpointEventhubOutput) ToEndpointEventhubOutputWithContext added in v3.31.1 

func (o EndpointEventhubOutput) ToEndpointEventhubOutputWithContext(ctx context.Context) EndpointEventhubOutput

type EndpointEventhubState 

type EndpointEventhubState struct {
	// The connection string for the endpoint.
	ConnectionString pulumi.StringPtrInput
	IothubName       pulumi.StringPtrInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringPtrInput
	ResourceGroupName pulumi.StringPtrInput
}

func (EndpointEventhubState) ElementType 

func (EndpointEventhubState) ElementType() reflect.Type

type EndpointServicebusQueue 

type EndpointServicebusQueue struct {
	pulumi.CustomResourceState

	// The connection string for the endpoint.
	ConnectionString pulumi.StringOutput `pulumi:"connectionString"`
	IothubName       pulumi.StringOutput `pulumi:"iothubName"`
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringOutput `pulumi:"name"`
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages an IotHub ServiceBus Queue Endpoint

> **NOTE:** Endpoints can be defined either directly on the `iot.IoTHub` resource, or using the `azurerm_iothub_endpoint_*` resources - but the two ways of defining the endpoints cannot be used together. If both are used against the same IoTHub, spurious changes will occur. Also, defining a `azurerm_iothub_endpoint_*` resource and another endpoint of a different type directly on the `iot.IoTHub` resource is not supported.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/servicebus"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("East US"),
		})
		if err != nil {
			return err
		}
		exampleNamespace, err := servicebus.NewNamespace(ctx, "exampleNamespace", &servicebus.NamespaceArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku:               pulumi.String("Standard"),
		})
		if err != nil {
			return err
		}
		exampleQueue, err := servicebus.NewQueue(ctx, "exampleQueue", &servicebus.QueueArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			NamespaceName:      exampleNamespace.Name,
			EnablePartitioning: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleQueueAuthorizationRule, err := servicebus.NewQueueAuthorizationRule(ctx, "exampleQueueAuthorizationRule", &servicebus.QueueAuthorizationRuleArgs{
			NamespaceName:     exampleNamespace.Name,
			QueueName:         exampleQueue.Name,
			ResourceGroupName: exampleResourceGroup.Name,
			Listen:            pulumi.Bool(false),
			Send:              pulumi.Bool(true),
			Manage:            pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("B1"),
				Tier:     pulumi.String("Basic"),
				Capacity: pulumi.Int(1),
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewEndpointServicebusQueue(ctx, "exampleEndpointServicebusQueue", &iot.EndpointServicebusQueueArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubName:        exampleIoTHub.Name,
			ConnectionString:  exampleQueueAuthorizationRule.PrimaryConnectionString,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub ServiceBus Queue Endpoint can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/endpointServicebusQueue:EndpointServicebusQueue servicebus_queue1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/Endpoints/servicebusqueue_endpoint1

```

func GetEndpointServicebusQueue 

func GetEndpointServicebusQueue(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointServicebusQueueState, opts ...pulumi.ResourceOption) (*EndpointServicebusQueue, error)

GetEndpointServicebusQueue gets an existing EndpointServicebusQueue resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEndpointServicebusQueue 

func NewEndpointServicebusQueue(ctx *pulumi.Context,
	name string, args *EndpointServicebusQueueArgs, opts ...pulumi.ResourceOption) (*EndpointServicebusQueue, error)

NewEndpointServicebusQueue registers a new resource with the given unique name, arguments, and options.

func (EndpointServicebusQueue) ElementType added in v3.31.1 

func (EndpointServicebusQueue) ElementType() reflect.Type

func (EndpointServicebusQueue) ToEndpointServicebusQueueOutput added in v3.31.1 

func (i EndpointServicebusQueue) ToEndpointServicebusQueueOutput() EndpointServicebusQueueOutput

func (EndpointServicebusQueue) ToEndpointServicebusQueueOutputWithContext added in v3.31.1 

func (i EndpointServicebusQueue) ToEndpointServicebusQueueOutputWithContext(ctx context.Context) EndpointServicebusQueueOutput

type EndpointServicebusQueueArgs 

type EndpointServicebusQueueArgs struct {
	// The connection string for the endpoint.
	ConnectionString pulumi.StringInput
	IothubName       pulumi.StringInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringPtrInput
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a EndpointServicebusQueue resource.

func (EndpointServicebusQueueArgs) ElementType 

func (EndpointServicebusQueueArgs) ElementType() reflect.Type

type EndpointServicebusQueueInput added in v3.31.1 

type EndpointServicebusQueueInput interface {
	pulumi.Input

	ToEndpointServicebusQueueOutput() EndpointServicebusQueueOutput
	ToEndpointServicebusQueueOutputWithContext(ctx context.Context) EndpointServicebusQueueOutput
}

type EndpointServicebusQueueOutput added in v3.31.1 

type EndpointServicebusQueueOutput struct {
	*pulumi.OutputState
}

func (EndpointServicebusQueueOutput) ElementType added in v3.31.1 

func (EndpointServicebusQueueOutput) ElementType() reflect.Type

func (EndpointServicebusQueueOutput) ToEndpointServicebusQueueOutput added in v3.31.1 

func (o EndpointServicebusQueueOutput) ToEndpointServicebusQueueOutput() EndpointServicebusQueueOutput

func (EndpointServicebusQueueOutput) ToEndpointServicebusQueueOutputWithContext added in v3.31.1 

func (o EndpointServicebusQueueOutput) ToEndpointServicebusQueueOutputWithContext(ctx context.Context) EndpointServicebusQueueOutput

type EndpointServicebusQueueState 

type EndpointServicebusQueueState struct {
	// The connection string for the endpoint.
	ConnectionString pulumi.StringPtrInput
	IothubName       pulumi.StringPtrInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringPtrInput
	ResourceGroupName pulumi.StringPtrInput
}

func (EndpointServicebusQueueState) ElementType 

func (EndpointServicebusQueueState) ElementType() reflect.Type

type EndpointServicebusTopic 

type EndpointServicebusTopic struct {
	pulumi.CustomResourceState

	// The connection string for the endpoint.
	ConnectionString pulumi.StringOutput `pulumi:"connectionString"`
	IothubName       pulumi.StringOutput `pulumi:"iothubName"`
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringOutput `pulumi:"name"`
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages an IotHub ServiceBus Topic Endpoint

> **NOTE:** Endpoints can be defined either directly on the `iot.IoTHub` resource, or using the `azurerm_iothub_endpoint_*` resources - but the two ways of defining the endpoints cannot be used together. If both are used against the same IoTHub, spurious changes will occur. Also, defining a `azurerm_iothub_endpoint_*` resource and another endpoint of a different type directly on the `iot.IoTHub` resource is not supported.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/servicebus"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("East US"),
		})
		if err != nil {
			return err
		}
		exampleNamespace, err := servicebus.NewNamespace(ctx, "exampleNamespace", &servicebus.NamespaceArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku:               pulumi.String("Standard"),
		})
		if err != nil {
			return err
		}
		exampleTopic, err := servicebus.NewTopic(ctx, "exampleTopic", &servicebus.TopicArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			NamespaceName:     exampleNamespace.Name,
		})
		if err != nil {
			return err
		}
		exampleTopicAuthorizationRule, err := servicebus.NewTopicAuthorizationRule(ctx, "exampleTopicAuthorizationRule", &servicebus.TopicAuthorizationRuleArgs{
			NamespaceName:     exampleNamespace.Name,
			TopicName:         exampleTopic.Name,
			ResourceGroupName: exampleResourceGroup.Name,
			Listen:            pulumi.Bool(false),
			Send:              pulumi.Bool(true),
			Manage:            pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("B1"),
				Tier:     pulumi.String("Basic"),
				Capacity: pulumi.Int(1),
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewEndpointServicebusTopic(ctx, "exampleEndpointServicebusTopic", &iot.EndpointServicebusTopicArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubName:        exampleIoTHub.Name,
			ConnectionString:  exampleTopicAuthorizationRule.PrimaryConnectionString,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub ServiceBus Topic Endpoint can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/endpointServicebusTopic:EndpointServicebusTopic servicebus_topic1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/Endpoints/servicebustopic_endpoint1

```

func GetEndpointServicebusTopic 

func GetEndpointServicebusTopic(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointServicebusTopicState, opts ...pulumi.ResourceOption) (*EndpointServicebusTopic, error)

GetEndpointServicebusTopic gets an existing EndpointServicebusTopic resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEndpointServicebusTopic 

func NewEndpointServicebusTopic(ctx *pulumi.Context,
	name string, args *EndpointServicebusTopicArgs, opts ...pulumi.ResourceOption) (*EndpointServicebusTopic, error)

NewEndpointServicebusTopic registers a new resource with the given unique name, arguments, and options.

func (EndpointServicebusTopic) ElementType added in v3.31.1 

func (EndpointServicebusTopic) ElementType() reflect.Type

func (EndpointServicebusTopic) ToEndpointServicebusTopicOutput added in v3.31.1 

func (i EndpointServicebusTopic) ToEndpointServicebusTopicOutput() EndpointServicebusTopicOutput

func (EndpointServicebusTopic) ToEndpointServicebusTopicOutputWithContext added in v3.31.1 

func (i EndpointServicebusTopic) ToEndpointServicebusTopicOutputWithContext(ctx context.Context) EndpointServicebusTopicOutput

type EndpointServicebusTopicArgs 

type EndpointServicebusTopicArgs struct {
	// The connection string for the endpoint.
	ConnectionString pulumi.StringInput
	IothubName       pulumi.StringInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringPtrInput
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a EndpointServicebusTopic resource.

func (EndpointServicebusTopicArgs) ElementType 

func (EndpointServicebusTopicArgs) ElementType() reflect.Type

type EndpointServicebusTopicInput added in v3.31.1 

type EndpointServicebusTopicInput interface {
	pulumi.Input

	ToEndpointServicebusTopicOutput() EndpointServicebusTopicOutput
	ToEndpointServicebusTopicOutputWithContext(ctx context.Context) EndpointServicebusTopicOutput
}

type EndpointServicebusTopicOutput added in v3.31.1 

type EndpointServicebusTopicOutput struct {
	*pulumi.OutputState
}

func (EndpointServicebusTopicOutput) ElementType added in v3.31.1 

func (EndpointServicebusTopicOutput) ElementType() reflect.Type

func (EndpointServicebusTopicOutput) ToEndpointServicebusTopicOutput added in v3.31.1 

func (o EndpointServicebusTopicOutput) ToEndpointServicebusTopicOutput() EndpointServicebusTopicOutput

func (EndpointServicebusTopicOutput) ToEndpointServicebusTopicOutputWithContext added in v3.31.1 

func (o EndpointServicebusTopicOutput) ToEndpointServicebusTopicOutputWithContext(ctx context.Context) EndpointServicebusTopicOutput

type EndpointServicebusTopicState 

type EndpointServicebusTopicState struct {
	// The connection string for the endpoint.
	ConnectionString pulumi.StringPtrInput
	IothubName       pulumi.StringPtrInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name              pulumi.StringPtrInput
	ResourceGroupName pulumi.StringPtrInput
}

func (EndpointServicebusTopicState) ElementType 

func (EndpointServicebusTopicState) ElementType() reflect.Type

type EndpointStorageContainer 

type EndpointStorageContainer struct {
	pulumi.CustomResourceState

	// Time interval at which blobs are written to storage. Value should be between 60 and 720 seconds. Default value is 300 seconds.
	BatchFrequencyInSeconds pulumi.IntPtrOutput `pulumi:"batchFrequencyInSeconds"`
	// The connection string for the endpoint.
	ConnectionString pulumi.StringOutput `pulumi:"connectionString"`
	// The name of storage container in the storage account.
	// *
	ContainerName pulumi.StringOutput `pulumi:"containerName"`
	// Encoding that is used to serialize messages to blobs. Supported values are 'avro' and 'avrodeflate'. Default value is 'avro'.
	Encoding pulumi.StringPtrOutput `pulumi:"encoding"`
	// File name format for the blob. Default format is “{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}“. All parameters are mandatory but can be reordered.
	FileNameFormat pulumi.StringPtrOutput `pulumi:"fileNameFormat"`
	// The name of the IoTHub to which this Storage Container Endpoint belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringOutput `pulumi:"iothubName"`
	// Maximum number of bytes for each blob written to storage. Value should be between 10485760(10MB) and 524288000(500MB). Default value is 314572800(300MB).
	MaxChunkSizeInBytes pulumi.IntPtrOutput `pulumi:"maxChunkSizeInBytes"`
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group under which the IotHub Storage Container Endpoint resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages an IotHub Storage Container Endpoint

> **NOTE:** Endpoints can be defined either directly on the `iot.IoTHub` resource, or using the `azurerm_iothub_endpoint_*` resources - but the two ways of defining the endpoints cannot be used together. If both are used against the same IoTHub, spurious changes will occur. Also, defining a `azurerm_iothub_endpoint_*` resource and another endpoint of a different type directly on the `iot.IoTHub` resource is not supported.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/storage"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West US"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewContainer(ctx, "exampleContainer", &storage.ContainerArgs{
			StorageAccountName:  exampleAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewEndpointStorageContainer(ctx, "exampleEndpointStorageContainer", &iot.EndpointStorageContainerArgs{
			ResourceGroupName:       exampleResourceGroup.Name,
			IothubName:              exampleIoTHub.Name,
			ContainerName:           pulumi.String("acctestcont"),
			ConnectionString:        exampleAccount.PrimaryBlobConnectionString,
			FileNameFormat:          pulumi.String("{iothub}/{partition}_{YYYY}_{MM}_{DD}_{HH}_{mm}"),
			BatchFrequencyInSeconds: pulumi.Int(60),
			MaxChunkSizeInBytes:     pulumi.Int(10485760),
			Encoding:                pulumi.String("JSON"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub Storage Container Endpoint can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/endpointStorageContainer:EndpointStorageContainer storage_container1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/Endpoints/storage_container_endpoint1

```

func GetEndpointStorageContainer 

func GetEndpointStorageContainer(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointStorageContainerState, opts ...pulumi.ResourceOption) (*EndpointStorageContainer, error)

GetEndpointStorageContainer gets an existing EndpointStorageContainer resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEndpointStorageContainer 

func NewEndpointStorageContainer(ctx *pulumi.Context,
	name string, args *EndpointStorageContainerArgs, opts ...pulumi.ResourceOption) (*EndpointStorageContainer, error)

NewEndpointStorageContainer registers a new resource with the given unique name, arguments, and options.

func (EndpointStorageContainer) ElementType added in v3.31.1 

func (EndpointStorageContainer) ElementType() reflect.Type

func (EndpointStorageContainer) ToEndpointStorageContainerOutput added in v3.31.1 

func (i EndpointStorageContainer) ToEndpointStorageContainerOutput() EndpointStorageContainerOutput

func (EndpointStorageContainer) ToEndpointStorageContainerOutputWithContext added in v3.31.1 

func (i EndpointStorageContainer) ToEndpointStorageContainerOutputWithContext(ctx context.Context) EndpointStorageContainerOutput

type EndpointStorageContainerArgs 

type EndpointStorageContainerArgs struct {
	// Time interval at which blobs are written to storage. Value should be between 60 and 720 seconds. Default value is 300 seconds.
	BatchFrequencyInSeconds pulumi.IntPtrInput
	// The connection string for the endpoint.
	ConnectionString pulumi.StringInput
	// The name of storage container in the storage account.
	// *
	ContainerName pulumi.StringInput
	// Encoding that is used to serialize messages to blobs. Supported values are 'avro' and 'avrodeflate'. Default value is 'avro'.
	Encoding pulumi.StringPtrInput
	// File name format for the blob. Default format is “{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}“. All parameters are mandatory but can be reordered.
	FileNameFormat pulumi.StringPtrInput
	// The name of the IoTHub to which this Storage Container Endpoint belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringInput
	// Maximum number of bytes for each blob written to storage. Value should be between 10485760(10MB) and 524288000(500MB). Default value is 314572800(300MB).
	MaxChunkSizeInBytes pulumi.IntPtrInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the IotHub Storage Container Endpoint resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a EndpointStorageContainer resource.

func (EndpointStorageContainerArgs) ElementType 

func (EndpointStorageContainerArgs) ElementType() reflect.Type

type EndpointStorageContainerInput added in v3.31.1 

type EndpointStorageContainerInput interface {
	pulumi.Input

	ToEndpointStorageContainerOutput() EndpointStorageContainerOutput
	ToEndpointStorageContainerOutputWithContext(ctx context.Context) EndpointStorageContainerOutput
}

type EndpointStorageContainerOutput added in v3.31.1 

type EndpointStorageContainerOutput struct {
	*pulumi.OutputState
}

func (EndpointStorageContainerOutput) ElementType added in v3.31.1 

func (EndpointStorageContainerOutput) ElementType() reflect.Type

func (EndpointStorageContainerOutput) ToEndpointStorageContainerOutput added in v3.31.1 

func (o EndpointStorageContainerOutput) ToEndpointStorageContainerOutput() EndpointStorageContainerOutput

func (EndpointStorageContainerOutput) ToEndpointStorageContainerOutputWithContext added in v3.31.1 

func (o EndpointStorageContainerOutput) ToEndpointStorageContainerOutputWithContext(ctx context.Context) EndpointStorageContainerOutput

type EndpointStorageContainerState 

type EndpointStorageContainerState struct {
	// Time interval at which blobs are written to storage. Value should be between 60 and 720 seconds. Default value is 300 seconds.
	BatchFrequencyInSeconds pulumi.IntPtrInput
	// The connection string for the endpoint.
	ConnectionString pulumi.StringPtrInput
	// The name of storage container in the storage account.
	// *
	ContainerName pulumi.StringPtrInput
	// Encoding that is used to serialize messages to blobs. Supported values are 'avro' and 'avrodeflate'. Default value is 'avro'.
	Encoding pulumi.StringPtrInput
	// File name format for the blob. Default format is “{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}“. All parameters are mandatory but can be reordered.
	FileNameFormat pulumi.StringPtrInput
	// The name of the IoTHub to which this Storage Container Endpoint belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringPtrInput
	// Maximum number of bytes for each blob written to storage. Value should be between 10485760(10MB) and 524288000(500MB). Default value is 314572800(300MB).
	MaxChunkSizeInBytes pulumi.IntPtrInput
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the IotHub Storage Container Endpoint resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
}

func (EndpointStorageContainerState) ElementType 

func (EndpointStorageContainerState) ElementType() reflect.Type

type FallbackRoute 

type FallbackRoute struct {
	pulumi.CustomResourceState

	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to `true` by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrOutput `pulumi:"condition"`
	// Used to specify whether the fallback route is enabled.
	Enabled pulumi.BoolOutput `pulumi:"enabled"`
	// The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.
	EndpointNames pulumi.StringOutput `pulumi:"endpointNames"`
	// The name of the IoTHub to which this Fallback Route belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringOutput `pulumi:"iothubName"`
	// The name of the resource group under which the IotHub Storage Container Endpoint resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages an IotHub Fallback Route

## Disclaimers

> **Note:** Fallback route can be defined either directly on the `iot.IoTHub` resource, or using the `iot.FallbackRoute` resource - but the two cannot be used together. If both are used against the same IoTHub, spurious changes will occur.

> **Note:** Since this resource is provisioned by default, the Azure Provider will not check for the presence of an existing resource prior to attempting to create it.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/storage"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West US"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleContainer, err := storage.NewContainer(ctx, "exampleContainer", &storage.ContainerArgs{
			StorageAccountName:  exampleAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("testing"),
			},
		})
		if err != nil {
			return err
		}
		exampleEndpointStorageContainer, err := iot.NewEndpointStorageContainer(ctx, "exampleEndpointStorageContainer", &iot.EndpointStorageContainerArgs{
			ResourceGroupName:       exampleResourceGroup.Name,
			IothubName:              exampleIoTHub.Name,
			ConnectionString:        exampleAccount.PrimaryBlobConnectionString,
			BatchFrequencyInSeconds: pulumi.Int(60),
			MaxChunkSizeInBytes:     pulumi.Int(10485760),
			ContainerName:           exampleContainer.Name,
			Encoding:                pulumi.String("Avro"),
			FileNameFormat:          pulumi.String("{iothub}/{partition}_{YYYY}_{MM}_{DD}_{HH}_{mm}"),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewFallbackRoute(ctx, "exampleFallbackRoute", &iot.FallbackRouteArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubName:        exampleIoTHub.Name,
			Condition:         pulumi.String("true"),
			EndpointNames: pulumi.String(pulumi.String{
				exampleEndpointStorageContainer.Name,
			}),
			Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub Fallback Route can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/fallbackRoute:FallbackRoute route1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/FallbackRoute/default

```

func GetFallbackRoute 

func GetFallbackRoute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FallbackRouteState, opts ...pulumi.ResourceOption) (*FallbackRoute, error)

GetFallbackRoute gets an existing FallbackRoute resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFallbackRoute 

func NewFallbackRoute(ctx *pulumi.Context,
	name string, args *FallbackRouteArgs, opts ...pulumi.ResourceOption) (*FallbackRoute, error)

NewFallbackRoute registers a new resource with the given unique name, arguments, and options.

func (FallbackRoute) ElementType added in v3.31.1 

func (FallbackRoute) ElementType() reflect.Type

func (FallbackRoute) ToFallbackRouteOutput added in v3.31.1 

func (i FallbackRoute) ToFallbackRouteOutput() FallbackRouteOutput

func (FallbackRoute) ToFallbackRouteOutputWithContext added in v3.31.1 

func (i FallbackRoute) ToFallbackRouteOutputWithContext(ctx context.Context) FallbackRouteOutput

type FallbackRouteArgs 

type FallbackRouteArgs struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to `true` by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrInput
	// Used to specify whether the fallback route is enabled.
	Enabled pulumi.BoolInput
	// The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.
	EndpointNames pulumi.StringInput
	// The name of the IoTHub to which this Fallback Route belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringInput
	// The name of the resource group under which the IotHub Storage Container Endpoint resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a FallbackRoute resource.

func (FallbackRouteArgs) ElementType 

func (FallbackRouteArgs) ElementType() reflect.Type

type FallbackRouteInput added in v3.31.1 

type FallbackRouteInput interface {
	pulumi.Input

	ToFallbackRouteOutput() FallbackRouteOutput
	ToFallbackRouteOutputWithContext(ctx context.Context) FallbackRouteOutput
}

type FallbackRouteOutput added in v3.31.1 

type FallbackRouteOutput struct {
	*pulumi.OutputState
}

func (FallbackRouteOutput) ElementType added in v3.31.1 

func (FallbackRouteOutput) ElementType() reflect.Type

func (FallbackRouteOutput) ToFallbackRouteOutput added in v3.31.1 

func (o FallbackRouteOutput) ToFallbackRouteOutput() FallbackRouteOutput

func (FallbackRouteOutput) ToFallbackRouteOutputWithContext added in v3.31.1 

func (o FallbackRouteOutput) ToFallbackRouteOutputWithContext(ctx context.Context) FallbackRouteOutput

type FallbackRouteState 

type FallbackRouteState struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to `true` by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrInput
	// Used to specify whether the fallback route is enabled.
	Enabled pulumi.BoolPtrInput
	// The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.
	EndpointNames pulumi.StringPtrInput
	// The name of the IoTHub to which this Fallback Route belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringPtrInput
	// The name of the resource group under which the IotHub Storage Container Endpoint resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
}

func (FallbackRouteState) ElementType 

func (FallbackRouteState) ElementType() reflect.Type

type GetDpsArgs 

type GetDpsArgs struct {
	// Specifies the name of the Iot Device Provisioning Service resource.
	Name string `pulumi:"name"`
	// The name of the resource group under which the Iot Device Provisioning Service is located in.
	ResourceGroupName string            `pulumi:"resourceGroupName"`
	Tags              map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getDps.

type GetDpsResult 

type GetDpsResult struct {
	// The allocation policy of the IoT Device Provisioning Service.
	AllocationPolicy string `pulumi:"allocationPolicy"`
	// The device endpoint of the IoT Device Provisioning Service.
	DeviceProvisioningHostName string `pulumi:"deviceProvisioningHostName"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The unique identifier of the IoT Device Provisioning Service.
	IdScope string `pulumi:"idScope"`
	// Specifies the supported Azure location where the IoT Device Provisioning Service exists.
	Location          string `pulumi:"location"`
	Name              string `pulumi:"name"`
	ResourceGroupName string `pulumi:"resourceGroupName"`
	// The service endpoint of the IoT Device Provisioning Service.
	ServiceOperationsHostName string            `pulumi:"serviceOperationsHostName"`
	Tags                      map[string]string `pulumi:"tags"`
}

A collection of values returned by getDps.

func GetDps 

func GetDps(ctx *pulumi.Context, args *GetDpsArgs, opts ...pulumi.InvokeOption) (*GetDpsResult, error)

Use this data source to access information about an existing IotHub Device Provisioning Service.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iot.GetDps(ctx, &iot.GetDpsArgs{
			Name:              "iot_hub_dps_test",
			ResourceGroupName: "iothub_dps_rg",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type IoTHub 

type IoTHub struct {
	pulumi.CustomResourceState

	// An `endpoint` block as defined below.
	Endpoints IoTHubEndpointArrayOutput `pulumi:"endpoints"`
	// The EventHub compatible endpoint for events data
	EventHubEventsEndpoint pulumi.StringOutput `pulumi:"eventHubEventsEndpoint"`
	// The EventHub compatible path for events data
	EventHubEventsPath pulumi.StringOutput `pulumi:"eventHubEventsPath"`
	// The EventHub compatible endpoint for operational data
	EventHubOperationsEndpoint pulumi.StringOutput `pulumi:"eventHubOperationsEndpoint"`
	// The EventHub compatible path for operational data
	EventHubOperationsPath pulumi.StringOutput `pulumi:"eventHubOperationsPath"`
	// The number of device-to-cloud partitions used by backing event hubs. Must be between `2` and `128`.
	EventHubPartitionCount pulumi.IntOutput `pulumi:"eventHubPartitionCount"`
	// The event hub retention to use in days. Must be between `1` and `7`.
	EventHubRetentionInDays pulumi.IntOutput `pulumi:"eventHubRetentionInDays"`
	// A `fallbackRoute` block as defined below. If the fallback route is enabled, messages that don't match any of the supplied routes are automatically sent to this route. Defaults to messages/events.
	FallbackRoute IoTHubFallbackRouteOutput `pulumi:"fallbackRoute"`
	// A `fileUpload` block as defined below.
	FileUpload IoTHubFileUploadPtrOutput `pulumi:"fileUpload"`
	// The hostname of the IotHub Resource.
	Hostname pulumi.StringOutput `pulumi:"hostname"`
	// One or more `ipFilterRule` blocks as defined below.
	IpFilterRules IoTHubIpFilterRuleArrayOutput `pulumi:"ipFilterRules"`
	// Specifies the supported Azure location where the resource has to be createc. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the IotHub resource. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// Is the IotHub resource accessible from a public network?
	PublicNetworkAccessEnabled pulumi.BoolPtrOutput `pulumi:"publicNetworkAccessEnabled"`
	// The name of the resource group under which the IotHub resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// A `route` block as defined below.
	Routes IoTHubRouteArrayOutput `pulumi:"routes"`
	// One or more `sharedAccessPolicy` blocks as defined below.
	SharedAccessPolicies IoTHubSharedAccessPolicyArrayOutput `pulumi:"sharedAccessPolicies"`
	// A `sku` block as defined below.
	Sku IoTHubSkuOutput `pulumi:"sku"`
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// The type of the endpoint. Possible values are `AzureIotHub.StorageContainer`, `AzureIotHub.ServiceBusQueue`, `AzureIotHub.ServiceBusTopic` or `AzureIotHub.EventHub`.
	Type pulumi.StringOutput `pulumi:"type"`
}

Manages an IotHub

> **NOTE:** Endpoints can be defined either directly on the `iot.IoTHub` resource, or using the `azurerm_iothub_endpoint_*` resources - but the two ways of defining the endpoints cannot be used together. If both are used against the same IoTHub, spurious changes will occur. Also, defining a `azurerm_iothub_endpoint_*` resource and another endpoint of a different type directly on the `iot.IoTHub` resource is not supported.

> **NOTE:** Routes can be defined either directly on the `iot.IoTHub` resource, or using the `iot.Route` resource - but the two cannot be used together. If both are used against the same IoTHub, spurious changes will occur.

> **NOTE:** Fallback route can be defined either directly on the `iot.IoTHub` resource, or using the `iot.FallbackRoute` resource - but the two cannot be used together. If both are used against the same IoTHub, spurious changes will occur.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/eventhub"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/storage"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("Canada Central"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleContainer, err := storage.NewContainer(ctx, "exampleContainer", &storage.ContainerArgs{
			StorageAccountName:  exampleAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		exampleEventHubNamespace, err := eventhub.NewEventHubNamespace(ctx, "exampleEventHubNamespace", &eventhub.EventHubNamespaceArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku:               pulumi.String("Basic"),
		})
		if err != nil {
			return err
		}
		exampleEventHub, err := eventhub.NewEventHub(ctx, "exampleEventHub", &eventhub.EventHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			NamespaceName:     exampleEventHubNamespace.Name,
			PartitionCount:    pulumi.Int(2),
			MessageRetention:  pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		exampleAuthorizationRule, err := eventhub.NewAuthorizationRule(ctx, "exampleAuthorizationRule", &eventhub.AuthorizationRuleArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			NamespaceName:     exampleEventHubNamespace.Name,
			EventhubName:      exampleEventHub.Name,
			Send:              pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
			Endpoints: iot.IoTHubEndpointArray{
				&iot.IoTHubEndpointArgs{
					Type:                    pulumi.String("AzureIotHub.StorageContainer"),
					ConnectionString:        exampleAccount.PrimaryBlobConnectionString,
					Name:                    pulumi.String("export"),
					BatchFrequencyInSeconds: pulumi.Int(60),
					MaxChunkSizeInBytes:     pulumi.Int(10485760),
					ContainerName:           exampleContainer.Name,
					Encoding:                pulumi.String("Avro"),
					FileNameFormat:          pulumi.String("{iothub}/{partition}_{YYYY}_{MM}_{DD}_{HH}_{mm}"),
				},
				&iot.IoTHubEndpointArgs{
					Type:             pulumi.String("AzureIotHub.EventHub"),
					ConnectionString: exampleAuthorizationRule.PrimaryConnectionString,
					Name:             pulumi.String("export2"),
				},
			},
			Routes: iot.IoTHubRouteArray{
				&iot.IoTHubRouteArgs{
					Name:      pulumi.String("export"),
					Source:    pulumi.String("DeviceMessages"),
					Condition: pulumi.String("true"),
					EndpointNames: pulumi.StringArray{
						pulumi.String("export"),
					},
					Enabled: pulumi.Bool(true),
				},
				&iot.IoTHubRouteArgs{
					Name:      pulumi.String("export2"),
					Source:    pulumi.String("DeviceMessages"),
					Condition: pulumi.String("true"),
					EndpointNames: pulumi.StringArray{
						pulumi.String("export2"),
					},
					Enabled: pulumi.Bool(true),
				},
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("testing"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHubs can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/ioTHub:IoTHub hub1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1

```

func GetIoTHub 

func GetIoTHub(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IoTHubState, opts ...pulumi.ResourceOption) (*IoTHub, error)

GetIoTHub gets an existing IoTHub resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIoTHub 

func NewIoTHub(ctx *pulumi.Context,
	name string, args *IoTHubArgs, opts ...pulumi.ResourceOption) (*IoTHub, error)

NewIoTHub registers a new resource with the given unique name, arguments, and options.

func (IoTHub) ElementType added in v3.31.1 

func (IoTHub) ElementType() reflect.Type

func (IoTHub) ToIoTHubOutput added in v3.31.1 

func (i IoTHub) ToIoTHubOutput() IoTHubOutput

func (IoTHub) ToIoTHubOutputWithContext added in v3.31.1 

func (i IoTHub) ToIoTHubOutputWithContext(ctx context.Context) IoTHubOutput

type IoTHubArgs 

type IoTHubArgs struct {
	// An `endpoint` block as defined below.
	Endpoints IoTHubEndpointArrayInput
	// The number of device-to-cloud partitions used by backing event hubs. Must be between `2` and `128`.
	EventHubPartitionCount pulumi.IntPtrInput
	// The event hub retention to use in days. Must be between `1` and `7`.
	EventHubRetentionInDays pulumi.IntPtrInput
	// A `fallbackRoute` block as defined below. If the fallback route is enabled, messages that don't match any of the supplied routes are automatically sent to this route. Defaults to messages/events.
	FallbackRoute IoTHubFallbackRoutePtrInput
	// A `fileUpload` block as defined below.
	FileUpload IoTHubFileUploadPtrInput
	// One or more `ipFilterRule` blocks as defined below.
	IpFilterRules IoTHubIpFilterRuleArrayInput
	// Specifies the supported Azure location where the resource has to be createc. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the IotHub resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// Is the IotHub resource accessible from a public network?
	PublicNetworkAccessEnabled pulumi.BoolPtrInput
	// The name of the resource group under which the IotHub resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// A `route` block as defined below.
	Routes IoTHubRouteArrayInput
	// A `sku` block as defined below.
	Sku IoTHubSkuInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a IoTHub resource.

func (IoTHubArgs) ElementType 

func (IoTHubArgs) ElementType() reflect.Type

type IoTHubEndpoint 

type IoTHubEndpoint struct {
	// Time interval at which blobs are written to storage. Value should be between 60 and 720 seconds. Default value is 300 seconds. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	BatchFrequencyInSeconds *int `pulumi:"batchFrequencyInSeconds"`
	// The connection string for the endpoint.
	ConnectionString string `pulumi:"connectionString"`
	// The name of storage container in the storage account. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	ContainerName *string `pulumi:"containerName"`
	// Encoding that is used to serialize messages to blobs. Supported values are 'avro' and 'avrodeflate'. Default value is 'avro'. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	Encoding *string `pulumi:"encoding"`
	// File name format for the blob. Default format is “{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}“. All parameters are mandatory but can be reordered. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	FileNameFormat *string `pulumi:"fileNameFormat"`
	// Maximum number of bytes for each blob written to storage. Value should be between 10485760(10MB) and 524288000(500MB). Default value is 314572800(300MB). This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	MaxChunkSizeInBytes *int `pulumi:"maxChunkSizeInBytes"`
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name string `pulumi:"name"`
	// The resource group in which the endpoint will be created.
	ResourceGroupName *string `pulumi:"resourceGroupName"`
	// The type of the endpoint. Possible values are `AzureIotHub.StorageContainer`, `AzureIotHub.ServiceBusQueue`, `AzureIotHub.ServiceBusTopic` or `AzureIotHub.EventHub`.
	Type string `pulumi:"type"`
}

type IoTHubEndpointArgs 

type IoTHubEndpointArgs struct {
	// Time interval at which blobs are written to storage. Value should be between 60 and 720 seconds. Default value is 300 seconds. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	BatchFrequencyInSeconds pulumi.IntPtrInput `pulumi:"batchFrequencyInSeconds"`
	// The connection string for the endpoint.
	ConnectionString pulumi.StringInput `pulumi:"connectionString"`
	// The name of storage container in the storage account. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	ContainerName pulumi.StringPtrInput `pulumi:"containerName"`
	// Encoding that is used to serialize messages to blobs. Supported values are 'avro' and 'avrodeflate'. Default value is 'avro'. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	Encoding pulumi.StringPtrInput `pulumi:"encoding"`
	// File name format for the blob. Default format is “{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}“. All parameters are mandatory but can be reordered. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	FileNameFormat pulumi.StringPtrInput `pulumi:"fileNameFormat"`
	// Maximum number of bytes for each blob written to storage. Value should be between 10485760(10MB) and 524288000(500MB). Default value is 314572800(300MB). This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.
	MaxChunkSizeInBytes pulumi.IntPtrInput `pulumi:"maxChunkSizeInBytes"`
	// The name of the endpoint. The name must be unique across endpoint types. The following names are reserved:  `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.
	Name pulumi.StringInput `pulumi:"name"`
	// The resource group in which the endpoint will be created.
	ResourceGroupName pulumi.StringPtrInput `pulumi:"resourceGroupName"`
	// The type of the endpoint. Possible values are `AzureIotHub.StorageContainer`, `AzureIotHub.ServiceBusQueue`, `AzureIotHub.ServiceBusTopic` or `AzureIotHub.EventHub`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (IoTHubEndpointArgs) ElementType 

func (IoTHubEndpointArgs) ElementType() reflect.Type

func (IoTHubEndpointArgs) ToIoTHubEndpointOutput 

func (i IoTHubEndpointArgs) ToIoTHubEndpointOutput() IoTHubEndpointOutput

func (IoTHubEndpointArgs) ToIoTHubEndpointOutputWithContext 

func (i IoTHubEndpointArgs) ToIoTHubEndpointOutputWithContext(ctx context.Context) IoTHubEndpointOutput

type IoTHubEndpointArray 

type IoTHubEndpointArray []IoTHubEndpointInput

func (IoTHubEndpointArray) ElementType 

func (IoTHubEndpointArray) ElementType() reflect.Type

func (IoTHubEndpointArray) ToIoTHubEndpointArrayOutput 

func (i IoTHubEndpointArray) ToIoTHubEndpointArrayOutput() IoTHubEndpointArrayOutput

func (IoTHubEndpointArray) ToIoTHubEndpointArrayOutputWithContext 

func (i IoTHubEndpointArray) ToIoTHubEndpointArrayOutputWithContext(ctx context.Context) IoTHubEndpointArrayOutput

type IoTHubEndpointArrayInput 

type IoTHubEndpointArrayInput interface {
	pulumi.Input

	ToIoTHubEndpointArrayOutput() IoTHubEndpointArrayOutput
	ToIoTHubEndpointArrayOutputWithContext(context.Context) IoTHubEndpointArrayOutput
}

IoTHubEndpointArrayInput is an input type that accepts IoTHubEndpointArray and IoTHubEndpointArrayOutput values. You can construct a concrete instance of `IoTHubEndpointArrayInput` via: 

IoTHubEndpointArray{ IoTHubEndpointArgs{...} }

type IoTHubEndpointArrayOutput 

type IoTHubEndpointArrayOutput struct{ *pulumi.OutputState }

func (IoTHubEndpointArrayOutput) ElementType 

func (IoTHubEndpointArrayOutput) ElementType() reflect.Type

func (IoTHubEndpointArrayOutput) Index 

func (o IoTHubEndpointArrayOutput) Index(i pulumi.IntInput) IoTHubEndpointOutput

func (IoTHubEndpointArrayOutput) ToIoTHubEndpointArrayOutput 

func (o IoTHubEndpointArrayOutput) ToIoTHubEndpointArrayOutput() IoTHubEndpointArrayOutput

func (IoTHubEndpointArrayOutput) ToIoTHubEndpointArrayOutputWithContext 

func (o IoTHubEndpointArrayOutput) ToIoTHubEndpointArrayOutputWithContext(ctx context.Context) IoTHubEndpointArrayOutput

type IoTHubEndpointInput 

type IoTHubEndpointInput interface {
	pulumi.Input

	ToIoTHubEndpointOutput() IoTHubEndpointOutput
	ToIoTHubEndpointOutputWithContext(context.Context) IoTHubEndpointOutput
}

IoTHubEndpointInput is an input type that accepts IoTHubEndpointArgs and IoTHubEndpointOutput values. You can construct a concrete instance of `IoTHubEndpointInput` via: 

IoTHubEndpointArgs{...}

type IoTHubEndpointOutput 

type IoTHubEndpointOutput struct{ *pulumi.OutputState }

func (IoTHubEndpointOutput) BatchFrequencyInSeconds 

func (o IoTHubEndpointOutput) BatchFrequencyInSeconds() pulumi.IntPtrOutput

Time interval at which blobs are written to storage. Value should be between 60 and 720 seconds. Default value is 300 seconds. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.

func (IoTHubEndpointOutput) ConnectionString 

func (o IoTHubEndpointOutput) ConnectionString() pulumi.StringOutput

The connection string for the endpoint.

func (IoTHubEndpointOutput) ContainerName 

func (o IoTHubEndpointOutput) ContainerName() pulumi.StringPtrOutput

The name of storage container in the storage account. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.

func (IoTHubEndpointOutput) ElementType 

func (IoTHubEndpointOutput) ElementType() reflect.Type

func (IoTHubEndpointOutput) Encoding 

func (o IoTHubEndpointOutput) Encoding() pulumi.StringPtrOutput

Encoding that is used to serialize messages to blobs. Supported values are 'avro' and 'avrodeflate'. Default value is 'avro'. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.

func (IoTHubEndpointOutput) FileNameFormat 

func (o IoTHubEndpointOutput) FileNameFormat() pulumi.StringPtrOutput

File name format for the blob. Default format is “{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}“. All parameters are mandatory but can be reordered. This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.

func (IoTHubEndpointOutput) MaxChunkSizeInBytes 

func (o IoTHubEndpointOutput) MaxChunkSizeInBytes() pulumi.IntPtrOutput

Maximum number of bytes for each blob written to storage. Value should be between 10485760(10MB) and 524288000(500MB). Default value is 314572800(300MB). This attribute is mandatory for endpoint type `AzureIotHub.StorageContainer`.

func (IoTHubEndpointOutput) Name 

func (o IoTHubEndpointOutput) Name() pulumi.StringOutput

The name of the endpoint. The name must be unique across endpoint types. The following names are reserved: `events`, `operationsMonitoringEvents`, `fileNotifications` and `$default`.

func (IoTHubEndpointOutput) ResourceGroupName added in v3.29.0 

func (o IoTHubEndpointOutput) ResourceGroupName() pulumi.StringPtrOutput

The resource group in which the endpoint will be created.

func (IoTHubEndpointOutput) ToIoTHubEndpointOutput 

func (o IoTHubEndpointOutput) ToIoTHubEndpointOutput() IoTHubEndpointOutput

func (IoTHubEndpointOutput) ToIoTHubEndpointOutputWithContext 

func (o IoTHubEndpointOutput) ToIoTHubEndpointOutputWithContext(ctx context.Context) IoTHubEndpointOutput

func (IoTHubEndpointOutput) Type 

func (o IoTHubEndpointOutput) Type() pulumi.StringOutput

The type of the endpoint. Possible values are `AzureIotHub.StorageContainer`, `AzureIotHub.ServiceBusQueue`, `AzureIotHub.ServiceBusTopic` or `AzureIotHub.EventHub`.

type IoTHubFallbackRoute 

type IoTHubFallbackRoute struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition *string `pulumi:"condition"`
	// Used to specify whether the fallback route is enabled.
	Enabled *bool `pulumi:"enabled"`
	// The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.
	EndpointNames []string `pulumi:"endpointNames"`
	// The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.
	Source *string `pulumi:"source"`
}

type IoTHubFallbackRouteArgs 

type IoTHubFallbackRouteArgs struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrInput `pulumi:"condition"`
	// Used to specify whether the fallback route is enabled.
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.
	EndpointNames pulumi.StringArrayInput `pulumi:"endpointNames"`
	// The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.
	Source pulumi.StringPtrInput `pulumi:"source"`
}

func (IoTHubFallbackRouteArgs) ElementType 

func (IoTHubFallbackRouteArgs) ElementType() reflect.Type

func (IoTHubFallbackRouteArgs) ToIoTHubFallbackRouteOutput 

func (i IoTHubFallbackRouteArgs) ToIoTHubFallbackRouteOutput() IoTHubFallbackRouteOutput

func (IoTHubFallbackRouteArgs) ToIoTHubFallbackRouteOutputWithContext 

func (i IoTHubFallbackRouteArgs) ToIoTHubFallbackRouteOutputWithContext(ctx context.Context) IoTHubFallbackRouteOutput

func (IoTHubFallbackRouteArgs) ToIoTHubFallbackRoutePtrOutput 

func (i IoTHubFallbackRouteArgs) ToIoTHubFallbackRoutePtrOutput() IoTHubFallbackRoutePtrOutput

func (IoTHubFallbackRouteArgs) ToIoTHubFallbackRoutePtrOutputWithContext 

func (i IoTHubFallbackRouteArgs) ToIoTHubFallbackRoutePtrOutputWithContext(ctx context.Context) IoTHubFallbackRoutePtrOutput

type IoTHubFallbackRouteInput 

type IoTHubFallbackRouteInput interface {
	pulumi.Input

	ToIoTHubFallbackRouteOutput() IoTHubFallbackRouteOutput
	ToIoTHubFallbackRouteOutputWithContext(context.Context) IoTHubFallbackRouteOutput
}

IoTHubFallbackRouteInput is an input type that accepts IoTHubFallbackRouteArgs and IoTHubFallbackRouteOutput values. You can construct a concrete instance of `IoTHubFallbackRouteInput` via: 

IoTHubFallbackRouteArgs{...}

type IoTHubFallbackRouteOutput 

type IoTHubFallbackRouteOutput struct{ *pulumi.OutputState }

func (IoTHubFallbackRouteOutput) Condition 

func (o IoTHubFallbackRouteOutput) Condition() pulumi.StringPtrOutput

The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.

func (IoTHubFallbackRouteOutput) ElementType 

func (IoTHubFallbackRouteOutput) ElementType() reflect.Type

func (IoTHubFallbackRouteOutput) Enabled 

func (o IoTHubFallbackRouteOutput) Enabled() pulumi.BoolPtrOutput

Used to specify whether the fallback route is enabled.

func (IoTHubFallbackRouteOutput) EndpointNames 

func (o IoTHubFallbackRouteOutput) EndpointNames() pulumi.StringArrayOutput

The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.

func (IoTHubFallbackRouteOutput) Source 

func (o IoTHubFallbackRouteOutput) Source() pulumi.StringPtrOutput

The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.

func (IoTHubFallbackRouteOutput) ToIoTHubFallbackRouteOutput 

func (o IoTHubFallbackRouteOutput) ToIoTHubFallbackRouteOutput() IoTHubFallbackRouteOutput

func (IoTHubFallbackRouteOutput) ToIoTHubFallbackRouteOutputWithContext 

func (o IoTHubFallbackRouteOutput) ToIoTHubFallbackRouteOutputWithContext(ctx context.Context) IoTHubFallbackRouteOutput

func (IoTHubFallbackRouteOutput) ToIoTHubFallbackRoutePtrOutput 

func (o IoTHubFallbackRouteOutput) ToIoTHubFallbackRoutePtrOutput() IoTHubFallbackRoutePtrOutput

func (IoTHubFallbackRouteOutput) ToIoTHubFallbackRoutePtrOutputWithContext 

func (o IoTHubFallbackRouteOutput) ToIoTHubFallbackRoutePtrOutputWithContext(ctx context.Context) IoTHubFallbackRoutePtrOutput

type IoTHubFallbackRoutePtrInput 

type IoTHubFallbackRoutePtrInput interface {
	pulumi.Input

	ToIoTHubFallbackRoutePtrOutput() IoTHubFallbackRoutePtrOutput
	ToIoTHubFallbackRoutePtrOutputWithContext(context.Context) IoTHubFallbackRoutePtrOutput
}

IoTHubFallbackRoutePtrInput is an input type that accepts IoTHubFallbackRouteArgs, IoTHubFallbackRoutePtr and IoTHubFallbackRoutePtrOutput values. You can construct a concrete instance of `IoTHubFallbackRoutePtrInput` via: 

        IoTHubFallbackRouteArgs{...}

or:

        nil

func IoTHubFallbackRoutePtr 

func IoTHubFallbackRoutePtr(v *IoTHubFallbackRouteArgs) IoTHubFallbackRoutePtrInput

type IoTHubFallbackRoutePtrOutput 

type IoTHubFallbackRoutePtrOutput struct{ *pulumi.OutputState }

func (IoTHubFallbackRoutePtrOutput) Condition 

func (o IoTHubFallbackRoutePtrOutput) Condition() pulumi.StringPtrOutput

The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.

func (IoTHubFallbackRoutePtrOutput) Elem 

func (o IoTHubFallbackRoutePtrOutput) Elem() IoTHubFallbackRouteOutput

func (IoTHubFallbackRoutePtrOutput) ElementType 

func (IoTHubFallbackRoutePtrOutput) ElementType() reflect.Type

func (IoTHubFallbackRoutePtrOutput) Enabled 

func (o IoTHubFallbackRoutePtrOutput) Enabled() pulumi.BoolPtrOutput

Used to specify whether the fallback route is enabled.

func (IoTHubFallbackRoutePtrOutput) EndpointNames 

func (o IoTHubFallbackRoutePtrOutput) EndpointNames() pulumi.StringArrayOutput

The endpoints to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.

func (IoTHubFallbackRoutePtrOutput) Source 

func (o IoTHubFallbackRoutePtrOutput) Source() pulumi.StringPtrOutput

The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.

func (IoTHubFallbackRoutePtrOutput) ToIoTHubFallbackRoutePtrOutput 

func (o IoTHubFallbackRoutePtrOutput) ToIoTHubFallbackRoutePtrOutput() IoTHubFallbackRoutePtrOutput

func (IoTHubFallbackRoutePtrOutput) ToIoTHubFallbackRoutePtrOutputWithContext 

func (o IoTHubFallbackRoutePtrOutput) ToIoTHubFallbackRoutePtrOutputWithContext(ctx context.Context) IoTHubFallbackRoutePtrOutput

type IoTHubFileUpload 

type IoTHubFileUpload struct {
	// The connection string for the Azure Storage account to which files are uploaded.
	ConnectionString string `pulumi:"connectionString"`
	// The name of the root container where you upload files. The container need not exist but should be creatable using the connectionString specified.
	ContainerName string `pulumi:"containerName"`
	// The period of time for which a file upload notification message is available to consume before it is expired by the IoT hub, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 48 hours, and evaluates to 'PT1H' by default.
	DefaultTtl *string `pulumi:"defaultTtl"`
	// The lock duration for the file upload notifications queue, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 5 and 300 seconds, and evaluates to 'PT1M' by default.
	LockDuration *string `pulumi:"lockDuration"`
	// The number of times the IoT hub attempts to deliver a file upload notification message. It evaluates to 10 by default.
	MaxDeliveryCount *int `pulumi:"maxDeliveryCount"`
	// Used to specify whether file notifications are sent to IoT Hub on upload. It evaluates to false by default.
	Notifications *bool `pulumi:"notifications"`
	// The period of time for which the SAS URI generated by IoT Hub for file upload is valid, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 24 hours, and evaluates to 'PT1H' by default.
	SasTtl *string `pulumi:"sasTtl"`
}

type IoTHubFileUploadArgs 

type IoTHubFileUploadArgs struct {
	// The connection string for the Azure Storage account to which files are uploaded.
	ConnectionString pulumi.StringInput `pulumi:"connectionString"`
	// The name of the root container where you upload files. The container need not exist but should be creatable using the connectionString specified.
	ContainerName pulumi.StringInput `pulumi:"containerName"`
	// The period of time for which a file upload notification message is available to consume before it is expired by the IoT hub, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 48 hours, and evaluates to 'PT1H' by default.
	DefaultTtl pulumi.StringPtrInput `pulumi:"defaultTtl"`
	// The lock duration for the file upload notifications queue, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 5 and 300 seconds, and evaluates to 'PT1M' by default.
	LockDuration pulumi.StringPtrInput `pulumi:"lockDuration"`
	// The number of times the IoT hub attempts to deliver a file upload notification message. It evaluates to 10 by default.
	MaxDeliveryCount pulumi.IntPtrInput `pulumi:"maxDeliveryCount"`
	// Used to specify whether file notifications are sent to IoT Hub on upload. It evaluates to false by default.
	Notifications pulumi.BoolPtrInput `pulumi:"notifications"`
	// The period of time for which the SAS URI generated by IoT Hub for file upload is valid, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 24 hours, and evaluates to 'PT1H' by default.
	SasTtl pulumi.StringPtrInput `pulumi:"sasTtl"`
}

func (IoTHubFileUploadArgs) ElementType 

func (IoTHubFileUploadArgs) ElementType() reflect.Type

func (IoTHubFileUploadArgs) ToIoTHubFileUploadOutput 

func (i IoTHubFileUploadArgs) ToIoTHubFileUploadOutput() IoTHubFileUploadOutput

func (IoTHubFileUploadArgs) ToIoTHubFileUploadOutputWithContext 

func (i IoTHubFileUploadArgs) ToIoTHubFileUploadOutputWithContext(ctx context.Context) IoTHubFileUploadOutput

func (IoTHubFileUploadArgs) ToIoTHubFileUploadPtrOutput 

func (i IoTHubFileUploadArgs) ToIoTHubFileUploadPtrOutput() IoTHubFileUploadPtrOutput

func (IoTHubFileUploadArgs) ToIoTHubFileUploadPtrOutputWithContext 

func (i IoTHubFileUploadArgs) ToIoTHubFileUploadPtrOutputWithContext(ctx context.Context) IoTHubFileUploadPtrOutput

type IoTHubFileUploadInput 

type IoTHubFileUploadInput interface {
	pulumi.Input

	ToIoTHubFileUploadOutput() IoTHubFileUploadOutput
	ToIoTHubFileUploadOutputWithContext(context.Context) IoTHubFileUploadOutput
}

IoTHubFileUploadInput is an input type that accepts IoTHubFileUploadArgs and IoTHubFileUploadOutput values. You can construct a concrete instance of `IoTHubFileUploadInput` via: 

IoTHubFileUploadArgs{...}

type IoTHubFileUploadOutput 

type IoTHubFileUploadOutput struct{ *pulumi.OutputState }

func (IoTHubFileUploadOutput) ConnectionString 

func (o IoTHubFileUploadOutput) ConnectionString() pulumi.StringOutput

The connection string for the Azure Storage account to which files are uploaded.

func (IoTHubFileUploadOutput) ContainerName 

func (o IoTHubFileUploadOutput) ContainerName() pulumi.StringOutput

The name of the root container where you upload files. The container need not exist but should be creatable using the connectionString specified.

func (IoTHubFileUploadOutput) DefaultTtl 

func (o IoTHubFileUploadOutput) DefaultTtl() pulumi.StringPtrOutput

The period of time for which a file upload notification message is available to consume before it is expired by the IoT hub, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 48 hours, and evaluates to 'PT1H' by default.

func (IoTHubFileUploadOutput) ElementType 

func (IoTHubFileUploadOutput) ElementType() reflect.Type

func (IoTHubFileUploadOutput) LockDuration 

func (o IoTHubFileUploadOutput) LockDuration() pulumi.StringPtrOutput

The lock duration for the file upload notifications queue, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 5 and 300 seconds, and evaluates to 'PT1M' by default.

func (IoTHubFileUploadOutput) MaxDeliveryCount 

func (o IoTHubFileUploadOutput) MaxDeliveryCount() pulumi.IntPtrOutput

The number of times the IoT hub attempts to deliver a file upload notification message. It evaluates to 10 by default.

func (IoTHubFileUploadOutput) Notifications 

func (o IoTHubFileUploadOutput) Notifications() pulumi.BoolPtrOutput

Used to specify whether file notifications are sent to IoT Hub on upload. It evaluates to false by default.

func (IoTHubFileUploadOutput) SasTtl 

func (o IoTHubFileUploadOutput) SasTtl() pulumi.StringPtrOutput

The period of time for which the SAS URI generated by IoT Hub for file upload is valid, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 24 hours, and evaluates to 'PT1H' by default.

func (IoTHubFileUploadOutput) ToIoTHubFileUploadOutput 

func (o IoTHubFileUploadOutput) ToIoTHubFileUploadOutput() IoTHubFileUploadOutput

func (IoTHubFileUploadOutput) ToIoTHubFileUploadOutputWithContext 

func (o IoTHubFileUploadOutput) ToIoTHubFileUploadOutputWithContext(ctx context.Context) IoTHubFileUploadOutput

func (IoTHubFileUploadOutput) ToIoTHubFileUploadPtrOutput 

func (o IoTHubFileUploadOutput) ToIoTHubFileUploadPtrOutput() IoTHubFileUploadPtrOutput

func (IoTHubFileUploadOutput) ToIoTHubFileUploadPtrOutputWithContext 

func (o IoTHubFileUploadOutput) ToIoTHubFileUploadPtrOutputWithContext(ctx context.Context) IoTHubFileUploadPtrOutput

type IoTHubFileUploadPtrInput 

type IoTHubFileUploadPtrInput interface {
	pulumi.Input

	ToIoTHubFileUploadPtrOutput() IoTHubFileUploadPtrOutput
	ToIoTHubFileUploadPtrOutputWithContext(context.Context) IoTHubFileUploadPtrOutput
}

IoTHubFileUploadPtrInput is an input type that accepts IoTHubFileUploadArgs, IoTHubFileUploadPtr and IoTHubFileUploadPtrOutput values. You can construct a concrete instance of `IoTHubFileUploadPtrInput` via: 

        IoTHubFileUploadArgs{...}

or:

        nil

func IoTHubFileUploadPtr 

func IoTHubFileUploadPtr(v *IoTHubFileUploadArgs) IoTHubFileUploadPtrInput

type IoTHubFileUploadPtrOutput 

type IoTHubFileUploadPtrOutput struct{ *pulumi.OutputState }

func (IoTHubFileUploadPtrOutput) ConnectionString 

func (o IoTHubFileUploadPtrOutput) ConnectionString() pulumi.StringPtrOutput

The connection string for the Azure Storage account to which files are uploaded.

func (IoTHubFileUploadPtrOutput) ContainerName 

func (o IoTHubFileUploadPtrOutput) ContainerName() pulumi.StringPtrOutput

The name of the root container where you upload files. The container need not exist but should be creatable using the connectionString specified.

func (IoTHubFileUploadPtrOutput) DefaultTtl 

func (o IoTHubFileUploadPtrOutput) DefaultTtl() pulumi.StringPtrOutput

The period of time for which a file upload notification message is available to consume before it is expired by the IoT hub, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 48 hours, and evaluates to 'PT1H' by default.

func (IoTHubFileUploadPtrOutput) Elem 

func (o IoTHubFileUploadPtrOutput) Elem() IoTHubFileUploadOutput

func (IoTHubFileUploadPtrOutput) ElementType 

func (IoTHubFileUploadPtrOutput) ElementType() reflect.Type

func (IoTHubFileUploadPtrOutput) LockDuration 

func (o IoTHubFileUploadPtrOutput) LockDuration() pulumi.StringPtrOutput

The lock duration for the file upload notifications queue, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 5 and 300 seconds, and evaluates to 'PT1M' by default.

func (IoTHubFileUploadPtrOutput) MaxDeliveryCount 

func (o IoTHubFileUploadPtrOutput) MaxDeliveryCount() pulumi.IntPtrOutput

The number of times the IoT hub attempts to deliver a file upload notification message. It evaluates to 10 by default.

func (IoTHubFileUploadPtrOutput) Notifications 

func (o IoTHubFileUploadPtrOutput) Notifications() pulumi.BoolPtrOutput

Used to specify whether file notifications are sent to IoT Hub on upload. It evaluates to false by default.

func (IoTHubFileUploadPtrOutput) SasTtl 

func (o IoTHubFileUploadPtrOutput) SasTtl() pulumi.StringPtrOutput

The period of time for which the SAS URI generated by IoT Hub for file upload is valid, specified as an [ISO 8601 timespan duration](https://en.wikipedia.org/wiki/ISO_8601#Durations). This value must be between 1 minute and 24 hours, and evaluates to 'PT1H' by default.

func (IoTHubFileUploadPtrOutput) ToIoTHubFileUploadPtrOutput 

func (o IoTHubFileUploadPtrOutput) ToIoTHubFileUploadPtrOutput() IoTHubFileUploadPtrOutput

func (IoTHubFileUploadPtrOutput) ToIoTHubFileUploadPtrOutputWithContext 

func (o IoTHubFileUploadPtrOutput) ToIoTHubFileUploadPtrOutputWithContext(ctx context.Context) IoTHubFileUploadPtrOutput

type IoTHubInput added in v3.31.1 

type IoTHubInput interface {
	pulumi.Input

	ToIoTHubOutput() IoTHubOutput
	ToIoTHubOutputWithContext(ctx context.Context) IoTHubOutput
}

type IoTHubIpFilterRule 

type IoTHubIpFilterRule struct {
	// The desired action for requests captured by this rule. Possible values are  `Accept`, `Reject`
	Action string `pulumi:"action"`
	// The IP address range in CIDR notation for the rule.
	IpMask string `pulumi:"ipMask"`
	// The name of the filter.
	Name string `pulumi:"name"`
}

type IoTHubIpFilterRuleArgs 

type IoTHubIpFilterRuleArgs struct {
	// The desired action for requests captured by this rule. Possible values are  `Accept`, `Reject`
	Action pulumi.StringInput `pulumi:"action"`
	// The IP address range in CIDR notation for the rule.
	IpMask pulumi.StringInput `pulumi:"ipMask"`
	// The name of the filter.
	Name pulumi.StringInput `pulumi:"name"`
}

func (IoTHubIpFilterRuleArgs) ElementType 

func (IoTHubIpFilterRuleArgs) ElementType() reflect.Type

func (IoTHubIpFilterRuleArgs) ToIoTHubIpFilterRuleOutput 

func (i IoTHubIpFilterRuleArgs) ToIoTHubIpFilterRuleOutput() IoTHubIpFilterRuleOutput

func (IoTHubIpFilterRuleArgs) ToIoTHubIpFilterRuleOutputWithContext 

func (i IoTHubIpFilterRuleArgs) ToIoTHubIpFilterRuleOutputWithContext(ctx context.Context) IoTHubIpFilterRuleOutput

type IoTHubIpFilterRuleArray 

type IoTHubIpFilterRuleArray []IoTHubIpFilterRuleInput

func (IoTHubIpFilterRuleArray) ElementType 

func (IoTHubIpFilterRuleArray) ElementType() reflect.Type

func (IoTHubIpFilterRuleArray) ToIoTHubIpFilterRuleArrayOutput 

func (i IoTHubIpFilterRuleArray) ToIoTHubIpFilterRuleArrayOutput() IoTHubIpFilterRuleArrayOutput

func (IoTHubIpFilterRuleArray) ToIoTHubIpFilterRuleArrayOutputWithContext 

func (i IoTHubIpFilterRuleArray) ToIoTHubIpFilterRuleArrayOutputWithContext(ctx context.Context) IoTHubIpFilterRuleArrayOutput

type IoTHubIpFilterRuleArrayInput 

type IoTHubIpFilterRuleArrayInput interface {
	pulumi.Input

	ToIoTHubIpFilterRuleArrayOutput() IoTHubIpFilterRuleArrayOutput
	ToIoTHubIpFilterRuleArrayOutputWithContext(context.Context) IoTHubIpFilterRuleArrayOutput
}

IoTHubIpFilterRuleArrayInput is an input type that accepts IoTHubIpFilterRuleArray and IoTHubIpFilterRuleArrayOutput values. You can construct a concrete instance of `IoTHubIpFilterRuleArrayInput` via: 

IoTHubIpFilterRuleArray{ IoTHubIpFilterRuleArgs{...} }

type IoTHubIpFilterRuleArrayOutput 

type IoTHubIpFilterRuleArrayOutput struct{ *pulumi.OutputState }

func (IoTHubIpFilterRuleArrayOutput) ElementType 

func (IoTHubIpFilterRuleArrayOutput) ElementType() reflect.Type

func (IoTHubIpFilterRuleArrayOutput) Index 

func (o IoTHubIpFilterRuleArrayOutput) Index(i pulumi.IntInput) IoTHubIpFilterRuleOutput

func (IoTHubIpFilterRuleArrayOutput) ToIoTHubIpFilterRuleArrayOutput 

func (o IoTHubIpFilterRuleArrayOutput) ToIoTHubIpFilterRuleArrayOutput() IoTHubIpFilterRuleArrayOutput

func (IoTHubIpFilterRuleArrayOutput) ToIoTHubIpFilterRuleArrayOutputWithContext 

func (o IoTHubIpFilterRuleArrayOutput) ToIoTHubIpFilterRuleArrayOutputWithContext(ctx context.Context) IoTHubIpFilterRuleArrayOutput

type IoTHubIpFilterRuleInput 

type IoTHubIpFilterRuleInput interface {
	pulumi.Input

	ToIoTHubIpFilterRuleOutput() IoTHubIpFilterRuleOutput
	ToIoTHubIpFilterRuleOutputWithContext(context.Context) IoTHubIpFilterRuleOutput
}

IoTHubIpFilterRuleInput is an input type that accepts IoTHubIpFilterRuleArgs and IoTHubIpFilterRuleOutput values. You can construct a concrete instance of `IoTHubIpFilterRuleInput` via: 

IoTHubIpFilterRuleArgs{...}

type IoTHubIpFilterRuleOutput 

type IoTHubIpFilterRuleOutput struct{ *pulumi.OutputState }

func (IoTHubIpFilterRuleOutput) Action 

func (o IoTHubIpFilterRuleOutput) Action() pulumi.StringOutput

The desired action for requests captured by this rule. Possible values are `Accept`, `Reject`

func (IoTHubIpFilterRuleOutput) ElementType 

func (IoTHubIpFilterRuleOutput) ElementType() reflect.Type

func (IoTHubIpFilterRuleOutput) IpMask 

func (o IoTHubIpFilterRuleOutput) IpMask() pulumi.StringOutput

The IP address range in CIDR notation for the rule.

func (IoTHubIpFilterRuleOutput) Name 

func (o IoTHubIpFilterRuleOutput) Name() pulumi.StringOutput

The name of the filter.

func (IoTHubIpFilterRuleOutput) ToIoTHubIpFilterRuleOutput 

func (o IoTHubIpFilterRuleOutput) ToIoTHubIpFilterRuleOutput() IoTHubIpFilterRuleOutput

func (IoTHubIpFilterRuleOutput) ToIoTHubIpFilterRuleOutputWithContext 

func (o IoTHubIpFilterRuleOutput) ToIoTHubIpFilterRuleOutputWithContext(ctx context.Context) IoTHubIpFilterRuleOutput

type IoTHubOutput added in v3.31.1 

type IoTHubOutput struct {
	*pulumi.OutputState
}

func (IoTHubOutput) ElementType added in v3.31.1 

func (IoTHubOutput) ElementType() reflect.Type

func (IoTHubOutput) ToIoTHubOutput added in v3.31.1 

func (o IoTHubOutput) ToIoTHubOutput() IoTHubOutput

func (IoTHubOutput) ToIoTHubOutputWithContext added in v3.31.1 

func (o IoTHubOutput) ToIoTHubOutputWithContext(ctx context.Context) IoTHubOutput

type IoTHubRoute 

type IoTHubRoute struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition *string `pulumi:"condition"`
	// Used to specify whether a route is enabled.
	Enabled bool `pulumi:"enabled"`
	// The list of endpoints to which messages that satisfy the condition are routed.
	EndpointNames []string `pulumi:"endpointNames"`
	// The name of the route.
	Name string `pulumi:"name"`
	// The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.
	Source string `pulumi:"source"`
}

type IoTHubRouteArgs 

type IoTHubRouteArgs struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrInput `pulumi:"condition"`
	// Used to specify whether a route is enabled.
	Enabled pulumi.BoolInput `pulumi:"enabled"`
	// The list of endpoints to which messages that satisfy the condition are routed.
	EndpointNames pulumi.StringArrayInput `pulumi:"endpointNames"`
	// The name of the route.
	Name pulumi.StringInput `pulumi:"name"`
	// The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.
	Source pulumi.StringInput `pulumi:"source"`
}

func (IoTHubRouteArgs) ElementType 

func (IoTHubRouteArgs) ElementType() reflect.Type

func (IoTHubRouteArgs) ToIoTHubRouteOutput 

func (i IoTHubRouteArgs) ToIoTHubRouteOutput() IoTHubRouteOutput

func (IoTHubRouteArgs) ToIoTHubRouteOutputWithContext 

func (i IoTHubRouteArgs) ToIoTHubRouteOutputWithContext(ctx context.Context) IoTHubRouteOutput

type IoTHubRouteArray 

type IoTHubRouteArray []IoTHubRouteInput

func (IoTHubRouteArray) ElementType 

func (IoTHubRouteArray) ElementType() reflect.Type

func (IoTHubRouteArray) ToIoTHubRouteArrayOutput 

func (i IoTHubRouteArray) ToIoTHubRouteArrayOutput() IoTHubRouteArrayOutput

func (IoTHubRouteArray) ToIoTHubRouteArrayOutputWithContext 

func (i IoTHubRouteArray) ToIoTHubRouteArrayOutputWithContext(ctx context.Context) IoTHubRouteArrayOutput

type IoTHubRouteArrayInput 

type IoTHubRouteArrayInput interface {
	pulumi.Input

	ToIoTHubRouteArrayOutput() IoTHubRouteArrayOutput
	ToIoTHubRouteArrayOutputWithContext(context.Context) IoTHubRouteArrayOutput
}

IoTHubRouteArrayInput is an input type that accepts IoTHubRouteArray and IoTHubRouteArrayOutput values. You can construct a concrete instance of `IoTHubRouteArrayInput` via: 

IoTHubRouteArray{ IoTHubRouteArgs{...} }

type IoTHubRouteArrayOutput 

type IoTHubRouteArrayOutput struct{ *pulumi.OutputState }

func (IoTHubRouteArrayOutput) ElementType 

func (IoTHubRouteArrayOutput) ElementType() reflect.Type

func (IoTHubRouteArrayOutput) Index 

func (o IoTHubRouteArrayOutput) Index(i pulumi.IntInput) IoTHubRouteOutput

func (IoTHubRouteArrayOutput) ToIoTHubRouteArrayOutput 

func (o IoTHubRouteArrayOutput) ToIoTHubRouteArrayOutput() IoTHubRouteArrayOutput

func (IoTHubRouteArrayOutput) ToIoTHubRouteArrayOutputWithContext 

func (o IoTHubRouteArrayOutput) ToIoTHubRouteArrayOutputWithContext(ctx context.Context) IoTHubRouteArrayOutput

type IoTHubRouteInput 

type IoTHubRouteInput interface {
	pulumi.Input

	ToIoTHubRouteOutput() IoTHubRouteOutput
	ToIoTHubRouteOutputWithContext(context.Context) IoTHubRouteOutput
}

IoTHubRouteInput is an input type that accepts IoTHubRouteArgs and IoTHubRouteOutput values. You can construct a concrete instance of `IoTHubRouteInput` via: 

IoTHubRouteArgs{...}

type IoTHubRouteOutput 

type IoTHubRouteOutput struct{ *pulumi.OutputState }

func (IoTHubRouteOutput) Condition 

func (o IoTHubRouteOutput) Condition() pulumi.StringPtrOutput

The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.

func (IoTHubRouteOutput) ElementType 

func (IoTHubRouteOutput) ElementType() reflect.Type

func (IoTHubRouteOutput) Enabled 

func (o IoTHubRouteOutput) Enabled() pulumi.BoolOutput

Used to specify whether a route is enabled.

func (IoTHubRouteOutput) EndpointNames 

func (o IoTHubRouteOutput) EndpointNames() pulumi.StringArrayOutput

The list of endpoints to which messages that satisfy the condition are routed.

func (IoTHubRouteOutput) Name 

func (o IoTHubRouteOutput) Name() pulumi.StringOutput

The name of the route.

func (IoTHubRouteOutput) Source 

func (o IoTHubRouteOutput) Source() pulumi.StringOutput

The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.

func (IoTHubRouteOutput) ToIoTHubRouteOutput 

func (o IoTHubRouteOutput) ToIoTHubRouteOutput() IoTHubRouteOutput

func (IoTHubRouteOutput) ToIoTHubRouteOutputWithContext 

func (o IoTHubRouteOutput) ToIoTHubRouteOutputWithContext(ctx context.Context) IoTHubRouteOutput

type IoTHubSharedAccessPolicy 

type IoTHubSharedAccessPolicy struct {
	// The name of the shared access policy.
	KeyName *string `pulumi:"keyName"`
	// The permissions assigned to the shared access policy.
	Permissions *string `pulumi:"permissions"`
	// The primary key.
	PrimaryKey *string `pulumi:"primaryKey"`
	// The secondary key.
	SecondaryKey *string `pulumi:"secondaryKey"`
}

type IoTHubSharedAccessPolicyArgs 

type IoTHubSharedAccessPolicyArgs struct {
	// The name of the shared access policy.
	KeyName pulumi.StringPtrInput `pulumi:"keyName"`
	// The permissions assigned to the shared access policy.
	Permissions pulumi.StringPtrInput `pulumi:"permissions"`
	// The primary key.
	PrimaryKey pulumi.StringPtrInput `pulumi:"primaryKey"`
	// The secondary key.
	SecondaryKey pulumi.StringPtrInput `pulumi:"secondaryKey"`
}

func (IoTHubSharedAccessPolicyArgs) ElementType 

func (IoTHubSharedAccessPolicyArgs) ElementType() reflect.Type

func (IoTHubSharedAccessPolicyArgs) ToIoTHubSharedAccessPolicyOutput 

func (i IoTHubSharedAccessPolicyArgs) ToIoTHubSharedAccessPolicyOutput() IoTHubSharedAccessPolicyOutput

func (IoTHubSharedAccessPolicyArgs) ToIoTHubSharedAccessPolicyOutputWithContext 

func (i IoTHubSharedAccessPolicyArgs) ToIoTHubSharedAccessPolicyOutputWithContext(ctx context.Context) IoTHubSharedAccessPolicyOutput

type IoTHubSharedAccessPolicyArray 

type IoTHubSharedAccessPolicyArray []IoTHubSharedAccessPolicyInput

func (IoTHubSharedAccessPolicyArray) ElementType 

func (IoTHubSharedAccessPolicyArray) ElementType() reflect.Type

func (IoTHubSharedAccessPolicyArray) ToIoTHubSharedAccessPolicyArrayOutput 

func (i IoTHubSharedAccessPolicyArray) ToIoTHubSharedAccessPolicyArrayOutput() IoTHubSharedAccessPolicyArrayOutput

func (IoTHubSharedAccessPolicyArray) ToIoTHubSharedAccessPolicyArrayOutputWithContext 

func (i IoTHubSharedAccessPolicyArray) ToIoTHubSharedAccessPolicyArrayOutputWithContext(ctx context.Context) IoTHubSharedAccessPolicyArrayOutput

type IoTHubSharedAccessPolicyArrayInput 

type IoTHubSharedAccessPolicyArrayInput interface {
	pulumi.Input

	ToIoTHubSharedAccessPolicyArrayOutput() IoTHubSharedAccessPolicyArrayOutput
	ToIoTHubSharedAccessPolicyArrayOutputWithContext(context.Context) IoTHubSharedAccessPolicyArrayOutput
}

IoTHubSharedAccessPolicyArrayInput is an input type that accepts IoTHubSharedAccessPolicyArray and IoTHubSharedAccessPolicyArrayOutput values. You can construct a concrete instance of `IoTHubSharedAccessPolicyArrayInput` via: 

IoTHubSharedAccessPolicyArray{ IoTHubSharedAccessPolicyArgs{...} }

type IoTHubSharedAccessPolicyArrayOutput 

type IoTHubSharedAccessPolicyArrayOutput struct{ *pulumi.OutputState }

func (IoTHubSharedAccessPolicyArrayOutput) ElementType 

func (IoTHubSharedAccessPolicyArrayOutput) ElementType() reflect.Type

func (IoTHubSharedAccessPolicyArrayOutput) Index 

func (o IoTHubSharedAccessPolicyArrayOutput) Index(i pulumi.IntInput) IoTHubSharedAccessPolicyOutput

func (IoTHubSharedAccessPolicyArrayOutput) ToIoTHubSharedAccessPolicyArrayOutput 

func (o IoTHubSharedAccessPolicyArrayOutput) ToIoTHubSharedAccessPolicyArrayOutput() IoTHubSharedAccessPolicyArrayOutput

func (IoTHubSharedAccessPolicyArrayOutput) ToIoTHubSharedAccessPolicyArrayOutputWithContext 

func (o IoTHubSharedAccessPolicyArrayOutput) ToIoTHubSharedAccessPolicyArrayOutputWithContext(ctx context.Context) IoTHubSharedAccessPolicyArrayOutput

type IoTHubSharedAccessPolicyInput 

type IoTHubSharedAccessPolicyInput interface {
	pulumi.Input

	ToIoTHubSharedAccessPolicyOutput() IoTHubSharedAccessPolicyOutput
	ToIoTHubSharedAccessPolicyOutputWithContext(context.Context) IoTHubSharedAccessPolicyOutput
}

IoTHubSharedAccessPolicyInput is an input type that accepts IoTHubSharedAccessPolicyArgs and IoTHubSharedAccessPolicyOutput values. You can construct a concrete instance of `IoTHubSharedAccessPolicyInput` via: 

IoTHubSharedAccessPolicyArgs{...}

type IoTHubSharedAccessPolicyOutput 

type IoTHubSharedAccessPolicyOutput struct{ *pulumi.OutputState }

func (IoTHubSharedAccessPolicyOutput) ElementType 

func (IoTHubSharedAccessPolicyOutput) ElementType() reflect.Type

func (IoTHubSharedAccessPolicyOutput) KeyName 

func (o IoTHubSharedAccessPolicyOutput) KeyName() pulumi.StringPtrOutput

The name of the shared access policy.

func (IoTHubSharedAccessPolicyOutput) Permissions 

func (o IoTHubSharedAccessPolicyOutput) Permissions() pulumi.StringPtrOutput

The permissions assigned to the shared access policy.

func (IoTHubSharedAccessPolicyOutput) PrimaryKey 

func (o IoTHubSharedAccessPolicyOutput) PrimaryKey() pulumi.StringPtrOutput

The primary key.

func (IoTHubSharedAccessPolicyOutput) SecondaryKey 

func (o IoTHubSharedAccessPolicyOutput) SecondaryKey() pulumi.StringPtrOutput

The secondary key.

func (IoTHubSharedAccessPolicyOutput) ToIoTHubSharedAccessPolicyOutput 

func (o IoTHubSharedAccessPolicyOutput) ToIoTHubSharedAccessPolicyOutput() IoTHubSharedAccessPolicyOutput

func (IoTHubSharedAccessPolicyOutput) ToIoTHubSharedAccessPolicyOutputWithContext 

func (o IoTHubSharedAccessPolicyOutput) ToIoTHubSharedAccessPolicyOutputWithContext(ctx context.Context) IoTHubSharedAccessPolicyOutput

type IoTHubSku 

type IoTHubSku struct {
	// The number of provisioned IoT Hub units.
	Capacity int `pulumi:"capacity"`
	// The name of the sku. Possible values are `B1`, `B2`, `B3`, `F1`, `S1`, `S2`, and `S3`.
	Name string `pulumi:"name"`
}

type IoTHubSkuArgs 

type IoTHubSkuArgs struct {
	// The number of provisioned IoT Hub units.
	Capacity pulumi.IntInput `pulumi:"capacity"`
	// The name of the sku. Possible values are `B1`, `B2`, `B3`, `F1`, `S1`, `S2`, and `S3`.
	Name pulumi.StringInput `pulumi:"name"`
}

func (IoTHubSkuArgs) ElementType 

func (IoTHubSkuArgs) ElementType() reflect.Type

func (IoTHubSkuArgs) ToIoTHubSkuOutput 

func (i IoTHubSkuArgs) ToIoTHubSkuOutput() IoTHubSkuOutput

func (IoTHubSkuArgs) ToIoTHubSkuOutputWithContext 

func (i IoTHubSkuArgs) ToIoTHubSkuOutputWithContext(ctx context.Context) IoTHubSkuOutput

func (IoTHubSkuArgs) ToIoTHubSkuPtrOutput 

func (i IoTHubSkuArgs) ToIoTHubSkuPtrOutput() IoTHubSkuPtrOutput

func (IoTHubSkuArgs) ToIoTHubSkuPtrOutputWithContext 

func (i IoTHubSkuArgs) ToIoTHubSkuPtrOutputWithContext(ctx context.Context) IoTHubSkuPtrOutput

type IoTHubSkuInput 

type IoTHubSkuInput interface {
	pulumi.Input

	ToIoTHubSkuOutput() IoTHubSkuOutput
	ToIoTHubSkuOutputWithContext(context.Context) IoTHubSkuOutput
}

IoTHubSkuInput is an input type that accepts IoTHubSkuArgs and IoTHubSkuOutput values. You can construct a concrete instance of `IoTHubSkuInput` via: 

IoTHubSkuArgs{...}

type IoTHubSkuOutput 

type IoTHubSkuOutput struct{ *pulumi.OutputState }

func (IoTHubSkuOutput) Capacity 

func (o IoTHubSkuOutput) Capacity() pulumi.IntOutput

The number of provisioned IoT Hub units.

func (IoTHubSkuOutput) ElementType 

func (IoTHubSkuOutput) ElementType() reflect.Type

func (IoTHubSkuOutput) Name 

func (o IoTHubSkuOutput) Name() pulumi.StringOutput

The name of the sku. Possible values are `B1`, `B2`, `B3`, `F1`, `S1`, `S2`, and `S3`.

func (IoTHubSkuOutput) ToIoTHubSkuOutput 

func (o IoTHubSkuOutput) ToIoTHubSkuOutput() IoTHubSkuOutput

func (IoTHubSkuOutput) ToIoTHubSkuOutputWithContext 

func (o IoTHubSkuOutput) ToIoTHubSkuOutputWithContext(ctx context.Context) IoTHubSkuOutput

func (IoTHubSkuOutput) ToIoTHubSkuPtrOutput 

func (o IoTHubSkuOutput) ToIoTHubSkuPtrOutput() IoTHubSkuPtrOutput

func (IoTHubSkuOutput) ToIoTHubSkuPtrOutputWithContext 

func (o IoTHubSkuOutput) ToIoTHubSkuPtrOutputWithContext(ctx context.Context) IoTHubSkuPtrOutput

type IoTHubSkuPtrInput 

type IoTHubSkuPtrInput interface {
	pulumi.Input

	ToIoTHubSkuPtrOutput() IoTHubSkuPtrOutput
	ToIoTHubSkuPtrOutputWithContext(context.Context) IoTHubSkuPtrOutput
}

IoTHubSkuPtrInput is an input type that accepts IoTHubSkuArgs, IoTHubSkuPtr and IoTHubSkuPtrOutput values. You can construct a concrete instance of `IoTHubSkuPtrInput` via: 

        IoTHubSkuArgs{...}

or:

        nil

func IoTHubSkuPtr 

func IoTHubSkuPtr(v *IoTHubSkuArgs) IoTHubSkuPtrInput

type IoTHubSkuPtrOutput 

type IoTHubSkuPtrOutput struct{ *pulumi.OutputState }

func (IoTHubSkuPtrOutput) Capacity 

func (o IoTHubSkuPtrOutput) Capacity() pulumi.IntPtrOutput

The number of provisioned IoT Hub units.

func (IoTHubSkuPtrOutput) Elem 

func (o IoTHubSkuPtrOutput) Elem() IoTHubSkuOutput

func (IoTHubSkuPtrOutput) ElementType 

func (IoTHubSkuPtrOutput) ElementType() reflect.Type

func (IoTHubSkuPtrOutput) Name 

func (o IoTHubSkuPtrOutput) Name() pulumi.StringPtrOutput

The name of the sku. Possible values are `B1`, `B2`, `B3`, `F1`, `S1`, `S2`, and `S3`.

func (IoTHubSkuPtrOutput) ToIoTHubSkuPtrOutput 

func (o IoTHubSkuPtrOutput) ToIoTHubSkuPtrOutput() IoTHubSkuPtrOutput

func (IoTHubSkuPtrOutput) ToIoTHubSkuPtrOutputWithContext 

func (o IoTHubSkuPtrOutput) ToIoTHubSkuPtrOutputWithContext(ctx context.Context) IoTHubSkuPtrOutput

type IoTHubState 

type IoTHubState struct {
	// An `endpoint` block as defined below.
	Endpoints IoTHubEndpointArrayInput
	// The EventHub compatible endpoint for events data
	EventHubEventsEndpoint pulumi.StringPtrInput
	// The EventHub compatible path for events data
	EventHubEventsPath pulumi.StringPtrInput
	// The EventHub compatible endpoint for operational data
	EventHubOperationsEndpoint pulumi.StringPtrInput
	// The EventHub compatible path for operational data
	EventHubOperationsPath pulumi.StringPtrInput
	// The number of device-to-cloud partitions used by backing event hubs. Must be between `2` and `128`.
	EventHubPartitionCount pulumi.IntPtrInput
	// The event hub retention to use in days. Must be between `1` and `7`.
	EventHubRetentionInDays pulumi.IntPtrInput
	// A `fallbackRoute` block as defined below. If the fallback route is enabled, messages that don't match any of the supplied routes are automatically sent to this route. Defaults to messages/events.
	FallbackRoute IoTHubFallbackRoutePtrInput
	// A `fileUpload` block as defined below.
	FileUpload IoTHubFileUploadPtrInput
	// The hostname of the IotHub Resource.
	Hostname pulumi.StringPtrInput
	// One or more `ipFilterRule` blocks as defined below.
	IpFilterRules IoTHubIpFilterRuleArrayInput
	// Specifies the supported Azure location where the resource has to be createc. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the IotHub resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// Is the IotHub resource accessible from a public network?
	PublicNetworkAccessEnabled pulumi.BoolPtrInput
	// The name of the resource group under which the IotHub resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// A `route` block as defined below.
	Routes IoTHubRouteArrayInput
	// One or more `sharedAccessPolicy` blocks as defined below.
	SharedAccessPolicies IoTHubSharedAccessPolicyArrayInput
	// A `sku` block as defined below.
	Sku IoTHubSkuPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// The type of the endpoint. Possible values are `AzureIotHub.StorageContainer`, `AzureIotHub.ServiceBusQueue`, `AzureIotHub.ServiceBusTopic` or `AzureIotHub.EventHub`.
	Type pulumi.StringPtrInput
}

func (IoTHubState) ElementType 

func (IoTHubState) ElementType() reflect.Type

type IotHubCertificate 

type IotHubCertificate struct {
	pulumi.CustomResourceState

	// The Base-64 representation of the X509 leaf certificate .cer file or just a .pem file content.
	CertificateContent pulumi.StringOutput `pulumi:"certificateContent"`
	// The name of the IoT Device Provisioning Service that this certificate will be attached to. Changing this forces a new resource to be created.
	IotDpsName pulumi.StringOutput `pulumi:"iotDpsName"`
	// Specifies the name of the Iot Device Provisioning Service Certificate resource. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group under which the Iot Device Provisioning Service Certificate resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages an IotHub Device Provisioning Service Certificate.

## Import

IoTHub Device Provisioning Service Certificates can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/iotHubCertificate:IotHubCertificate example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/provisioningServices/example/certificates/example

```

func GetIotHubCertificate 

func GetIotHubCertificate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IotHubCertificateState, opts ...pulumi.ResourceOption) (*IotHubCertificate, error)

GetIotHubCertificate gets an existing IotHubCertificate resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIotHubCertificate 

func NewIotHubCertificate(ctx *pulumi.Context,
	name string, args *IotHubCertificateArgs, opts ...pulumi.ResourceOption) (*IotHubCertificate, error)

NewIotHubCertificate registers a new resource with the given unique name, arguments, and options.

func (IotHubCertificate) ElementType added in v3.31.1 

func (IotHubCertificate) ElementType() reflect.Type

func (IotHubCertificate) ToIotHubCertificateOutput added in v3.31.1 

func (i IotHubCertificate) ToIotHubCertificateOutput() IotHubCertificateOutput

func (IotHubCertificate) ToIotHubCertificateOutputWithContext added in v3.31.1 

func (i IotHubCertificate) ToIotHubCertificateOutputWithContext(ctx context.Context) IotHubCertificateOutput

type IotHubCertificateArgs 

type IotHubCertificateArgs struct {
	// The Base-64 representation of the X509 leaf certificate .cer file or just a .pem file content.
	CertificateContent pulumi.StringInput
	// The name of the IoT Device Provisioning Service that this certificate will be attached to. Changing this forces a new resource to be created.
	IotDpsName pulumi.StringInput
	// Specifies the name of the Iot Device Provisioning Service Certificate resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the Iot Device Provisioning Service Certificate resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a IotHubCertificate resource.

func (IotHubCertificateArgs) ElementType 

func (IotHubCertificateArgs) ElementType() reflect.Type

type IotHubCertificateInput added in v3.31.1 

type IotHubCertificateInput interface {
	pulumi.Input

	ToIotHubCertificateOutput() IotHubCertificateOutput
	ToIotHubCertificateOutputWithContext(ctx context.Context) IotHubCertificateOutput
}

type IotHubCertificateOutput added in v3.31.1 

type IotHubCertificateOutput struct {
	*pulumi.OutputState
}

func (IotHubCertificateOutput) ElementType added in v3.31.1 

func (IotHubCertificateOutput) ElementType() reflect.Type

func (IotHubCertificateOutput) ToIotHubCertificateOutput added in v3.31.1 

func (o IotHubCertificateOutput) ToIotHubCertificateOutput() IotHubCertificateOutput

func (IotHubCertificateOutput) ToIotHubCertificateOutputWithContext added in v3.31.1 

func (o IotHubCertificateOutput) ToIotHubCertificateOutputWithContext(ctx context.Context) IotHubCertificateOutput

type IotHubCertificateState 

type IotHubCertificateState struct {
	// The Base-64 representation of the X509 leaf certificate .cer file or just a .pem file content.
	CertificateContent pulumi.StringPtrInput
	// The name of the IoT Device Provisioning Service that this certificate will be attached to. Changing this forces a new resource to be created.
	IotDpsName pulumi.StringPtrInput
	// Specifies the name of the Iot Device Provisioning Service Certificate resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the Iot Device Provisioning Service Certificate resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
}

func (IotHubCertificateState) ElementType 

func (IotHubCertificateState) ElementType() reflect.Type

type IotHubDps 

type IotHubDps struct {
	pulumi.CustomResourceState

	// The allocation policy of the IoT Device Provisioning Service.
	AllocationPolicy pulumi.StringOutput `pulumi:"allocationPolicy"`
	// The device endpoint of the IoT Device Provisioning Service.
	DeviceProvisioningHostName pulumi.StringOutput `pulumi:"deviceProvisioningHostName"`
	// The unique identifier of the IoT Device Provisioning Service.
	IdScope pulumi.StringOutput `pulumi:"idScope"`
	// A `linkedHub` block as defined below.
	LinkedHubs IotHubDpsLinkedHubArrayOutput `pulumi:"linkedHubs"`
	// Specifies the supported Azure location where the resource has to be createc. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the Iot Device Provisioning Service resource. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group under which the Iot Device Provisioning Service resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// The service endpoint of the IoT Device Provisioning Service.
	ServiceOperationsHostName pulumi.StringOutput `pulumi:"serviceOperationsHostName"`
	// A `sku` block as defined below.
	Sku IotHubDpsSkuOutput `pulumi:"sku"`
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Manages an IotHub Device Provisioning Service.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West US"),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewIotHubDps(ctx, "exampleIotHubDps", &iot.IotHubDpsArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IotHubDpsSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoT Device Provisioning Service can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/iotHubDps:IotHubDps example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/provisioningServices/example

```

func GetIotHubDps 

func GetIotHubDps(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IotHubDpsState, opts ...pulumi.ResourceOption) (*IotHubDps, error)

GetIotHubDps gets an existing IotHubDps resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIotHubDps 

func NewIotHubDps(ctx *pulumi.Context,
	name string, args *IotHubDpsArgs, opts ...pulumi.ResourceOption) (*IotHubDps, error)

NewIotHubDps registers a new resource with the given unique name, arguments, and options.

func (IotHubDps) ElementType added in v3.31.1 

func (IotHubDps) ElementType() reflect.Type

func (IotHubDps) ToIotHubDpsOutput added in v3.31.1 

func (i IotHubDps) ToIotHubDpsOutput() IotHubDpsOutput

func (IotHubDps) ToIotHubDpsOutputWithContext added in v3.31.1 

func (i IotHubDps) ToIotHubDpsOutputWithContext(ctx context.Context) IotHubDpsOutput

type IotHubDpsArgs 

type IotHubDpsArgs struct {
	// A `linkedHub` block as defined below.
	LinkedHubs IotHubDpsLinkedHubArrayInput
	// Specifies the supported Azure location where the resource has to be createc. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Iot Device Provisioning Service resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the Iot Device Provisioning Service resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// A `sku` block as defined below.
	Sku IotHubDpsSkuInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a IotHubDps resource.

func (IotHubDpsArgs) ElementType 

func (IotHubDpsArgs) ElementType() reflect.Type

type IotHubDpsInput added in v3.31.1 

type IotHubDpsInput interface {
	pulumi.Input

	ToIotHubDpsOutput() IotHubDpsOutput
	ToIotHubDpsOutputWithContext(ctx context.Context) IotHubDpsOutput
}

type IotHubDpsLinkedHub 

type IotHubDpsLinkedHub struct {
	// The weight applied to the IoT Hub. Defaults to 0.
	AllocationWeight *int `pulumi:"allocationWeight"`
	// Determines whether to apply allocation policies to the IoT Hub. Defaults to false.
	ApplyAllocationPolicy *bool `pulumi:"applyAllocationPolicy"`
	// The connection string to connect to the IoT Hub. Changing this forces a new resource.
	ConnectionString string `pulumi:"connectionString"`
	// The IoT Hub hostname.
	Hostname *string `pulumi:"hostname"`
	// The location of the IoT hub. Changing this forces a new resource.
	Location string `pulumi:"location"`
}

type IotHubDpsLinkedHubArgs 

type IotHubDpsLinkedHubArgs struct {
	// The weight applied to the IoT Hub. Defaults to 0.
	AllocationWeight pulumi.IntPtrInput `pulumi:"allocationWeight"`
	// Determines whether to apply allocation policies to the IoT Hub. Defaults to false.
	ApplyAllocationPolicy pulumi.BoolPtrInput `pulumi:"applyAllocationPolicy"`
	// The connection string to connect to the IoT Hub. Changing this forces a new resource.
	ConnectionString pulumi.StringInput `pulumi:"connectionString"`
	// The IoT Hub hostname.
	Hostname pulumi.StringPtrInput `pulumi:"hostname"`
	// The location of the IoT hub. Changing this forces a new resource.
	Location pulumi.StringInput `pulumi:"location"`
}

func (IotHubDpsLinkedHubArgs) ElementType 

func (IotHubDpsLinkedHubArgs) ElementType() reflect.Type

func (IotHubDpsLinkedHubArgs) ToIotHubDpsLinkedHubOutput 

func (i IotHubDpsLinkedHubArgs) ToIotHubDpsLinkedHubOutput() IotHubDpsLinkedHubOutput

func (IotHubDpsLinkedHubArgs) ToIotHubDpsLinkedHubOutputWithContext 

func (i IotHubDpsLinkedHubArgs) ToIotHubDpsLinkedHubOutputWithContext(ctx context.Context) IotHubDpsLinkedHubOutput

type IotHubDpsLinkedHubArray 

type IotHubDpsLinkedHubArray []IotHubDpsLinkedHubInput

func (IotHubDpsLinkedHubArray) ElementType 

func (IotHubDpsLinkedHubArray) ElementType() reflect.Type

func (IotHubDpsLinkedHubArray) ToIotHubDpsLinkedHubArrayOutput 

func (i IotHubDpsLinkedHubArray) ToIotHubDpsLinkedHubArrayOutput() IotHubDpsLinkedHubArrayOutput

func (IotHubDpsLinkedHubArray) ToIotHubDpsLinkedHubArrayOutputWithContext 

func (i IotHubDpsLinkedHubArray) ToIotHubDpsLinkedHubArrayOutputWithContext(ctx context.Context) IotHubDpsLinkedHubArrayOutput

type IotHubDpsLinkedHubArrayInput 

type IotHubDpsLinkedHubArrayInput interface {
	pulumi.Input

	ToIotHubDpsLinkedHubArrayOutput() IotHubDpsLinkedHubArrayOutput
	ToIotHubDpsLinkedHubArrayOutputWithContext(context.Context) IotHubDpsLinkedHubArrayOutput
}

IotHubDpsLinkedHubArrayInput is an input type that accepts IotHubDpsLinkedHubArray and IotHubDpsLinkedHubArrayOutput values. You can construct a concrete instance of `IotHubDpsLinkedHubArrayInput` via: 

IotHubDpsLinkedHubArray{ IotHubDpsLinkedHubArgs{...} }

type IotHubDpsLinkedHubArrayOutput 

type IotHubDpsLinkedHubArrayOutput struct{ *pulumi.OutputState }

func (IotHubDpsLinkedHubArrayOutput) ElementType 

func (IotHubDpsLinkedHubArrayOutput) ElementType() reflect.Type

func (IotHubDpsLinkedHubArrayOutput) Index 

func (o IotHubDpsLinkedHubArrayOutput) Index(i pulumi.IntInput) IotHubDpsLinkedHubOutput

func (IotHubDpsLinkedHubArrayOutput) ToIotHubDpsLinkedHubArrayOutput 

func (o IotHubDpsLinkedHubArrayOutput) ToIotHubDpsLinkedHubArrayOutput() IotHubDpsLinkedHubArrayOutput

func (IotHubDpsLinkedHubArrayOutput) ToIotHubDpsLinkedHubArrayOutputWithContext 

func (o IotHubDpsLinkedHubArrayOutput) ToIotHubDpsLinkedHubArrayOutputWithContext(ctx context.Context) IotHubDpsLinkedHubArrayOutput

type IotHubDpsLinkedHubInput 

type IotHubDpsLinkedHubInput interface {
	pulumi.Input

	ToIotHubDpsLinkedHubOutput() IotHubDpsLinkedHubOutput
	ToIotHubDpsLinkedHubOutputWithContext(context.Context) IotHubDpsLinkedHubOutput
}

IotHubDpsLinkedHubInput is an input type that accepts IotHubDpsLinkedHubArgs and IotHubDpsLinkedHubOutput values. You can construct a concrete instance of `IotHubDpsLinkedHubInput` via: 

IotHubDpsLinkedHubArgs{...}

type IotHubDpsLinkedHubOutput 

type IotHubDpsLinkedHubOutput struct{ *pulumi.OutputState }

func (IotHubDpsLinkedHubOutput) AllocationWeight 

func (o IotHubDpsLinkedHubOutput) AllocationWeight() pulumi.IntPtrOutput

The weight applied to the IoT Hub. Defaults to 0.

func (IotHubDpsLinkedHubOutput) ApplyAllocationPolicy 

func (o IotHubDpsLinkedHubOutput) ApplyAllocationPolicy() pulumi.BoolPtrOutput

Determines whether to apply allocation policies to the IoT Hub. Defaults to false.

func (IotHubDpsLinkedHubOutput) ConnectionString 

func (o IotHubDpsLinkedHubOutput) ConnectionString() pulumi.StringOutput

The connection string to connect to the IoT Hub. Changing this forces a new resource.

func (IotHubDpsLinkedHubOutput) ElementType 

func (IotHubDpsLinkedHubOutput) ElementType() reflect.Type

func (IotHubDpsLinkedHubOutput) Hostname 

func (o IotHubDpsLinkedHubOutput) Hostname() pulumi.StringPtrOutput

The IoT Hub hostname.

func (IotHubDpsLinkedHubOutput) Location 

func (o IotHubDpsLinkedHubOutput) Location() pulumi.StringOutput

The location of the IoT hub. Changing this forces a new resource.

func (IotHubDpsLinkedHubOutput) ToIotHubDpsLinkedHubOutput 

func (o IotHubDpsLinkedHubOutput) ToIotHubDpsLinkedHubOutput() IotHubDpsLinkedHubOutput

func (IotHubDpsLinkedHubOutput) ToIotHubDpsLinkedHubOutputWithContext 

func (o IotHubDpsLinkedHubOutput) ToIotHubDpsLinkedHubOutputWithContext(ctx context.Context) IotHubDpsLinkedHubOutput

type IotHubDpsOutput added in v3.31.1 

type IotHubDpsOutput struct {
	*pulumi.OutputState
}

func (IotHubDpsOutput) ElementType added in v3.31.1 

func (IotHubDpsOutput) ElementType() reflect.Type

func (IotHubDpsOutput) ToIotHubDpsOutput added in v3.31.1 

func (o IotHubDpsOutput) ToIotHubDpsOutput() IotHubDpsOutput

func (IotHubDpsOutput) ToIotHubDpsOutputWithContext added in v3.31.1 

func (o IotHubDpsOutput) ToIotHubDpsOutputWithContext(ctx context.Context) IotHubDpsOutput

type IotHubDpsSku 

type IotHubDpsSku struct {
	// The number of provisioned IoT Device Provisioning Service units.
	Capacity int `pulumi:"capacity"`
	// The name of the sku. Currently can only be set to `S1`.
	Name string `pulumi:"name"`
}

type IotHubDpsSkuArgs 

type IotHubDpsSkuArgs struct {
	// The number of provisioned IoT Device Provisioning Service units.
	Capacity pulumi.IntInput `pulumi:"capacity"`
	// The name of the sku. Currently can only be set to `S1`.
	Name pulumi.StringInput `pulumi:"name"`
}

func (IotHubDpsSkuArgs) ElementType 

func (IotHubDpsSkuArgs) ElementType() reflect.Type

func (IotHubDpsSkuArgs) ToIotHubDpsSkuOutput 

func (i IotHubDpsSkuArgs) ToIotHubDpsSkuOutput() IotHubDpsSkuOutput

func (IotHubDpsSkuArgs) ToIotHubDpsSkuOutputWithContext 

func (i IotHubDpsSkuArgs) ToIotHubDpsSkuOutputWithContext(ctx context.Context) IotHubDpsSkuOutput

func (IotHubDpsSkuArgs) ToIotHubDpsSkuPtrOutput 

func (i IotHubDpsSkuArgs) ToIotHubDpsSkuPtrOutput() IotHubDpsSkuPtrOutput

func (IotHubDpsSkuArgs) ToIotHubDpsSkuPtrOutputWithContext 

func (i IotHubDpsSkuArgs) ToIotHubDpsSkuPtrOutputWithContext(ctx context.Context) IotHubDpsSkuPtrOutput

type IotHubDpsSkuInput 

type IotHubDpsSkuInput interface {
	pulumi.Input

	ToIotHubDpsSkuOutput() IotHubDpsSkuOutput
	ToIotHubDpsSkuOutputWithContext(context.Context) IotHubDpsSkuOutput
}

IotHubDpsSkuInput is an input type that accepts IotHubDpsSkuArgs and IotHubDpsSkuOutput values. You can construct a concrete instance of `IotHubDpsSkuInput` via: 

IotHubDpsSkuArgs{...}

type IotHubDpsSkuOutput 

type IotHubDpsSkuOutput struct{ *pulumi.OutputState }

func (IotHubDpsSkuOutput) Capacity 

func (o IotHubDpsSkuOutput) Capacity() pulumi.IntOutput

The number of provisioned IoT Device Provisioning Service units.

func (IotHubDpsSkuOutput) ElementType 

func (IotHubDpsSkuOutput) ElementType() reflect.Type

func (IotHubDpsSkuOutput) Name 

func (o IotHubDpsSkuOutput) Name() pulumi.StringOutput

The name of the sku. Currently can only be set to `S1`.

func (IotHubDpsSkuOutput) ToIotHubDpsSkuOutput 

func (o IotHubDpsSkuOutput) ToIotHubDpsSkuOutput() IotHubDpsSkuOutput

func (IotHubDpsSkuOutput) ToIotHubDpsSkuOutputWithContext 

func (o IotHubDpsSkuOutput) ToIotHubDpsSkuOutputWithContext(ctx context.Context) IotHubDpsSkuOutput

func (IotHubDpsSkuOutput) ToIotHubDpsSkuPtrOutput 

func (o IotHubDpsSkuOutput) ToIotHubDpsSkuPtrOutput() IotHubDpsSkuPtrOutput

func (IotHubDpsSkuOutput) ToIotHubDpsSkuPtrOutputWithContext 

func (o IotHubDpsSkuOutput) ToIotHubDpsSkuPtrOutputWithContext(ctx context.Context) IotHubDpsSkuPtrOutput

type IotHubDpsSkuPtrInput 

type IotHubDpsSkuPtrInput interface {
	pulumi.Input

	ToIotHubDpsSkuPtrOutput() IotHubDpsSkuPtrOutput
	ToIotHubDpsSkuPtrOutputWithContext(context.Context) IotHubDpsSkuPtrOutput
}

IotHubDpsSkuPtrInput is an input type that accepts IotHubDpsSkuArgs, IotHubDpsSkuPtr and IotHubDpsSkuPtrOutput values. You can construct a concrete instance of `IotHubDpsSkuPtrInput` via: 

        IotHubDpsSkuArgs{...}

or:

        nil

func IotHubDpsSkuPtr 

func IotHubDpsSkuPtr(v *IotHubDpsSkuArgs) IotHubDpsSkuPtrInput

type IotHubDpsSkuPtrOutput 

type IotHubDpsSkuPtrOutput struct{ *pulumi.OutputState }

func (IotHubDpsSkuPtrOutput) Capacity 

func (o IotHubDpsSkuPtrOutput) Capacity() pulumi.IntPtrOutput

The number of provisioned IoT Device Provisioning Service units.

func (IotHubDpsSkuPtrOutput) Elem 

func (o IotHubDpsSkuPtrOutput) Elem() IotHubDpsSkuOutput

func (IotHubDpsSkuPtrOutput) ElementType 

func (IotHubDpsSkuPtrOutput) ElementType() reflect.Type

func (IotHubDpsSkuPtrOutput) Name 

func (o IotHubDpsSkuPtrOutput) Name() pulumi.StringPtrOutput

The name of the sku. Currently can only be set to `S1`.

func (IotHubDpsSkuPtrOutput) ToIotHubDpsSkuPtrOutput 

func (o IotHubDpsSkuPtrOutput) ToIotHubDpsSkuPtrOutput() IotHubDpsSkuPtrOutput

func (IotHubDpsSkuPtrOutput) ToIotHubDpsSkuPtrOutputWithContext 

func (o IotHubDpsSkuPtrOutput) ToIotHubDpsSkuPtrOutputWithContext(ctx context.Context) IotHubDpsSkuPtrOutput

type IotHubDpsState 

type IotHubDpsState struct {
	// The allocation policy of the IoT Device Provisioning Service.
	AllocationPolicy pulumi.StringPtrInput
	// The device endpoint of the IoT Device Provisioning Service.
	DeviceProvisioningHostName pulumi.StringPtrInput
	// The unique identifier of the IoT Device Provisioning Service.
	IdScope pulumi.StringPtrInput
	// A `linkedHub` block as defined below.
	LinkedHubs IotHubDpsLinkedHubArrayInput
	// Specifies the supported Azure location where the resource has to be createc. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Iot Device Provisioning Service resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the Iot Device Provisioning Service resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// The service endpoint of the IoT Device Provisioning Service.
	ServiceOperationsHostName pulumi.StringPtrInput
	// A `sku` block as defined below.
	Sku IotHubDpsSkuPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (IotHubDpsState) ElementType 

func (IotHubDpsState) ElementType() reflect.Type

type LookupDpsSharedAccessPolicyArgs 

type LookupDpsSharedAccessPolicyArgs struct {
	// Specifies the name of the IoT Hub Device Provisioning service to which the Shared Access Policy belongs.
	IothubDpsName string `pulumi:"iothubDpsName"`
	// Specifies the name of the IotHub Shared Access Policy.
	Name string `pulumi:"name"`
	// Specifies the name of the resource group under which the IotHub Shared Access Policy resource exists.
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getDpsSharedAccessPolicy.

type LookupDpsSharedAccessPolicyResult 

type LookupDpsSharedAccessPolicyResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id            string `pulumi:"id"`
	IothubDpsName string `pulumi:"iothubDpsName"`
	Name          string `pulumi:"name"`
	// The primary connection string of the Shared Access Policy.
	PrimaryConnectionString string `pulumi:"primaryConnectionString"`
	// The primary key used to create the authentication token.
	PrimaryKey        string `pulumi:"primaryKey"`
	ResourceGroupName string `pulumi:"resourceGroupName"`
	// The secondary connection string of the Shared Access Policy.
	SecondaryConnectionString string `pulumi:"secondaryConnectionString"`
	// The secondary key used to create the authentication token.
	SecondaryKey string `pulumi:"secondaryKey"`
}

A collection of values returned by getDpsSharedAccessPolicy.

func LookupDpsSharedAccessPolicy 

func LookupDpsSharedAccessPolicy(ctx *pulumi.Context, args *LookupDpsSharedAccessPolicyArgs, opts ...pulumi.InvokeOption) (*LookupDpsSharedAccessPolicyResult, error)

Use this data source to access information about an existing IotHub Device Provisioning Service Shared Access Policy

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iot.LookupDpsSharedAccessPolicy(ctx, &iot.LookupDpsSharedAccessPolicyArgs{
			Name:              "example",
			ResourceGroupName: azurerm_resource_group.Example.Name,
			IothubDpsName:     azurerm_iothub_dps.Example.Name,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupSharedAccessPolicyArgs 

type LookupSharedAccessPolicyArgs struct {
	// The name of the IoTHub to which this Shared Access Policy belongs.
	IothubName string `pulumi:"iothubName"`
	// Specifies the name of the IotHub Shared Access Policy resource.
	Name string `pulumi:"name"`
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created.
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getSharedAccessPolicy.

type LookupSharedAccessPolicyResult 

type LookupSharedAccessPolicyResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id         string `pulumi:"id"`
	IothubName string `pulumi:"iothubName"`
	Name       string `pulumi:"name"`
	// The primary connection string of the Shared Access Policy.
	PrimaryConnectionString string `pulumi:"primaryConnectionString"`
	// The primary key used to create the authentication token.
	PrimaryKey        string `pulumi:"primaryKey"`
	ResourceGroupName string `pulumi:"resourceGroupName"`
	// The secondary connection string of the Shared Access Policy.
	SecondaryConnectionString string `pulumi:"secondaryConnectionString"`
	// The secondary key used to create the authentication token.
	SecondaryKey string `pulumi:"secondaryKey"`
}

A collection of values returned by getSharedAccessPolicy.

func LookupSharedAccessPolicy 

func LookupSharedAccessPolicy(ctx *pulumi.Context, args *LookupSharedAccessPolicyArgs, opts ...pulumi.InvokeOption) (*LookupSharedAccessPolicyResult, error)

Use this data source to access information about an existing IotHub Shared Access Policy

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iot.LookupSharedAccessPolicy(ctx, &iot.LookupSharedAccessPolicyArgs{
			Name:              "example",
			ResourceGroupName: azurerm_resource_group.Example.Name,
			IothubName:        azurerm_iothub.Example.Name,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type Route 

type Route struct {
	pulumi.CustomResourceState

	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to `true` by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrOutput `pulumi:"condition"`
	// Specifies whether a route is enabled.
	Enabled pulumi.BoolOutput `pulumi:"enabled"`
	// The list of endpoints to which messages that satisfy the condition are routed. Currently only one endpoint is allowed.
	EndpointNames pulumi.StringOutput `pulumi:"endpointNames"`
	// The name of the IoTHub to which this Route belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringOutput `pulumi:"iothubName"`
	// The name of the route.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group under which the IotHub Route resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// The source that the routing rule is to be applied to. Possible values include: `DeviceJobLifecycleEvents`, `DeviceLifecycleEvents`, `DeviceMessages`, `Invalid`, `TwinChangeEvents`.
	Source pulumi.StringOutput `pulumi:"source"`
}

Manages an IotHub Route

> **NOTE:** Routes can be defined either directly on the `iot.IoTHub` resource, or using the `iot.Route` resourcs - but the two cannot be used together. If both are used against the same IoTHub, spurious changes will occur.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/storage"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West US"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleContainer, err := storage.NewContainer(ctx, "exampleContainer", &storage.ContainerArgs{
			StorageAccountName:  exampleAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
			Tags: pulumi.StringMap{
				"purpose": pulumi.String("testing"),
			},
		})
		if err != nil {
			return err
		}
		exampleEndpointStorageContainer, err := iot.NewEndpointStorageContainer(ctx, "exampleEndpointStorageContainer", &iot.EndpointStorageContainerArgs{
			ResourceGroupName:       exampleResourceGroup.Name,
			IothubName:              exampleIoTHub.Name,
			ConnectionString:        exampleAccount.PrimaryBlobConnectionString,
			BatchFrequencyInSeconds: pulumi.Int(60),
			MaxChunkSizeInBytes:     pulumi.Int(10485760),
			ContainerName:           exampleContainer.Name,
			Encoding:                pulumi.String("Avro"),
			FileNameFormat:          pulumi.String("{iothub}/{partition}_{YYYY}_{MM}_{DD}_{HH}_{mm}"),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewRoute(ctx, "exampleRoute", &iot.RouteArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubName:        exampleIoTHub.Name,
			Source:            pulumi.String("DeviceMessages"),
			Condition:         pulumi.String("true"),
			EndpointNames: pulumi.String(pulumi.String{
				exampleEndpointStorageContainer.Name,
			}),
			Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub Route can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/route:Route route1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/Routes/route1

```

func GetRoute 

func GetRoute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RouteState, opts ...pulumi.ResourceOption) (*Route, error)

GetRoute gets an existing Route resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRoute 

func NewRoute(ctx *pulumi.Context,
	name string, args *RouteArgs, opts ...pulumi.ResourceOption) (*Route, error)

NewRoute registers a new resource with the given unique name, arguments, and options.

func (Route) ElementType added in v3.31.1 

func (Route) ElementType() reflect.Type

func (Route) ToRouteOutput added in v3.31.1 

func (i Route) ToRouteOutput() RouteOutput

func (Route) ToRouteOutputWithContext added in v3.31.1 

func (i Route) ToRouteOutputWithContext(ctx context.Context) RouteOutput

type RouteArgs 

type RouteArgs struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to `true` by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrInput
	// Specifies whether a route is enabled.
	Enabled pulumi.BoolInput
	// The list of endpoints to which messages that satisfy the condition are routed. Currently only one endpoint is allowed.
	EndpointNames pulumi.StringInput
	// The name of the IoTHub to which this Route belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringInput
	// The name of the route.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the IotHub Route resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// The source that the routing rule is to be applied to. Possible values include: `DeviceJobLifecycleEvents`, `DeviceLifecycleEvents`, `DeviceMessages`, `Invalid`, `TwinChangeEvents`.
	Source pulumi.StringInput
}

The set of arguments for constructing a Route resource.

func (RouteArgs) ElementType 

func (RouteArgs) ElementType() reflect.Type

type RouteInput added in v3.31.1 

type RouteInput interface {
	pulumi.Input

	ToRouteOutput() RouteOutput
	ToRouteOutputWithContext(ctx context.Context) RouteOutput
}

type RouteOutput added in v3.31.1 

type RouteOutput struct {
	*pulumi.OutputState
}

func (RouteOutput) ElementType added in v3.31.1 

func (RouteOutput) ElementType() reflect.Type

func (RouteOutput) ToRouteOutput added in v3.31.1 

func (o RouteOutput) ToRouteOutput() RouteOutput

func (RouteOutput) ToRouteOutputWithContext added in v3.31.1 

func (o RouteOutput) ToRouteOutputWithContext(ctx context.Context) RouteOutput

type RouteState 

type RouteState struct {
	// The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to `true` by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
	Condition pulumi.StringPtrInput
	// Specifies whether a route is enabled.
	Enabled pulumi.BoolPtrInput
	// The list of endpoints to which messages that satisfy the condition are routed. Currently only one endpoint is allowed.
	EndpointNames pulumi.StringPtrInput
	// The name of the IoTHub to which this Route belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringPtrInput
	// The name of the route.
	Name pulumi.StringPtrInput
	// The name of the resource group under which the IotHub Route resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// The source that the routing rule is to be applied to. Possible values include: `DeviceJobLifecycleEvents`, `DeviceLifecycleEvents`, `DeviceMessages`, `Invalid`, `TwinChangeEvents`.
	Source pulumi.StringPtrInput
}

func (RouteState) ElementType 

func (RouteState) ElementType() reflect.Type

type SharedAccessPolicy 

type SharedAccessPolicy struct {
	pulumi.CustomResourceState

	// Adds `DeviceConnect` permission to this Shared Access Account. It allows sending and receiving on the device-side endpoints.
	DeviceConnect pulumi.BoolPtrOutput `pulumi:"deviceConnect"`
	// The name of the IoTHub to which this Shared Access Policy belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringOutput `pulumi:"iothubName"`
	// Specifies the name of the IotHub Shared Access Policy resource. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The primary connection string of the Shared Access Policy.
	PrimaryConnectionString pulumi.StringOutput `pulumi:"primaryConnectionString"`
	// The primary key used to create the authentication token.
	PrimaryKey pulumi.StringOutput `pulumi:"primaryKey"`
	// Adds `RegistryRead` permission to this Shared Access Account. It allows read access to the identity registry.
	RegistryRead pulumi.BoolPtrOutput `pulumi:"registryRead"`
	// Adds `RegistryWrite` permission to this Shared Access Account. It allows write access to the identity registry.
	RegistryWrite pulumi.BoolPtrOutput `pulumi:"registryWrite"`
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// The secondary connection string of the Shared Access Policy.
	SecondaryConnectionString pulumi.StringOutput `pulumi:"secondaryConnectionString"`
	// The secondary key used to create the authentication token.
	SecondaryKey pulumi.StringOutput `pulumi:"secondaryKey"`
	// Adds `ServiceConnect` permission to this Shared Access Account. It allows sending and receiving on the cloud-side endpoints.
	ServiceConnect pulumi.BoolPtrOutput `pulumi:"serviceConnect"`
}

Manages an IotHub Shared Access Policy

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West US"),
		})
		if err != nil {
			return err
		}
		exampleIoTHub, err := iot.NewIoTHub(ctx, "exampleIoTHub", &iot.IoTHubArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &iot.IoTHubSkuArgs{
				Name:     pulumi.String("S1"),
				Capacity: pulumi.Int(1),
			},
		})
		if err != nil {
			return err
		}
		_, err = iot.NewSharedAccessPolicy(ctx, "exampleSharedAccessPolicy", &iot.SharedAccessPolicyArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			IothubName:        exampleIoTHub.Name,
			RegistryRead:      pulumi.Bool(true),
			RegistryWrite:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

IoTHub Shared Access Policies can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/sharedAccessPolicy:SharedAccessPolicy shared_access_policy1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Devices/IotHubs/hub1/IotHubKeys/shared_access_policy1

```

func GetSharedAccessPolicy 

func GetSharedAccessPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SharedAccessPolicyState, opts ...pulumi.ResourceOption) (*SharedAccessPolicy, error)

GetSharedAccessPolicy gets an existing SharedAccessPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSharedAccessPolicy 

func NewSharedAccessPolicy(ctx *pulumi.Context,
	name string, args *SharedAccessPolicyArgs, opts ...pulumi.ResourceOption) (*SharedAccessPolicy, error)

NewSharedAccessPolicy registers a new resource with the given unique name, arguments, and options.

func (SharedAccessPolicy) ElementType added in v3.31.1 

func (SharedAccessPolicy) ElementType() reflect.Type

func (SharedAccessPolicy) ToSharedAccessPolicyOutput added in v3.31.1 

func (i SharedAccessPolicy) ToSharedAccessPolicyOutput() SharedAccessPolicyOutput

func (SharedAccessPolicy) ToSharedAccessPolicyOutputWithContext added in v3.31.1 

func (i SharedAccessPolicy) ToSharedAccessPolicyOutputWithContext(ctx context.Context) SharedAccessPolicyOutput

type SharedAccessPolicyArgs 

type SharedAccessPolicyArgs struct {
	// Adds `DeviceConnect` permission to this Shared Access Account. It allows sending and receiving on the device-side endpoints.
	DeviceConnect pulumi.BoolPtrInput
	// The name of the IoTHub to which this Shared Access Policy belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringInput
	// Specifies the name of the IotHub Shared Access Policy resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// Adds `RegistryRead` permission to this Shared Access Account. It allows read access to the identity registry.
	RegistryRead pulumi.BoolPtrInput
	// Adds `RegistryWrite` permission to this Shared Access Account. It allows write access to the identity registry.
	RegistryWrite pulumi.BoolPtrInput
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// Adds `ServiceConnect` permission to this Shared Access Account. It allows sending and receiving on the cloud-side endpoints.
	ServiceConnect pulumi.BoolPtrInput
}

The set of arguments for constructing a SharedAccessPolicy resource.

func (SharedAccessPolicyArgs) ElementType 

func (SharedAccessPolicyArgs) ElementType() reflect.Type

type SharedAccessPolicyInput added in v3.31.1 

type SharedAccessPolicyInput interface {
	pulumi.Input

	ToSharedAccessPolicyOutput() SharedAccessPolicyOutput
	ToSharedAccessPolicyOutputWithContext(ctx context.Context) SharedAccessPolicyOutput
}

type SharedAccessPolicyOutput added in v3.31.1 

type SharedAccessPolicyOutput struct {
	*pulumi.OutputState
}

func (SharedAccessPolicyOutput) ElementType added in v3.31.1 

func (SharedAccessPolicyOutput) ElementType() reflect.Type

func (SharedAccessPolicyOutput) ToSharedAccessPolicyOutput added in v3.31.1 

func (o SharedAccessPolicyOutput) ToSharedAccessPolicyOutput() SharedAccessPolicyOutput

func (SharedAccessPolicyOutput) ToSharedAccessPolicyOutputWithContext added in v3.31.1 

func (o SharedAccessPolicyOutput) ToSharedAccessPolicyOutputWithContext(ctx context.Context) SharedAccessPolicyOutput

type SharedAccessPolicyState 

type SharedAccessPolicyState struct {
	// Adds `DeviceConnect` permission to this Shared Access Account. It allows sending and receiving on the device-side endpoints.
	DeviceConnect pulumi.BoolPtrInput
	// The name of the IoTHub to which this Shared Access Policy belongs. Changing this forces a new resource to be created.
	IothubName pulumi.StringPtrInput
	// Specifies the name of the IotHub Shared Access Policy resource. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The primary connection string of the Shared Access Policy.
	PrimaryConnectionString pulumi.StringPtrInput
	// The primary key used to create the authentication token.
	PrimaryKey pulumi.StringPtrInput
	// Adds `RegistryRead` permission to this Shared Access Account. It allows read access to the identity registry.
	RegistryRead pulumi.BoolPtrInput
	// Adds `RegistryWrite` permission to this Shared Access Account. It allows write access to the identity registry.
	RegistryWrite pulumi.BoolPtrInput
	// The name of the resource group under which the IotHub Shared Access Policy resource has to be created. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// The secondary connection string of the Shared Access Policy.
	SecondaryConnectionString pulumi.StringPtrInput
	// The secondary key used to create the authentication token.
	SecondaryKey pulumi.StringPtrInput
	// Adds `ServiceConnect` permission to this Shared Access Account. It allows sending and receiving on the cloud-side endpoints.
	ServiceConnect pulumi.BoolPtrInput
}

func (SharedAccessPolicyState) ElementType 

func (SharedAccessPolicyState) ElementType() reflect.Type

type TimeSeriesInsightsAccessPolicy added in v3.9.0 

type TimeSeriesInsightsAccessPolicy struct {
	pulumi.CustomResourceState

	// The description of the Azure IoT Time Series Insights Access Policy.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Specifies the name of the Azure IoT Time Series Insights Access Policy. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringOutput `pulumi:"name"`
	// The id of the principal in Azure Active Directory.
	PrincipalObjectId pulumi.StringOutput `pulumi:"principalObjectId"`
	// A list of roles to apply to the Access Policy. Valid values include `Contributor` and `Reader`.
	Roles pulumi.StringArrayOutput `pulumi:"roles"`
	// The resource ID of the Azure IoT Time Series Insights Environment in which to create the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created.
	TimeSeriesInsightsEnvironmentId pulumi.StringOutput `pulumi:"timeSeriesInsightsEnvironmentId"`
}

Manages an Azure IoT Time Series Insights Access Policy.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("northeurope"),
		})
		if err != nil {
			return err
		}
		exampleTimeSeriesInsightsStandardEnvironment, err := iot.NewTimeSeriesInsightsStandardEnvironment(ctx, "exampleTimeSeriesInsightsStandardEnvironment", &iot.TimeSeriesInsightsStandardEnvironmentArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			SkuName:           pulumi.String("S1_1"),
			DataRetentionTime: pulumi.String("P30D"),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewTimeSeriesInsightsAccessPolicy(ctx, "exampleTimeSeriesInsightsAccessPolicy", &iot.TimeSeriesInsightsAccessPolicyArgs{
			TimeSeriesInsightsEnvironmentId: exampleTimeSeriesInsightsStandardEnvironment.Name,
			PrincipalObjectId:               pulumi.String("aGUID"),
			Roles: pulumi.StringArray{
				pulumi.String("Reader"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Azure IoT Time Series Insights Access Policy can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/timeSeriesInsightsAccessPolicy:TimeSeriesInsightsAccessPolicy example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.TimeSeriesInsights/environments/environment1/accessPolicies/example

```

func GetTimeSeriesInsightsAccessPolicy added in v3.9.0 

func GetTimeSeriesInsightsAccessPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TimeSeriesInsightsAccessPolicyState, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsAccessPolicy, error)

GetTimeSeriesInsightsAccessPolicy gets an existing TimeSeriesInsightsAccessPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewTimeSeriesInsightsAccessPolicy added in v3.9.0 

func NewTimeSeriesInsightsAccessPolicy(ctx *pulumi.Context,
	name string, args *TimeSeriesInsightsAccessPolicyArgs, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsAccessPolicy, error)

NewTimeSeriesInsightsAccessPolicy registers a new resource with the given unique name, arguments, and options.

func (TimeSeriesInsightsAccessPolicy) ElementType added in v3.31.1 

func (TimeSeriesInsightsAccessPolicy) ElementType() reflect.Type

func (TimeSeriesInsightsAccessPolicy) ToTimeSeriesInsightsAccessPolicyOutput added in v3.31.1 

func (i TimeSeriesInsightsAccessPolicy) ToTimeSeriesInsightsAccessPolicyOutput() TimeSeriesInsightsAccessPolicyOutput

func (TimeSeriesInsightsAccessPolicy) ToTimeSeriesInsightsAccessPolicyOutputWithContext added in v3.31.1 

func (i TimeSeriesInsightsAccessPolicy) ToTimeSeriesInsightsAccessPolicyOutputWithContext(ctx context.Context) TimeSeriesInsightsAccessPolicyOutput

type TimeSeriesInsightsAccessPolicyArgs added in v3.9.0 

type TimeSeriesInsightsAccessPolicyArgs struct {
	// The description of the Azure IoT Time Series Insights Access Policy.
	Description pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Access Policy. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// The id of the principal in Azure Active Directory.
	PrincipalObjectId pulumi.StringInput
	// A list of roles to apply to the Access Policy. Valid values include `Contributor` and `Reader`.
	Roles pulumi.StringArrayInput
	// The resource ID of the Azure IoT Time Series Insights Environment in which to create the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created.
	TimeSeriesInsightsEnvironmentId pulumi.StringInput
}

The set of arguments for constructing a TimeSeriesInsightsAccessPolicy resource.

func (TimeSeriesInsightsAccessPolicyArgs) ElementType added in v3.9.0 

func (TimeSeriesInsightsAccessPolicyArgs) ElementType() reflect.Type

type TimeSeriesInsightsAccessPolicyInput added in v3.31.1 

type TimeSeriesInsightsAccessPolicyInput interface {
	pulumi.Input

	ToTimeSeriesInsightsAccessPolicyOutput() TimeSeriesInsightsAccessPolicyOutput
	ToTimeSeriesInsightsAccessPolicyOutputWithContext(ctx context.Context) TimeSeriesInsightsAccessPolicyOutput
}

type TimeSeriesInsightsAccessPolicyOutput added in v3.31.1 

type TimeSeriesInsightsAccessPolicyOutput struct {
	*pulumi.OutputState
}

func (TimeSeriesInsightsAccessPolicyOutput) ElementType added in v3.31.1 

func (TimeSeriesInsightsAccessPolicyOutput) ElementType() reflect.Type

func (TimeSeriesInsightsAccessPolicyOutput) ToTimeSeriesInsightsAccessPolicyOutput added in v3.31.1 

func (o TimeSeriesInsightsAccessPolicyOutput) ToTimeSeriesInsightsAccessPolicyOutput() TimeSeriesInsightsAccessPolicyOutput

func (TimeSeriesInsightsAccessPolicyOutput) ToTimeSeriesInsightsAccessPolicyOutputWithContext added in v3.31.1 

func (o TimeSeriesInsightsAccessPolicyOutput) ToTimeSeriesInsightsAccessPolicyOutputWithContext(ctx context.Context) TimeSeriesInsightsAccessPolicyOutput

type TimeSeriesInsightsAccessPolicyState added in v3.9.0 

type TimeSeriesInsightsAccessPolicyState struct {
	// The description of the Azure IoT Time Series Insights Access Policy.
	Description pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Access Policy. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// The id of the principal in Azure Active Directory.
	PrincipalObjectId pulumi.StringPtrInput
	// A list of roles to apply to the Access Policy. Valid values include `Contributor` and `Reader`.
	Roles pulumi.StringArrayInput
	// The resource ID of the Azure IoT Time Series Insights Environment in which to create the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created.
	TimeSeriesInsightsEnvironmentId pulumi.StringPtrInput
}

func (TimeSeriesInsightsAccessPolicyState) ElementType added in v3.9.0 

func (TimeSeriesInsightsAccessPolicyState) ElementType() reflect.Type

type TimeSeriesInsightsGen2Environment added in v3.33.0 

type TimeSeriesInsightsGen2Environment struct {
	pulumi.CustomResourceState

	// A list of property ids for the Azure IoT Time Series Insights Gen2 Environment
	IdProperties pulumi.StringArrayOutput `pulumi:"idProperties"`
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the Azure IoT Time Series Insights Gen2 Environment. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group in which to create the Azure IoT Time Series Insights Gen2 Environment.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// Specifies the SKU Name for this IoT Time Series Insights Gen2 Environment. Currently it supports only `L1`. For gen2, capacity cannot be specified.
	SkuName pulumi.StringOutput `pulumi:"skuName"`
	// A `storage` block as defined below.
	Storage TimeSeriesInsightsGen2EnvironmentStorageOutput `pulumi:"storage"`
	// A mapping of tags to assign to the resource.
	Tags                       pulumi.StringMapOutput `pulumi:"tags"`
	WarmStoreDataRetentionTime pulumi.StringPtrOutput `pulumi:"warmStoreDataRetentionTime"`
}

Manages an Azure IoT Time Series Insights Gen2 Environment.

## Import

Azure IoT Time Series Insights Gen2 Environment can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/timeSeriesInsightsGen2Environment:TimeSeriesInsightsGen2Environment example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.TimeSeriesInsights/environments/example

```

func GetTimeSeriesInsightsGen2Environment added in v3.33.0 

func GetTimeSeriesInsightsGen2Environment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TimeSeriesInsightsGen2EnvironmentState, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsGen2Environment, error)

GetTimeSeriesInsightsGen2Environment gets an existing TimeSeriesInsightsGen2Environment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewTimeSeriesInsightsGen2Environment added in v3.33.0 

func NewTimeSeriesInsightsGen2Environment(ctx *pulumi.Context,
	name string, args *TimeSeriesInsightsGen2EnvironmentArgs, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsGen2Environment, error)

NewTimeSeriesInsightsGen2Environment registers a new resource with the given unique name, arguments, and options.

func (TimeSeriesInsightsGen2Environment) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2Environment) ElementType() reflect.Type

func (TimeSeriesInsightsGen2Environment) ToTimeSeriesInsightsGen2EnvironmentOutput added in v3.33.0 

func (i TimeSeriesInsightsGen2Environment) ToTimeSeriesInsightsGen2EnvironmentOutput() TimeSeriesInsightsGen2EnvironmentOutput

func (TimeSeriesInsightsGen2Environment) ToTimeSeriesInsightsGen2EnvironmentOutputWithContext added in v3.33.0 

func (i TimeSeriesInsightsGen2Environment) ToTimeSeriesInsightsGen2EnvironmentOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentOutput

type TimeSeriesInsightsGen2EnvironmentArgs added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentArgs struct {
	// A list of property ids for the Azure IoT Time Series Insights Gen2 Environment
	IdProperties pulumi.StringArrayInput
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Gen2 Environment. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// The name of the resource group in which to create the Azure IoT Time Series Insights Gen2 Environment.
	ResourceGroupName pulumi.StringInput
	// Specifies the SKU Name for this IoT Time Series Insights Gen2 Environment. Currently it supports only `L1`. For gen2, capacity cannot be specified.
	SkuName pulumi.StringInput
	// A `storage` block as defined below.
	Storage TimeSeriesInsightsGen2EnvironmentStorageInput
	// A mapping of tags to assign to the resource.
	Tags                       pulumi.StringMapInput
	WarmStoreDataRetentionTime pulumi.StringPtrInput
}

The set of arguments for constructing a TimeSeriesInsightsGen2Environment resource.

func (TimeSeriesInsightsGen2EnvironmentArgs) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2EnvironmentArgs) ElementType() reflect.Type

type TimeSeriesInsightsGen2EnvironmentInput added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentInput interface {
	pulumi.Input

	ToTimeSeriesInsightsGen2EnvironmentOutput() TimeSeriesInsightsGen2EnvironmentOutput
	ToTimeSeriesInsightsGen2EnvironmentOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentOutput
}

type TimeSeriesInsightsGen2EnvironmentOutput added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentOutput struct {
	*pulumi.OutputState
}

func (TimeSeriesInsightsGen2EnvironmentOutput) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2EnvironmentOutput) ElementType() reflect.Type

func (TimeSeriesInsightsGen2EnvironmentOutput) ToTimeSeriesInsightsGen2EnvironmentOutput added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentOutput) ToTimeSeriesInsightsGen2EnvironmentOutput() TimeSeriesInsightsGen2EnvironmentOutput

func (TimeSeriesInsightsGen2EnvironmentOutput) ToTimeSeriesInsightsGen2EnvironmentOutputWithContext added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentOutput) ToTimeSeriesInsightsGen2EnvironmentOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentOutput

type TimeSeriesInsightsGen2EnvironmentState added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentState struct {
	// A list of property ids for the Azure IoT Time Series Insights Gen2 Environment
	IdProperties pulumi.StringArrayInput
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Gen2 Environment. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// The name of the resource group in which to create the Azure IoT Time Series Insights Gen2 Environment.
	ResourceGroupName pulumi.StringPtrInput
	// Specifies the SKU Name for this IoT Time Series Insights Gen2 Environment. Currently it supports only `L1`. For gen2, capacity cannot be specified.
	SkuName pulumi.StringPtrInput
	// A `storage` block as defined below.
	Storage TimeSeriesInsightsGen2EnvironmentStoragePtrInput
	// A mapping of tags to assign to the resource.
	Tags                       pulumi.StringMapInput
	WarmStoreDataRetentionTime pulumi.StringPtrInput
}

func (TimeSeriesInsightsGen2EnvironmentState) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2EnvironmentState) ElementType() reflect.Type

type TimeSeriesInsightsGen2EnvironmentStorage added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentStorage struct {
	// Access key of storage account for Azure IoT Time Series Insights Gen2 Environment
	Key string `pulumi:"key"`
	// Name of storage account for Azure IoT Time Series Insights Gen2 Environment
	Name string `pulumi:"name"`
}

type TimeSeriesInsightsGen2EnvironmentStorageArgs added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentStorageArgs struct {
	// Access key of storage account for Azure IoT Time Series Insights Gen2 Environment
	Key pulumi.StringInput `pulumi:"key"`
	// Name of storage account for Azure IoT Time Series Insights Gen2 Environment
	Name pulumi.StringInput `pulumi:"name"`
}

func (TimeSeriesInsightsGen2EnvironmentStorageArgs) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2EnvironmentStorageArgs) ElementType() reflect.Type

func (TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStorageOutput added in v3.33.0 

func (i TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStorageOutput() TimeSeriesInsightsGen2EnvironmentStorageOutput

func (TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStorageOutputWithContext added in v3.33.0 

func (i TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStorageOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentStorageOutput

func (TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput added in v3.33.0 

func (i TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput() TimeSeriesInsightsGen2EnvironmentStoragePtrOutput

func (TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext added in v3.33.0 

func (i TimeSeriesInsightsGen2EnvironmentStorageArgs) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentStoragePtrOutput

type TimeSeriesInsightsGen2EnvironmentStorageInput added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentStorageInput interface {
	pulumi.Input

	ToTimeSeriesInsightsGen2EnvironmentStorageOutput() TimeSeriesInsightsGen2EnvironmentStorageOutput
	ToTimeSeriesInsightsGen2EnvironmentStorageOutputWithContext(context.Context) TimeSeriesInsightsGen2EnvironmentStorageOutput
}

TimeSeriesInsightsGen2EnvironmentStorageInput is an input type that accepts TimeSeriesInsightsGen2EnvironmentStorageArgs and TimeSeriesInsightsGen2EnvironmentStorageOutput values. You can construct a concrete instance of `TimeSeriesInsightsGen2EnvironmentStorageInput` via: 

TimeSeriesInsightsGen2EnvironmentStorageArgs{...}

type TimeSeriesInsightsGen2EnvironmentStorageOutput added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentStorageOutput struct{ *pulumi.OutputState }

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) ElementType() reflect.Type

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) Key added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStorageOutput) Key() pulumi.StringOutput

Access key of storage account for Azure IoT Time Series Insights Gen2 Environment

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) Name added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStorageOutput) Name() pulumi.StringOutput

Name of storage account for Azure IoT Time Series Insights Gen2 Environment

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStorageOutput added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStorageOutput() TimeSeriesInsightsGen2EnvironmentStorageOutput

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStorageOutputWithContext added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStorageOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentStorageOutput

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput() TimeSeriesInsightsGen2EnvironmentStoragePtrOutput

func (TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStorageOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentStoragePtrOutput

type TimeSeriesInsightsGen2EnvironmentStoragePtrInput added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentStoragePtrInput interface {
	pulumi.Input

	ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput() TimeSeriesInsightsGen2EnvironmentStoragePtrOutput
	ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext(context.Context) TimeSeriesInsightsGen2EnvironmentStoragePtrOutput
}

TimeSeriesInsightsGen2EnvironmentStoragePtrInput is an input type that accepts TimeSeriesInsightsGen2EnvironmentStorageArgs, TimeSeriesInsightsGen2EnvironmentStoragePtr and TimeSeriesInsightsGen2EnvironmentStoragePtrOutput values. You can construct a concrete instance of `TimeSeriesInsightsGen2EnvironmentStoragePtrInput` via: 

        TimeSeriesInsightsGen2EnvironmentStorageArgs{...}

or:

        nil

func TimeSeriesInsightsGen2EnvironmentStoragePtr added in v3.33.0 

func TimeSeriesInsightsGen2EnvironmentStoragePtr(v *TimeSeriesInsightsGen2EnvironmentStorageArgs) TimeSeriesInsightsGen2EnvironmentStoragePtrInput

type TimeSeriesInsightsGen2EnvironmentStoragePtrOutput added in v3.33.0 

type TimeSeriesInsightsGen2EnvironmentStoragePtrOutput struct{ *pulumi.OutputState }

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) Elem added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) Elem() TimeSeriesInsightsGen2EnvironmentStorageOutput

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) ElementType added in v3.33.0 

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) ElementType() reflect.Type

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) Key added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) Key() pulumi.StringPtrOutput

Access key of storage account for Azure IoT Time Series Insights Gen2 Environment

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) Name added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) Name() pulumi.StringPtrOutput

Name of storage account for Azure IoT Time Series Insights Gen2 Environment

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutput() TimeSeriesInsightsGen2EnvironmentStoragePtrOutput

func (TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext added in v3.33.0 

func (o TimeSeriesInsightsGen2EnvironmentStoragePtrOutput) ToTimeSeriesInsightsGen2EnvironmentStoragePtrOutputWithContext(ctx context.Context) TimeSeriesInsightsGen2EnvironmentStoragePtrOutput

type TimeSeriesInsightsReferenceDataSet added in v3.9.0 

type TimeSeriesInsightsReferenceDataSet struct {
	pulumi.CustomResourceState

	// The comparison behavior that will be used to compare keys. Valid values include `Ordinal` and `OrdinalIgnoreCase`. Defaults to `Ordinal`.
	DataStringComparisonBehavior pulumi.StringPtrOutput `pulumi:"dataStringComparisonBehavior"`
	// A `keyProperty` block as defined below.
	KeyProperties TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput `pulumi:"keyProperties"`
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringOutput `pulumi:"name"`
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// The resource ID of the Azure IoT Time Series Insights Environment in which to create the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created.
	TimeSeriesInsightsEnvironmentId pulumi.StringOutput `pulumi:"timeSeriesInsightsEnvironmentId"`
}

Manages an Azure IoT Time Series Insights Reference Data Set.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("northeurope"),
		})
		if err != nil {
			return err
		}
		exampleTimeSeriesInsightsStandardEnvironment, err := iot.NewTimeSeriesInsightsStandardEnvironment(ctx, "exampleTimeSeriesInsightsStandardEnvironment", &iot.TimeSeriesInsightsStandardEnvironmentArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			SkuName:           pulumi.String("S1_1"),
			DataRetentionTime: pulumi.String("P30D"),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewTimeSeriesInsightsReferenceDataSet(ctx, "exampleTimeSeriesInsightsReferenceDataSet", &iot.TimeSeriesInsightsReferenceDataSetArgs{
			TimeSeriesInsightsEnvironmentId: exampleTimeSeriesInsightsStandardEnvironment.ID(),
			Location:                        exampleResourceGroup.Location,
			KeyProperties: iot.TimeSeriesInsightsReferenceDataSetKeyPropertyArray{
				&iot.TimeSeriesInsightsReferenceDataSetKeyPropertyArgs{
					Name: pulumi.String("keyProperty1"),
					Type: pulumi.String("String"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Azure IoT Time Series Insights Reference Data Set can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/timeSeriesInsightsReferenceDataSet:TimeSeriesInsightsReferenceDataSet example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.TimeSeriesInsights/environments/example/referenceDataSets/example

```

func GetTimeSeriesInsightsReferenceDataSet added in v3.9.0 

func GetTimeSeriesInsightsReferenceDataSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TimeSeriesInsightsReferenceDataSetState, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsReferenceDataSet, error)

GetTimeSeriesInsightsReferenceDataSet gets an existing TimeSeriesInsightsReferenceDataSet resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewTimeSeriesInsightsReferenceDataSet added in v3.9.0 

func NewTimeSeriesInsightsReferenceDataSet(ctx *pulumi.Context,
	name string, args *TimeSeriesInsightsReferenceDataSetArgs, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsReferenceDataSet, error)

NewTimeSeriesInsightsReferenceDataSet registers a new resource with the given unique name, arguments, and options.

func (TimeSeriesInsightsReferenceDataSet) ElementType added in v3.31.1 

func (TimeSeriesInsightsReferenceDataSet) ElementType() reflect.Type

func (TimeSeriesInsightsReferenceDataSet) ToTimeSeriesInsightsReferenceDataSetOutput added in v3.31.1 

func (i TimeSeriesInsightsReferenceDataSet) ToTimeSeriesInsightsReferenceDataSetOutput() TimeSeriesInsightsReferenceDataSetOutput

func (TimeSeriesInsightsReferenceDataSet) ToTimeSeriesInsightsReferenceDataSetOutputWithContext added in v3.31.1 

func (i TimeSeriesInsightsReferenceDataSet) ToTimeSeriesInsightsReferenceDataSetOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetOutput

type TimeSeriesInsightsReferenceDataSetArgs added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetArgs struct {
	// The comparison behavior that will be used to compare keys. Valid values include `Ordinal` and `OrdinalIgnoreCase`. Defaults to `Ordinal`.
	DataStringComparisonBehavior pulumi.StringPtrInput
	// A `keyProperty` block as defined below.
	KeyProperties TimeSeriesInsightsReferenceDataSetKeyPropertyArrayInput
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// The resource ID of the Azure IoT Time Series Insights Environment in which to create the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created.
	TimeSeriesInsightsEnvironmentId pulumi.StringInput
}

The set of arguments for constructing a TimeSeriesInsightsReferenceDataSet resource.

func (TimeSeriesInsightsReferenceDataSetArgs) ElementType added in v3.9.0 

func (TimeSeriesInsightsReferenceDataSetArgs) ElementType() reflect.Type

type TimeSeriesInsightsReferenceDataSetInput added in v3.31.1 

type TimeSeriesInsightsReferenceDataSetInput interface {
	pulumi.Input

	ToTimeSeriesInsightsReferenceDataSetOutput() TimeSeriesInsightsReferenceDataSetOutput
	ToTimeSeriesInsightsReferenceDataSetOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetOutput
}

type TimeSeriesInsightsReferenceDataSetKeyProperty added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyProperty struct {
	// The name of the key property.
	Name string `pulumi:"name"`
	// The data type of the key property. Valid values include `Bool`, `DateTime`, `Double`, `String`.
	Type string `pulumi:"type"`
}

type TimeSeriesInsightsReferenceDataSetKeyPropertyArgs added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyPropertyArgs struct {
	// The name of the key property.
	Name pulumi.StringInput `pulumi:"name"`
	// The data type of the key property. Valid values include `Bool`, `DateTime`, `Double`, `String`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArgs) ElementType added in v3.9.0 

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArgs) ElementType() reflect.Type

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArgs) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutput added in v3.9.0 

func (i TimeSeriesInsightsReferenceDataSetKeyPropertyArgs) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutput() TimeSeriesInsightsReferenceDataSetKeyPropertyOutput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArgs) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutputWithContext added in v3.9.0 

func (i TimeSeriesInsightsReferenceDataSetKeyPropertyArgs) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetKeyPropertyOutput

type TimeSeriesInsightsReferenceDataSetKeyPropertyArray added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyPropertyArray []TimeSeriesInsightsReferenceDataSetKeyPropertyInput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArray) ElementType added in v3.9.0 

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArray) ElementType() reflect.Type

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArray) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput added in v3.9.0 

func (i TimeSeriesInsightsReferenceDataSetKeyPropertyArray) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput() TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArray) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutputWithContext added in v3.9.0 

func (i TimeSeriesInsightsReferenceDataSetKeyPropertyArray) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput

type TimeSeriesInsightsReferenceDataSetKeyPropertyArrayInput added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyPropertyArrayInput interface {
	pulumi.Input

	ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput() TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput
	ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutputWithContext(context.Context) TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput
}

TimeSeriesInsightsReferenceDataSetKeyPropertyArrayInput is an input type that accepts TimeSeriesInsightsReferenceDataSetKeyPropertyArray and TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput values. You can construct a concrete instance of `TimeSeriesInsightsReferenceDataSetKeyPropertyArrayInput` via: 

TimeSeriesInsightsReferenceDataSetKeyPropertyArray{ TimeSeriesInsightsReferenceDataSetKeyPropertyArgs{...} }

type TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput struct{ *pulumi.OutputState }

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) ElementType added in v3.9.0 

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) ElementType() reflect.Type

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) Index added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) Index(i pulumi.IntInput) TimeSeriesInsightsReferenceDataSetKeyPropertyOutput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput() TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutputWithContext added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetKeyPropertyArrayOutput

type TimeSeriesInsightsReferenceDataSetKeyPropertyInput added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyPropertyInput interface {
	pulumi.Input

	ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutput() TimeSeriesInsightsReferenceDataSetKeyPropertyOutput
	ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutputWithContext(context.Context) TimeSeriesInsightsReferenceDataSetKeyPropertyOutput
}

TimeSeriesInsightsReferenceDataSetKeyPropertyInput is an input type that accepts TimeSeriesInsightsReferenceDataSetKeyPropertyArgs and TimeSeriesInsightsReferenceDataSetKeyPropertyOutput values. You can construct a concrete instance of `TimeSeriesInsightsReferenceDataSetKeyPropertyInput` via: 

TimeSeriesInsightsReferenceDataSetKeyPropertyArgs{...}

type TimeSeriesInsightsReferenceDataSetKeyPropertyOutput added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetKeyPropertyOutput struct{ *pulumi.OutputState }

func (TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) ElementType added in v3.9.0 

func (TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) ElementType() reflect.Type

func (TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) Name added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) Name() pulumi.StringOutput

The name of the key property.

func (TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutput added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutput() TimeSeriesInsightsReferenceDataSetKeyPropertyOutput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutputWithContext added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) ToTimeSeriesInsightsReferenceDataSetKeyPropertyOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetKeyPropertyOutput

func (TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) Type added in v3.9.0 

func (o TimeSeriesInsightsReferenceDataSetKeyPropertyOutput) Type() pulumi.StringOutput

The data type of the key property. Valid values include `Bool`, `DateTime`, `Double`, `String`.

type TimeSeriesInsightsReferenceDataSetOutput added in v3.31.1 

type TimeSeriesInsightsReferenceDataSetOutput struct {
	*pulumi.OutputState
}

func (TimeSeriesInsightsReferenceDataSetOutput) ElementType added in v3.31.1 

func (TimeSeriesInsightsReferenceDataSetOutput) ElementType() reflect.Type

func (TimeSeriesInsightsReferenceDataSetOutput) ToTimeSeriesInsightsReferenceDataSetOutput added in v3.31.1 

func (o TimeSeriesInsightsReferenceDataSetOutput) ToTimeSeriesInsightsReferenceDataSetOutput() TimeSeriesInsightsReferenceDataSetOutput

func (TimeSeriesInsightsReferenceDataSetOutput) ToTimeSeriesInsightsReferenceDataSetOutputWithContext added in v3.31.1 

func (o TimeSeriesInsightsReferenceDataSetOutput) ToTimeSeriesInsightsReferenceDataSetOutputWithContext(ctx context.Context) TimeSeriesInsightsReferenceDataSetOutput

type TimeSeriesInsightsReferenceDataSetState added in v3.9.0 

type TimeSeriesInsightsReferenceDataSetState struct {
	// The comparison behavior that will be used to compare keys. Valid values include `Ordinal` and `OrdinalIgnoreCase`. Defaults to `Ordinal`.
	DataStringComparisonBehavior pulumi.StringPtrInput
	// A `keyProperty` block as defined below.
	KeyProperties TimeSeriesInsightsReferenceDataSetKeyPropertyArrayInput
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// The resource ID of the Azure IoT Time Series Insights Environment in which to create the Azure IoT Time Series Insights Reference Data Set. Changing this forces a new resource to be created.
	TimeSeriesInsightsEnvironmentId pulumi.StringPtrInput
}

func (TimeSeriesInsightsReferenceDataSetState) ElementType added in v3.9.0 

func (TimeSeriesInsightsReferenceDataSetState) ElementType() reflect.Type

type TimeSeriesInsightsStandardEnvironment added in v3.6.0 

type TimeSeriesInsightsStandardEnvironment struct {
	pulumi.CustomResourceState

	// Specifies the ISO8601 timespan specifying the minimum number of days the environment's events will be available for query. Changing this forces a new resource to be created.
	DataRetentionTime pulumi.StringOutput `pulumi:"dataRetentionTime"`
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the Azure IoT Time Series Insights Standard Environment. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the event property which will be used to partition data. Changing this forces a new resource to be created.
	PartitionKey pulumi.StringPtrOutput `pulumi:"partitionKey"`
	// The name of the resource group in which to create the Azure IoT Time Series Insights Standard Environment.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// Specifies the SKU Name for this IoT Time Series Insights Standard Environment. It is string consisting of two parts separated by an underscore(\_).The fist part is the `name`, valid values include: `S1` and `S2`. The second part is the `capacity` (e.g. the number of deployed units of the `sku`), which must be a positive `integer` (e.g. `S1_1`). Changing this forces a new resource to be created.
	SkuName pulumi.StringOutput `pulumi:"skuName"`
	// Specifies the behaviour the IoT Time Series Insights service should take when the environment's capacity has been exceeded. Valid values include `PauseIngress` and `PurgeOldData`. Defaults to `PurgeOldData`.
	StorageLimitExceededBehavior pulumi.StringPtrOutput `pulumi:"storageLimitExceededBehavior"`
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Manages an Azure IoT Time Series Insights Standard Environment.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/iot"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("northeurope"),
		})
		if err != nil {
			return err
		}
		_, err = iot.NewTimeSeriesInsightsStandardEnvironment(ctx, "exampleTimeSeriesInsightsStandardEnvironment", &iot.TimeSeriesInsightsStandardEnvironmentArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			SkuName:           pulumi.String("S1_1"),
			DataRetentionTime: pulumi.String("P30D"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Azure IoT Time Series Insights Standard Environment can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:iot/timeSeriesInsightsStandardEnvironment:TimeSeriesInsightsStandardEnvironment example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.TimeSeriesInsights/environments/example

```

func GetTimeSeriesInsightsStandardEnvironment added in v3.6.0 

func GetTimeSeriesInsightsStandardEnvironment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TimeSeriesInsightsStandardEnvironmentState, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsStandardEnvironment, error)

GetTimeSeriesInsightsStandardEnvironment gets an existing TimeSeriesInsightsStandardEnvironment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewTimeSeriesInsightsStandardEnvironment added in v3.6.0 

func NewTimeSeriesInsightsStandardEnvironment(ctx *pulumi.Context,
	name string, args *TimeSeriesInsightsStandardEnvironmentArgs, opts ...pulumi.ResourceOption) (*TimeSeriesInsightsStandardEnvironment, error)

NewTimeSeriesInsightsStandardEnvironment registers a new resource with the given unique name, arguments, and options.

func (TimeSeriesInsightsStandardEnvironment) ElementType added in v3.31.1 

func (TimeSeriesInsightsStandardEnvironment) ElementType() reflect.Type

func (TimeSeriesInsightsStandardEnvironment) ToTimeSeriesInsightsStandardEnvironmentOutput added in v3.31.1 

func (i TimeSeriesInsightsStandardEnvironment) ToTimeSeriesInsightsStandardEnvironmentOutput() TimeSeriesInsightsStandardEnvironmentOutput

func (TimeSeriesInsightsStandardEnvironment) ToTimeSeriesInsightsStandardEnvironmentOutputWithContext added in v3.31.1 

func (i TimeSeriesInsightsStandardEnvironment) ToTimeSeriesInsightsStandardEnvironmentOutputWithContext(ctx context.Context) TimeSeriesInsightsStandardEnvironmentOutput

type TimeSeriesInsightsStandardEnvironmentArgs added in v3.6.0 

type TimeSeriesInsightsStandardEnvironmentArgs struct {
	// Specifies the ISO8601 timespan specifying the minimum number of days the environment's events will be available for query. Changing this forces a new resource to be created.
	DataRetentionTime pulumi.StringInput
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Standard Environment. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// The name of the event property which will be used to partition data. Changing this forces a new resource to be created.
	PartitionKey pulumi.StringPtrInput
	// The name of the resource group in which to create the Azure IoT Time Series Insights Standard Environment.
	ResourceGroupName pulumi.StringInput
	// Specifies the SKU Name for this IoT Time Series Insights Standard Environment. It is string consisting of two parts separated by an underscore(\_).The fist part is the `name`, valid values include: `S1` and `S2`. The second part is the `capacity` (e.g. the number of deployed units of the `sku`), which must be a positive `integer` (e.g. `S1_1`). Changing this forces a new resource to be created.
	SkuName pulumi.StringInput
	// Specifies the behaviour the IoT Time Series Insights service should take when the environment's capacity has been exceeded. Valid values include `PauseIngress` and `PurgeOldData`. Defaults to `PurgeOldData`.
	StorageLimitExceededBehavior pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a TimeSeriesInsightsStandardEnvironment resource.

func (TimeSeriesInsightsStandardEnvironmentArgs) ElementType added in v3.6.0 

func (TimeSeriesInsightsStandardEnvironmentArgs) ElementType() reflect.Type

type TimeSeriesInsightsStandardEnvironmentInput added in v3.31.1 

type TimeSeriesInsightsStandardEnvironmentInput interface {
	pulumi.Input

	ToTimeSeriesInsightsStandardEnvironmentOutput() TimeSeriesInsightsStandardEnvironmentOutput
	ToTimeSeriesInsightsStandardEnvironmentOutputWithContext(ctx context.Context) TimeSeriesInsightsStandardEnvironmentOutput
}

type TimeSeriesInsightsStandardEnvironmentOutput added in v3.31.1 

type TimeSeriesInsightsStandardEnvironmentOutput struct {
	*pulumi.OutputState
}

func (TimeSeriesInsightsStandardEnvironmentOutput) ElementType added in v3.31.1 

func (TimeSeriesInsightsStandardEnvironmentOutput) ElementType() reflect.Type

func (TimeSeriesInsightsStandardEnvironmentOutput) ToTimeSeriesInsightsStandardEnvironmentOutput added in v3.31.1 

func (o TimeSeriesInsightsStandardEnvironmentOutput) ToTimeSeriesInsightsStandardEnvironmentOutput() TimeSeriesInsightsStandardEnvironmentOutput

func (TimeSeriesInsightsStandardEnvironmentOutput) ToTimeSeriesInsightsStandardEnvironmentOutputWithContext added in v3.31.1 

func (o TimeSeriesInsightsStandardEnvironmentOutput) ToTimeSeriesInsightsStandardEnvironmentOutputWithContext(ctx context.Context) TimeSeriesInsightsStandardEnvironmentOutput

type TimeSeriesInsightsStandardEnvironmentState added in v3.6.0 

type TimeSeriesInsightsStandardEnvironmentState struct {
	// Specifies the ISO8601 timespan specifying the minimum number of days the environment's events will be available for query. Changing this forces a new resource to be created.
	DataRetentionTime pulumi.StringPtrInput
	// Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Azure IoT Time Series Insights Standard Environment. Changing this forces a new resource to be created. Must be globally unique.
	Name pulumi.StringPtrInput
	// The name of the event property which will be used to partition data. Changing this forces a new resource to be created.
	PartitionKey pulumi.StringPtrInput
	// The name of the resource group in which to create the Azure IoT Time Series Insights Standard Environment.
	ResourceGroupName pulumi.StringPtrInput
	// Specifies the SKU Name for this IoT Time Series Insights Standard Environment. It is string consisting of two parts separated by an underscore(\_).The fist part is the `name`, valid values include: `S1` and `S2`. The second part is the `capacity` (e.g. the number of deployed units of the `sku`), which must be a positive `integer` (e.g. `S1_1`). Changing this forces a new resource to be created.
	SkuName pulumi.StringPtrInput
	// Specifies the behaviour the IoT Time Series Insights service should take when the environment's capacity has been exceeded. Valid values include `PauseIngress` and `PurgeOldData`. Defaults to `PurgeOldData`.
	StorageLimitExceededBehavior pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (TimeSeriesInsightsStandardEnvironmentState) ElementType added in v3.6.0 

func (TimeSeriesInsightsStandardEnvironmentState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.