pulumiTypes.go

// *** WARNING: this file was generated by the Pulumi SDK Generator. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

package v20190801

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

// The type of the paths for alias.
type AliasPathTypeResponse struct {
	// The API versions.
	ApiVersions []string `pulumi:"apiVersions"`
	// The path of an alias.
	Path *string `pulumi:"path"`
}

// AliasPathTypeResponseInput is an input type that accepts AliasPathTypeResponseArgs and AliasPathTypeResponseOutput values.
// You can construct a concrete instance of `AliasPathTypeResponseInput` via:
//
//          AliasPathTypeResponseArgs{...}
type AliasPathTypeResponseInput interface {
	pulumi.Input

	ToAliasPathTypeResponseOutput() AliasPathTypeResponseOutput
	ToAliasPathTypeResponseOutputWithContext(context.Context) AliasPathTypeResponseOutput
}

// The type of the paths for alias.
type AliasPathTypeResponseArgs struct {
	// The API versions.
	ApiVersions pulumi.StringArrayInput `pulumi:"apiVersions"`
	// The path of an alias.
	Path pulumi.StringPtrInput `pulumi:"path"`
}

func (AliasPathTypeResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AliasPathTypeResponse)(nil)).Elem()
}

func (i AliasPathTypeResponseArgs) ToAliasPathTypeResponseOutput() AliasPathTypeResponseOutput {
	return i.ToAliasPathTypeResponseOutputWithContext(context.Background())
}

func (i AliasPathTypeResponseArgs) ToAliasPathTypeResponseOutputWithContext(ctx context.Context) AliasPathTypeResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasPathTypeResponseOutput)
}

// AliasPathTypeResponseArrayInput is an input type that accepts AliasPathTypeResponseArray and AliasPathTypeResponseArrayOutput values.
// You can construct a concrete instance of `AliasPathTypeResponseArrayInput` via:
//
//          AliasPathTypeResponseArray{ AliasPathTypeResponseArgs{...} }
type AliasPathTypeResponseArrayInput interface {
	pulumi.Input

	ToAliasPathTypeResponseArrayOutput() AliasPathTypeResponseArrayOutput
	ToAliasPathTypeResponseArrayOutputWithContext(context.Context) AliasPathTypeResponseArrayOutput
}

type AliasPathTypeResponseArray []AliasPathTypeResponseInput

func (AliasPathTypeResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AliasPathTypeResponse)(nil)).Elem()
}

func (i AliasPathTypeResponseArray) ToAliasPathTypeResponseArrayOutput() AliasPathTypeResponseArrayOutput {
	return i.ToAliasPathTypeResponseArrayOutputWithContext(context.Background())
}

func (i AliasPathTypeResponseArray) ToAliasPathTypeResponseArrayOutputWithContext(ctx context.Context) AliasPathTypeResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasPathTypeResponseArrayOutput)
}

// The type of the paths for alias.
type AliasPathTypeResponseOutput struct{ *pulumi.OutputState }

func (AliasPathTypeResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AliasPathTypeResponse)(nil)).Elem()
}

func (o AliasPathTypeResponseOutput) ToAliasPathTypeResponseOutput() AliasPathTypeResponseOutput {
	return o
}

func (o AliasPathTypeResponseOutput) ToAliasPathTypeResponseOutputWithContext(ctx context.Context) AliasPathTypeResponseOutput {
	return o
}

// The API versions.
func (o AliasPathTypeResponseOutput) ApiVersions() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AliasPathTypeResponse) []string { return v.ApiVersions }).(pulumi.StringArrayOutput)
}

// The path of an alias.
func (o AliasPathTypeResponseOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AliasPathTypeResponse) *string { return v.Path }).(pulumi.StringPtrOutput)
}

type AliasPathTypeResponseArrayOutput struct{ *pulumi.OutputState }

func (AliasPathTypeResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AliasPathTypeResponse)(nil)).Elem()
}

func (o AliasPathTypeResponseArrayOutput) ToAliasPathTypeResponseArrayOutput() AliasPathTypeResponseArrayOutput {
	return o
}

func (o AliasPathTypeResponseArrayOutput) ToAliasPathTypeResponseArrayOutputWithContext(ctx context.Context) AliasPathTypeResponseArrayOutput {
	return o
}

func (o AliasPathTypeResponseArrayOutput) Index(i pulumi.IntInput) AliasPathTypeResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AliasPathTypeResponse {
		return vs[0].([]AliasPathTypeResponse)[vs[1].(int)]
	}).(AliasPathTypeResponseOutput)
}

// The alias type.
type AliasTypeResponse struct {
	// The alias name.
	Name *string `pulumi:"name"`
	// The paths for an alias.
	Paths []AliasPathTypeResponse `pulumi:"paths"`
}

// AliasTypeResponseInput is an input type that accepts AliasTypeResponseArgs and AliasTypeResponseOutput values.
// You can construct a concrete instance of `AliasTypeResponseInput` via:
//
//          AliasTypeResponseArgs{...}
type AliasTypeResponseInput interface {
	pulumi.Input

	ToAliasTypeResponseOutput() AliasTypeResponseOutput
	ToAliasTypeResponseOutputWithContext(context.Context) AliasTypeResponseOutput
}

// The alias type.
type AliasTypeResponseArgs struct {
	// The alias name.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The paths for an alias.
	Paths AliasPathTypeResponseArrayInput `pulumi:"paths"`
}

func (AliasTypeResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AliasTypeResponse)(nil)).Elem()
}

func (i AliasTypeResponseArgs) ToAliasTypeResponseOutput() AliasTypeResponseOutput {
	return i.ToAliasTypeResponseOutputWithContext(context.Background())
}

func (i AliasTypeResponseArgs) ToAliasTypeResponseOutputWithContext(ctx context.Context) AliasTypeResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasTypeResponseOutput)
}

// AliasTypeResponseArrayInput is an input type that accepts AliasTypeResponseArray and AliasTypeResponseArrayOutput values.
// You can construct a concrete instance of `AliasTypeResponseArrayInput` via:
//
//          AliasTypeResponseArray{ AliasTypeResponseArgs{...} }
type AliasTypeResponseArrayInput interface {
	pulumi.Input

	ToAliasTypeResponseArrayOutput() AliasTypeResponseArrayOutput
	ToAliasTypeResponseArrayOutputWithContext(context.Context) AliasTypeResponseArrayOutput
}

type AliasTypeResponseArray []AliasTypeResponseInput

func (AliasTypeResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AliasTypeResponse)(nil)).Elem()
}

func (i AliasTypeResponseArray) ToAliasTypeResponseArrayOutput() AliasTypeResponseArrayOutput {
	return i.ToAliasTypeResponseArrayOutputWithContext(context.Background())
}

func (i AliasTypeResponseArray) ToAliasTypeResponseArrayOutputWithContext(ctx context.Context) AliasTypeResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasTypeResponseArrayOutput)
}

// The alias type.
type AliasTypeResponseOutput struct{ *pulumi.OutputState }

func (AliasTypeResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AliasTypeResponse)(nil)).Elem()
}

func (o AliasTypeResponseOutput) ToAliasTypeResponseOutput() AliasTypeResponseOutput {
	return o
}

func (o AliasTypeResponseOutput) ToAliasTypeResponseOutputWithContext(ctx context.Context) AliasTypeResponseOutput {
	return o
}

// The alias name.
func (o AliasTypeResponseOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AliasTypeResponse) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The paths for an alias.
func (o AliasTypeResponseOutput) Paths() AliasPathTypeResponseArrayOutput {
	return o.ApplyT(func(v AliasTypeResponse) []AliasPathTypeResponse { return v.Paths }).(AliasPathTypeResponseArrayOutput)
}

type AliasTypeResponseArrayOutput struct{ *pulumi.OutputState }

func (AliasTypeResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AliasTypeResponse)(nil)).Elem()
}

func (o AliasTypeResponseArrayOutput) ToAliasTypeResponseArrayOutput() AliasTypeResponseArrayOutput {
	return o
}

func (o AliasTypeResponseArrayOutput) ToAliasTypeResponseArrayOutputWithContext(ctx context.Context) AliasTypeResponseArrayOutput {
	return o
}

func (o AliasTypeResponseArrayOutput) Index(i pulumi.IntInput) AliasTypeResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AliasTypeResponse {
		return vs[0].([]AliasTypeResponse)[vs[1].(int)]
	}).(AliasTypeResponseOutput)
}

// Deployment dependency information.
type BasicDependencyResponse struct {
	// The ID of the dependency.
	Id *string `pulumi:"id"`
	// The dependency resource name.
	ResourceName *string `pulumi:"resourceName"`
	// The dependency resource type.
	ResourceType *string `pulumi:"resourceType"`
}

// BasicDependencyResponseInput is an input type that accepts BasicDependencyResponseArgs and BasicDependencyResponseOutput values.
// You can construct a concrete instance of `BasicDependencyResponseInput` via:
//
//          BasicDependencyResponseArgs{...}
type BasicDependencyResponseInput interface {
	pulumi.Input

	ToBasicDependencyResponseOutput() BasicDependencyResponseOutput
	ToBasicDependencyResponseOutputWithContext(context.Context) BasicDependencyResponseOutput
}

// Deployment dependency information.
type BasicDependencyResponseArgs struct {
	// The ID of the dependency.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The dependency resource name.
	ResourceName pulumi.StringPtrInput `pulumi:"resourceName"`
	// The dependency resource type.
	ResourceType pulumi.StringPtrInput `pulumi:"resourceType"`
}

func (BasicDependencyResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*BasicDependencyResponse)(nil)).Elem()
}

func (i BasicDependencyResponseArgs) ToBasicDependencyResponseOutput() BasicDependencyResponseOutput {
	return i.ToBasicDependencyResponseOutputWithContext(context.Background())
}

func (i BasicDependencyResponseArgs) ToBasicDependencyResponseOutputWithContext(ctx context.Context) BasicDependencyResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BasicDependencyResponseOutput)
}

// BasicDependencyResponseArrayInput is an input type that accepts BasicDependencyResponseArray and BasicDependencyResponseArrayOutput values.
// You can construct a concrete instance of `BasicDependencyResponseArrayInput` via:
//
//          BasicDependencyResponseArray{ BasicDependencyResponseArgs{...} }
type BasicDependencyResponseArrayInput interface {
	pulumi.Input

	ToBasicDependencyResponseArrayOutput() BasicDependencyResponseArrayOutput
	ToBasicDependencyResponseArrayOutputWithContext(context.Context) BasicDependencyResponseArrayOutput
}

type BasicDependencyResponseArray []BasicDependencyResponseInput

func (BasicDependencyResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]BasicDependencyResponse)(nil)).Elem()
}

func (i BasicDependencyResponseArray) ToBasicDependencyResponseArrayOutput() BasicDependencyResponseArrayOutput {
	return i.ToBasicDependencyResponseArrayOutputWithContext(context.Background())
}

func (i BasicDependencyResponseArray) ToBasicDependencyResponseArrayOutputWithContext(ctx context.Context) BasicDependencyResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BasicDependencyResponseArrayOutput)
}

// Deployment dependency information.
type BasicDependencyResponseOutput struct{ *pulumi.OutputState }

func (BasicDependencyResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BasicDependencyResponse)(nil)).Elem()
}

func (o BasicDependencyResponseOutput) ToBasicDependencyResponseOutput() BasicDependencyResponseOutput {
	return o
}

func (o BasicDependencyResponseOutput) ToBasicDependencyResponseOutputWithContext(ctx context.Context) BasicDependencyResponseOutput {
	return o
}

// The ID of the dependency.
func (o BasicDependencyResponseOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BasicDependencyResponse) *string { return v.Id }).(pulumi.StringPtrOutput)
}

// The dependency resource name.
func (o BasicDependencyResponseOutput) ResourceName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BasicDependencyResponse) *string { return v.ResourceName }).(pulumi.StringPtrOutput)
}

// The dependency resource type.
func (o BasicDependencyResponseOutput) ResourceType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BasicDependencyResponse) *string { return v.ResourceType }).(pulumi.StringPtrOutput)
}

type BasicDependencyResponseArrayOutput struct{ *pulumi.OutputState }

func (BasicDependencyResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]BasicDependencyResponse)(nil)).Elem()
}

func (o BasicDependencyResponseArrayOutput) ToBasicDependencyResponseArrayOutput() BasicDependencyResponseArrayOutput {
	return o
}

func (o BasicDependencyResponseArrayOutput) ToBasicDependencyResponseArrayOutputWithContext(ctx context.Context) BasicDependencyResponseArrayOutput {
	return o
}

func (o BasicDependencyResponseArrayOutput) Index(i pulumi.IntInput) BasicDependencyResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) BasicDependencyResponse {
		return vs[0].([]BasicDependencyResponse)[vs[1].(int)]
	}).(BasicDependencyResponseOutput)
}

// The debug setting.
type DebugSetting struct {
	// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
	DetailLevel *string `pulumi:"detailLevel"`
}

// DebugSettingInput is an input type that accepts DebugSettingArgs and DebugSettingOutput values.
// You can construct a concrete instance of `DebugSettingInput` via:
//
//          DebugSettingArgs{...}
type DebugSettingInput interface {
	pulumi.Input

	ToDebugSettingOutput() DebugSettingOutput
	ToDebugSettingOutputWithContext(context.Context) DebugSettingOutput
}

// The debug setting.
type DebugSettingArgs struct {
	// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
	DetailLevel pulumi.StringPtrInput `pulumi:"detailLevel"`
}

func (DebugSettingArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DebugSetting)(nil)).Elem()
}

func (i DebugSettingArgs) ToDebugSettingOutput() DebugSettingOutput {
	return i.ToDebugSettingOutputWithContext(context.Background())
}

func (i DebugSettingArgs) ToDebugSettingOutputWithContext(ctx context.Context) DebugSettingOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DebugSettingOutput)
}

func (i DebugSettingArgs) ToDebugSettingPtrOutput() DebugSettingPtrOutput {
	return i.ToDebugSettingPtrOutputWithContext(context.Background())
}

func (i DebugSettingArgs) ToDebugSettingPtrOutputWithContext(ctx context.Context) DebugSettingPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DebugSettingOutput).ToDebugSettingPtrOutputWithContext(ctx)
}

// DebugSettingPtrInput is an input type that accepts DebugSettingArgs, DebugSettingPtr and DebugSettingPtrOutput values.
// You can construct a concrete instance of `DebugSettingPtrInput` via:
//
//          DebugSettingArgs{...}
//
//  or:
//
//          nil
type DebugSettingPtrInput interface {
	pulumi.Input

	ToDebugSettingPtrOutput() DebugSettingPtrOutput
	ToDebugSettingPtrOutputWithContext(context.Context) DebugSettingPtrOutput
}

type debugSettingPtrType DebugSettingArgs

func DebugSettingPtr(v *DebugSettingArgs) DebugSettingPtrInput {
	return (*debugSettingPtrType)(v)
}

func (*debugSettingPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DebugSetting)(nil)).Elem()
}

func (i *debugSettingPtrType) ToDebugSettingPtrOutput() DebugSettingPtrOutput {
	return i.ToDebugSettingPtrOutputWithContext(context.Background())
}

func (i *debugSettingPtrType) ToDebugSettingPtrOutputWithContext(ctx context.Context) DebugSettingPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DebugSettingPtrOutput)
}

// The debug setting.
type DebugSettingOutput struct{ *pulumi.OutputState }

func (DebugSettingOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DebugSetting)(nil)).Elem()
}

func (o DebugSettingOutput) ToDebugSettingOutput() DebugSettingOutput {
	return o
}

func (o DebugSettingOutput) ToDebugSettingOutputWithContext(ctx context.Context) DebugSettingOutput {
	return o
}

func (o DebugSettingOutput) ToDebugSettingPtrOutput() DebugSettingPtrOutput {
	return o.ToDebugSettingPtrOutputWithContext(context.Background())
}

func (o DebugSettingOutput) ToDebugSettingPtrOutputWithContext(ctx context.Context) DebugSettingPtrOutput {
	return o.ApplyT(func(v DebugSetting) *DebugSetting {
		return &v
	}).(DebugSettingPtrOutput)
}

// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
func (o DebugSettingOutput) DetailLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DebugSetting) *string { return v.DetailLevel }).(pulumi.StringPtrOutput)
}

type DebugSettingPtrOutput struct{ *pulumi.OutputState }

func (DebugSettingPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DebugSetting)(nil)).Elem()
}

func (o DebugSettingPtrOutput) ToDebugSettingPtrOutput() DebugSettingPtrOutput {
	return o
}

func (o DebugSettingPtrOutput) ToDebugSettingPtrOutputWithContext(ctx context.Context) DebugSettingPtrOutput {
	return o
}

func (o DebugSettingPtrOutput) Elem() DebugSettingOutput {
	return o.ApplyT(func(v *DebugSetting) DebugSetting { return *v }).(DebugSettingOutput)
}

// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
func (o DebugSettingPtrOutput) DetailLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DebugSetting) *string {
		if v == nil {
			return nil
		}
		return v.DetailLevel
	}).(pulumi.StringPtrOutput)
}

// The debug setting.
type DebugSettingResponse struct {
	// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
	DetailLevel *string `pulumi:"detailLevel"`
}

// DebugSettingResponseInput is an input type that accepts DebugSettingResponseArgs and DebugSettingResponseOutput values.
// You can construct a concrete instance of `DebugSettingResponseInput` via:
//
//          DebugSettingResponseArgs{...}
type DebugSettingResponseInput interface {
	pulumi.Input

	ToDebugSettingResponseOutput() DebugSettingResponseOutput
	ToDebugSettingResponseOutputWithContext(context.Context) DebugSettingResponseOutput
}

// The debug setting.
type DebugSettingResponseArgs struct {
	// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
	DetailLevel pulumi.StringPtrInput `pulumi:"detailLevel"`
}

func (DebugSettingResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DebugSettingResponse)(nil)).Elem()
}

func (i DebugSettingResponseArgs) ToDebugSettingResponseOutput() DebugSettingResponseOutput {
	return i.ToDebugSettingResponseOutputWithContext(context.Background())
}

func (i DebugSettingResponseArgs) ToDebugSettingResponseOutputWithContext(ctx context.Context) DebugSettingResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DebugSettingResponseOutput)
}

func (i DebugSettingResponseArgs) ToDebugSettingResponsePtrOutput() DebugSettingResponsePtrOutput {
	return i.ToDebugSettingResponsePtrOutputWithContext(context.Background())
}

func (i DebugSettingResponseArgs) ToDebugSettingResponsePtrOutputWithContext(ctx context.Context) DebugSettingResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DebugSettingResponseOutput).ToDebugSettingResponsePtrOutputWithContext(ctx)
}

// DebugSettingResponsePtrInput is an input type that accepts DebugSettingResponseArgs, DebugSettingResponsePtr and DebugSettingResponsePtrOutput values.
// You can construct a concrete instance of `DebugSettingResponsePtrInput` via:
//
//          DebugSettingResponseArgs{...}
//
//  or:
//
//          nil
type DebugSettingResponsePtrInput interface {
	pulumi.Input

	ToDebugSettingResponsePtrOutput() DebugSettingResponsePtrOutput
	ToDebugSettingResponsePtrOutputWithContext(context.Context) DebugSettingResponsePtrOutput
}

type debugSettingResponsePtrType DebugSettingResponseArgs

func DebugSettingResponsePtr(v *DebugSettingResponseArgs) DebugSettingResponsePtrInput {
	return (*debugSettingResponsePtrType)(v)
}

func (*debugSettingResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DebugSettingResponse)(nil)).Elem()
}

func (i *debugSettingResponsePtrType) ToDebugSettingResponsePtrOutput() DebugSettingResponsePtrOutput {
	return i.ToDebugSettingResponsePtrOutputWithContext(context.Background())
}

func (i *debugSettingResponsePtrType) ToDebugSettingResponsePtrOutputWithContext(ctx context.Context) DebugSettingResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DebugSettingResponsePtrOutput)
}

// The debug setting.
type DebugSettingResponseOutput struct{ *pulumi.OutputState }

func (DebugSettingResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DebugSettingResponse)(nil)).Elem()
}

func (o DebugSettingResponseOutput) ToDebugSettingResponseOutput() DebugSettingResponseOutput {
	return o
}

func (o DebugSettingResponseOutput) ToDebugSettingResponseOutputWithContext(ctx context.Context) DebugSettingResponseOutput {
	return o
}

func (o DebugSettingResponseOutput) ToDebugSettingResponsePtrOutput() DebugSettingResponsePtrOutput {
	return o.ToDebugSettingResponsePtrOutputWithContext(context.Background())
}

func (o DebugSettingResponseOutput) ToDebugSettingResponsePtrOutputWithContext(ctx context.Context) DebugSettingResponsePtrOutput {
	return o.ApplyT(func(v DebugSettingResponse) *DebugSettingResponse {
		return &v
	}).(DebugSettingResponsePtrOutput)
}

// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
func (o DebugSettingResponseOutput) DetailLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DebugSettingResponse) *string { return v.DetailLevel }).(pulumi.StringPtrOutput)
}

type DebugSettingResponsePtrOutput struct{ *pulumi.OutputState }

func (DebugSettingResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DebugSettingResponse)(nil)).Elem()
}

func (o DebugSettingResponsePtrOutput) ToDebugSettingResponsePtrOutput() DebugSettingResponsePtrOutput {
	return o
}

func (o DebugSettingResponsePtrOutput) ToDebugSettingResponsePtrOutputWithContext(ctx context.Context) DebugSettingResponsePtrOutput {
	return o
}

func (o DebugSettingResponsePtrOutput) Elem() DebugSettingResponseOutput {
	return o.ApplyT(func(v *DebugSettingResponse) DebugSettingResponse { return *v }).(DebugSettingResponseOutput)
}

// Specifies the type of information to log for debugging. The permitted values are none, requestContent, responseContent, or both requestContent and responseContent separated by a comma. The default is none. When setting this value, carefully consider the type of information you are passing in during deployment. By logging information about the request or response, you could potentially expose sensitive data that is retrieved through the deployment operations.
func (o DebugSettingResponsePtrOutput) DetailLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DebugSettingResponse) *string {
		if v == nil {
			return nil
		}
		return v.DetailLevel
	}).(pulumi.StringPtrOutput)
}

// Deployment dependency information.
type DependencyResponse struct {
	// The list of dependencies.
	DependsOn []BasicDependencyResponse `pulumi:"dependsOn"`
	// The ID of the dependency.
	Id *string `pulumi:"id"`
	// The dependency resource name.
	ResourceName *string `pulumi:"resourceName"`
	// The dependency resource type.
	ResourceType *string `pulumi:"resourceType"`
}

// DependencyResponseInput is an input type that accepts DependencyResponseArgs and DependencyResponseOutput values.
// You can construct a concrete instance of `DependencyResponseInput` via:
//
//          DependencyResponseArgs{...}
type DependencyResponseInput interface {
	pulumi.Input

	ToDependencyResponseOutput() DependencyResponseOutput
	ToDependencyResponseOutputWithContext(context.Context) DependencyResponseOutput
}

// Deployment dependency information.
type DependencyResponseArgs struct {
	// The list of dependencies.
	DependsOn BasicDependencyResponseArrayInput `pulumi:"dependsOn"`
	// The ID of the dependency.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The dependency resource name.
	ResourceName pulumi.StringPtrInput `pulumi:"resourceName"`
	// The dependency resource type.
	ResourceType pulumi.StringPtrInput `pulumi:"resourceType"`
}

func (DependencyResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DependencyResponse)(nil)).Elem()
}

func (i DependencyResponseArgs) ToDependencyResponseOutput() DependencyResponseOutput {
	return i.ToDependencyResponseOutputWithContext(context.Background())
}

func (i DependencyResponseArgs) ToDependencyResponseOutputWithContext(ctx context.Context) DependencyResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DependencyResponseOutput)
}

// DependencyResponseArrayInput is an input type that accepts DependencyResponseArray and DependencyResponseArrayOutput values.
// You can construct a concrete instance of `DependencyResponseArrayInput` via:
//
//          DependencyResponseArray{ DependencyResponseArgs{...} }
type DependencyResponseArrayInput interface {
	pulumi.Input

	ToDependencyResponseArrayOutput() DependencyResponseArrayOutput
	ToDependencyResponseArrayOutputWithContext(context.Context) DependencyResponseArrayOutput
}

type DependencyResponseArray []DependencyResponseInput

func (DependencyResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]DependencyResponse)(nil)).Elem()
}

func (i DependencyResponseArray) ToDependencyResponseArrayOutput() DependencyResponseArrayOutput {
	return i.ToDependencyResponseArrayOutputWithContext(context.Background())
}

func (i DependencyResponseArray) ToDependencyResponseArrayOutputWithContext(ctx context.Context) DependencyResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DependencyResponseArrayOutput)
}

// Deployment dependency information.
type DependencyResponseOutput struct{ *pulumi.OutputState }

func (DependencyResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DependencyResponse)(nil)).Elem()
}

func (o DependencyResponseOutput) ToDependencyResponseOutput() DependencyResponseOutput {
	return o
}

func (o DependencyResponseOutput) ToDependencyResponseOutputWithContext(ctx context.Context) DependencyResponseOutput {
	return o
}

// The list of dependencies.
func (o DependencyResponseOutput) DependsOn() BasicDependencyResponseArrayOutput {
	return o.ApplyT(func(v DependencyResponse) []BasicDependencyResponse { return v.DependsOn }).(BasicDependencyResponseArrayOutput)
}

// The ID of the dependency.
func (o DependencyResponseOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DependencyResponse) *string { return v.Id }).(pulumi.StringPtrOutput)
}

// The dependency resource name.
func (o DependencyResponseOutput) ResourceName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DependencyResponse) *string { return v.ResourceName }).(pulumi.StringPtrOutput)
}

// The dependency resource type.
func (o DependencyResponseOutput) ResourceType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DependencyResponse) *string { return v.ResourceType }).(pulumi.StringPtrOutput)
}

type DependencyResponseArrayOutput struct{ *pulumi.OutputState }

func (DependencyResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]DependencyResponse)(nil)).Elem()
}

func (o DependencyResponseArrayOutput) ToDependencyResponseArrayOutput() DependencyResponseArrayOutput {
	return o
}

func (o DependencyResponseArrayOutput) ToDependencyResponseArrayOutputWithContext(ctx context.Context) DependencyResponseArrayOutput {
	return o
}

func (o DependencyResponseArrayOutput) Index(i pulumi.IntInput) DependencyResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) DependencyResponse {
		return vs[0].([]DependencyResponse)[vs[1].(int)]
	}).(DependencyResponseOutput)
}

// Deployment properties.
type DeploymentProperties struct {
	// The debug setting of the deployment.
	DebugSetting *DebugSetting `pulumi:"debugSetting"`
	// The mode that is used to deploy resources. This value can be either Incremental or Complete. In Incremental mode, resources are deployed without deleting existing resources that are not included in the template. In Complete mode, resources are deployed and existing resources in the resource group that are not included in the template are deleted. Be careful when using Complete mode as you may unintentionally delete resources.
	Mode string `pulumi:"mode"`
	// The deployment on error behavior.
	OnErrorDeployment *OnErrorDeployment `pulumi:"onErrorDeployment"`
	// Name and value pairs that define the deployment parameters for the template. You use this element when you want to provide the parameter values directly in the request rather than link to an existing parameter file. Use either the parametersLink property or the parameters property, but not both. It can be a JObject or a well formed JSON string.
	Parameters interface{} `pulumi:"parameters"`
	// The URI of parameters file. You use this element to link to an existing parameters file. Use either the parametersLink property or the parameters property, but not both.
	ParametersLink *ParametersLink `pulumi:"parametersLink"`
	// The template content. You use this element when you want to pass the template syntax directly in the request rather than link to an existing template. It can be a JObject or well-formed JSON string. Use either the templateLink property or the template property, but not both.
	Template interface{} `pulumi:"template"`
	// The URI of the template. Use either the templateLink property or the template property, but not both.
	TemplateLink *TemplateLink `pulumi:"templateLink"`
}

// DeploymentPropertiesInput is an input type that accepts DeploymentPropertiesArgs and DeploymentPropertiesOutput values.
// You can construct a concrete instance of `DeploymentPropertiesInput` via:
//
//          DeploymentPropertiesArgs{...}
type DeploymentPropertiesInput interface {
	pulumi.Input

	ToDeploymentPropertiesOutput() DeploymentPropertiesOutput
	ToDeploymentPropertiesOutputWithContext(context.Context) DeploymentPropertiesOutput
}

// Deployment properties.
type DeploymentPropertiesArgs struct {
	// The debug setting of the deployment.
	DebugSetting DebugSettingPtrInput `pulumi:"debugSetting"`
	// The mode that is used to deploy resources. This value can be either Incremental or Complete. In Incremental mode, resources are deployed without deleting existing resources that are not included in the template. In Complete mode, resources are deployed and existing resources in the resource group that are not included in the template are deleted. Be careful when using Complete mode as you may unintentionally delete resources.
	Mode DeploymentMode `pulumi:"mode"`
	// The deployment on error behavior.
	OnErrorDeployment OnErrorDeploymentPtrInput `pulumi:"onErrorDeployment"`
	// Name and value pairs that define the deployment parameters for the template. You use this element when you want to provide the parameter values directly in the request rather than link to an existing parameter file. Use either the parametersLink property or the parameters property, but not both. It can be a JObject or a well formed JSON string.
	Parameters pulumi.Input `pulumi:"parameters"`
	// The URI of parameters file. You use this element to link to an existing parameters file. Use either the parametersLink property or the parameters property, but not both.
	ParametersLink ParametersLinkPtrInput `pulumi:"parametersLink"`
	// The template content. You use this element when you want to pass the template syntax directly in the request rather than link to an existing template. It can be a JObject or well-formed JSON string. Use either the templateLink property or the template property, but not both.
	Template pulumi.Input `pulumi:"template"`
	// The URI of the template. Use either the templateLink property or the template property, but not both.
	TemplateLink TemplateLinkPtrInput `pulumi:"templateLink"`
}

func (DeploymentPropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentProperties)(nil)).Elem()
}

func (i DeploymentPropertiesArgs) ToDeploymentPropertiesOutput() DeploymentPropertiesOutput {
	return i.ToDeploymentPropertiesOutputWithContext(context.Background())
}

func (i DeploymentPropertiesArgs) ToDeploymentPropertiesOutputWithContext(ctx context.Context) DeploymentPropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentPropertiesOutput)
}

func (i DeploymentPropertiesArgs) ToDeploymentPropertiesPtrOutput() DeploymentPropertiesPtrOutput {
	return i.ToDeploymentPropertiesPtrOutputWithContext(context.Background())
}

func (i DeploymentPropertiesArgs) ToDeploymentPropertiesPtrOutputWithContext(ctx context.Context) DeploymentPropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentPropertiesOutput).ToDeploymentPropertiesPtrOutputWithContext(ctx)
}

// DeploymentPropertiesPtrInput is an input type that accepts DeploymentPropertiesArgs, DeploymentPropertiesPtr and DeploymentPropertiesPtrOutput values.
// You can construct a concrete instance of `DeploymentPropertiesPtrInput` via:
//
//          DeploymentPropertiesArgs{...}
//
//  or:
//
//          nil
type DeploymentPropertiesPtrInput interface {
	pulumi.Input

	ToDeploymentPropertiesPtrOutput() DeploymentPropertiesPtrOutput
	ToDeploymentPropertiesPtrOutputWithContext(context.Context) DeploymentPropertiesPtrOutput
}

type deploymentPropertiesPtrType DeploymentPropertiesArgs

func DeploymentPropertiesPtr(v *DeploymentPropertiesArgs) DeploymentPropertiesPtrInput {
	return (*deploymentPropertiesPtrType)(v)
}

func (*deploymentPropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentProperties)(nil)).Elem()
}

func (i *deploymentPropertiesPtrType) ToDeploymentPropertiesPtrOutput() DeploymentPropertiesPtrOutput {
	return i.ToDeploymentPropertiesPtrOutputWithContext(context.Background())
}

func (i *deploymentPropertiesPtrType) ToDeploymentPropertiesPtrOutputWithContext(ctx context.Context) DeploymentPropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentPropertiesPtrOutput)
}

// Deployment properties.
type DeploymentPropertiesOutput struct{ *pulumi.OutputState }

func (DeploymentPropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentProperties)(nil)).Elem()
}

func (o DeploymentPropertiesOutput) ToDeploymentPropertiesOutput() DeploymentPropertiesOutput {
	return o
}

func (o DeploymentPropertiesOutput) ToDeploymentPropertiesOutputWithContext(ctx context.Context) DeploymentPropertiesOutput {
	return o
}

func (o DeploymentPropertiesOutput) ToDeploymentPropertiesPtrOutput() DeploymentPropertiesPtrOutput {
	return o.ToDeploymentPropertiesPtrOutputWithContext(context.Background())
}

func (o DeploymentPropertiesOutput) ToDeploymentPropertiesPtrOutputWithContext(ctx context.Context) DeploymentPropertiesPtrOutput {
	return o.ApplyT(func(v DeploymentProperties) *DeploymentProperties {
		return &v
	}).(DeploymentPropertiesPtrOutput)
}

// The debug setting of the deployment.
func (o DeploymentPropertiesOutput) DebugSetting() DebugSettingPtrOutput {
	return o.ApplyT(func(v DeploymentProperties) *DebugSetting { return v.DebugSetting }).(DebugSettingPtrOutput)
}

// The mode that is used to deploy resources. This value can be either Incremental or Complete. In Incremental mode, resources are deployed without deleting existing resources that are not included in the template. In Complete mode, resources are deployed and existing resources in the resource group that are not included in the template are deleted. Be careful when using Complete mode as you may unintentionally delete resources.
func (o DeploymentPropertiesOutput) Mode() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentProperties) string { return v.Mode }).(pulumi.StringOutput)
}

// The deployment on error behavior.
func (o DeploymentPropertiesOutput) OnErrorDeployment() OnErrorDeploymentPtrOutput {
	return o.ApplyT(func(v DeploymentProperties) *OnErrorDeployment { return v.OnErrorDeployment }).(OnErrorDeploymentPtrOutput)
}

// Name and value pairs that define the deployment parameters for the template. You use this element when you want to provide the parameter values directly in the request rather than link to an existing parameter file. Use either the parametersLink property or the parameters property, but not both. It can be a JObject or a well formed JSON string.
func (o DeploymentPropertiesOutput) Parameters() pulumi.AnyOutput {
	return o.ApplyT(func(v DeploymentProperties) interface{} { return v.Parameters }).(pulumi.AnyOutput)
}

// The URI of parameters file. You use this element to link to an existing parameters file. Use either the parametersLink property or the parameters property, but not both.
func (o DeploymentPropertiesOutput) ParametersLink() ParametersLinkPtrOutput {
	return o.ApplyT(func(v DeploymentProperties) *ParametersLink { return v.ParametersLink }).(ParametersLinkPtrOutput)
}

// The template content. You use this element when you want to pass the template syntax directly in the request rather than link to an existing template. It can be a JObject or well-formed JSON string. Use either the templateLink property or the template property, but not both.
func (o DeploymentPropertiesOutput) Template() pulumi.AnyOutput {
	return o.ApplyT(func(v DeploymentProperties) interface{} { return v.Template }).(pulumi.AnyOutput)
}

// The URI of the template. Use either the templateLink property or the template property, but not both.
func (o DeploymentPropertiesOutput) TemplateLink() TemplateLinkPtrOutput {
	return o.ApplyT(func(v DeploymentProperties) *TemplateLink { return v.TemplateLink }).(TemplateLinkPtrOutput)
}

type DeploymentPropertiesPtrOutput struct{ *pulumi.OutputState }

func (DeploymentPropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentProperties)(nil)).Elem()
}

func (o DeploymentPropertiesPtrOutput) ToDeploymentPropertiesPtrOutput() DeploymentPropertiesPtrOutput {
	return o
}

func (o DeploymentPropertiesPtrOutput) ToDeploymentPropertiesPtrOutputWithContext(ctx context.Context) DeploymentPropertiesPtrOutput {
	return o
}

func (o DeploymentPropertiesPtrOutput) Elem() DeploymentPropertiesOutput {
	return o.ApplyT(func(v *DeploymentProperties) DeploymentProperties { return *v }).(DeploymentPropertiesOutput)
}

// The debug setting of the deployment.
func (o DeploymentPropertiesPtrOutput) DebugSetting() DebugSettingPtrOutput {
	return o.ApplyT(func(v *DeploymentProperties) *DebugSetting {
		if v == nil {
			return nil
		}
		return v.DebugSetting
	}).(DebugSettingPtrOutput)
}

// The mode that is used to deploy resources. This value can be either Incremental or Complete. In Incremental mode, resources are deployed without deleting existing resources that are not included in the template. In Complete mode, resources are deployed and existing resources in the resource group that are not included in the template are deleted. Be careful when using Complete mode as you may unintentionally delete resources.
func (o DeploymentPropertiesPtrOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentProperties) *string {
		if v == nil {
			return nil
		}
		return &v.Mode
	}).(pulumi.StringPtrOutput)
}

// The deployment on error behavior.
func (o DeploymentPropertiesPtrOutput) OnErrorDeployment() OnErrorDeploymentPtrOutput {
	return o.ApplyT(func(v *DeploymentProperties) *OnErrorDeployment {
		if v == nil {
			return nil
		}
		return v.OnErrorDeployment
	}).(OnErrorDeploymentPtrOutput)
}

// Name and value pairs that define the deployment parameters for the template. You use this element when you want to provide the parameter values directly in the request rather than link to an existing parameter file. Use either the parametersLink property or the parameters property, but not both. It can be a JObject or a well formed JSON string.
func (o DeploymentPropertiesPtrOutput) Parameters() pulumi.AnyOutput {
	return o.ApplyT(func(v *DeploymentProperties) interface{} {
		if v == nil {
			return nil
		}
		return v.Parameters
	}).(pulumi.AnyOutput)
}

// The URI of parameters file. You use this element to link to an existing parameters file. Use either the parametersLink property or the parameters property, but not both.
func (o DeploymentPropertiesPtrOutput) ParametersLink() ParametersLinkPtrOutput {
	return o.ApplyT(func(v *DeploymentProperties) *ParametersLink {
		if v == nil {
			return nil
		}
		return v.ParametersLink
	}).(ParametersLinkPtrOutput)
}

// The template content. You use this element when you want to pass the template syntax directly in the request rather than link to an existing template. It can be a JObject or well-formed JSON string. Use either the templateLink property or the template property, but not both.
func (o DeploymentPropertiesPtrOutput) Template() pulumi.AnyOutput {
	return o.ApplyT(func(v *DeploymentProperties) interface{} {
		if v == nil {
			return nil
		}
		return v.Template
	}).(pulumi.AnyOutput)
}

// The URI of the template. Use either the templateLink property or the template property, but not both.
func (o DeploymentPropertiesPtrOutput) TemplateLink() TemplateLinkPtrOutput {
	return o.ApplyT(func(v *DeploymentProperties) *TemplateLink {
		if v == nil {
			return nil
		}
		return v.TemplateLink
	}).(TemplateLinkPtrOutput)
}

// Deployment properties with additional details.
type DeploymentPropertiesExtendedResponse struct {
	// The correlation ID of the deployment.
	CorrelationId string `pulumi:"correlationId"`
	// The debug setting of the deployment.
	DebugSetting *DebugSettingResponse `pulumi:"debugSetting"`
	// The list of deployment dependencies.
	Dependencies []DependencyResponse `pulumi:"dependencies"`
	// The duration of the template deployment.
	Duration string `pulumi:"duration"`
	// The deployment mode. Possible values are Incremental and Complete.
	Mode *string `pulumi:"mode"`
	// The deployment on error behavior.
	OnErrorDeployment *OnErrorDeploymentExtendedResponse `pulumi:"onErrorDeployment"`
	// Key/value pairs that represent deployment output.
	Outputs interface{} `pulumi:"outputs"`
	// Deployment parameters. Use only one of Parameters or ParametersLink.
	Parameters interface{} `pulumi:"parameters"`
	// The URI referencing the parameters. Use only one of Parameters or ParametersLink.
	ParametersLink *ParametersLinkResponse `pulumi:"parametersLink"`
	// The list of resource providers needed for the deployment.
	Providers []ProviderResponse `pulumi:"providers"`
	// The state of the provisioning.
	ProvisioningState string `pulumi:"provisioningState"`
	// The template content. Use only one of Template or TemplateLink.
	Template interface{} `pulumi:"template"`
	// The URI referencing the template. Use only one of Template or TemplateLink.
	TemplateLink *TemplateLinkResponse `pulumi:"templateLink"`
	// The timestamp of the template deployment.
	Timestamp string `pulumi:"timestamp"`
}

// DeploymentPropertiesExtendedResponseInput is an input type that accepts DeploymentPropertiesExtendedResponseArgs and DeploymentPropertiesExtendedResponseOutput values.
// You can construct a concrete instance of `DeploymentPropertiesExtendedResponseInput` via:
//
//          DeploymentPropertiesExtendedResponseArgs{...}
type DeploymentPropertiesExtendedResponseInput interface {
	pulumi.Input

	ToDeploymentPropertiesExtendedResponseOutput() DeploymentPropertiesExtendedResponseOutput
	ToDeploymentPropertiesExtendedResponseOutputWithContext(context.Context) DeploymentPropertiesExtendedResponseOutput
}

// Deployment properties with additional details.
type DeploymentPropertiesExtendedResponseArgs struct {
	// The correlation ID of the deployment.
	CorrelationId pulumi.StringInput `pulumi:"correlationId"`
	// The debug setting of the deployment.
	DebugSetting DebugSettingResponsePtrInput `pulumi:"debugSetting"`
	// The list of deployment dependencies.
	Dependencies DependencyResponseArrayInput `pulumi:"dependencies"`
	// The duration of the template deployment.
	Duration pulumi.StringInput `pulumi:"duration"`
	// The deployment mode. Possible values are Incremental and Complete.
	Mode pulumi.StringPtrInput `pulumi:"mode"`
	// The deployment on error behavior.
	OnErrorDeployment OnErrorDeploymentExtendedResponsePtrInput `pulumi:"onErrorDeployment"`
	// Key/value pairs that represent deployment output.
	Outputs pulumi.Input `pulumi:"outputs"`
	// Deployment parameters. Use only one of Parameters or ParametersLink.
	Parameters pulumi.Input `pulumi:"parameters"`
	// The URI referencing the parameters. Use only one of Parameters or ParametersLink.
	ParametersLink ParametersLinkResponsePtrInput `pulumi:"parametersLink"`
	// The list of resource providers needed for the deployment.
	Providers ProviderResponseArrayInput `pulumi:"providers"`
	// The state of the provisioning.
	ProvisioningState pulumi.StringInput `pulumi:"provisioningState"`
	// The template content. Use only one of Template or TemplateLink.
	Template pulumi.Input `pulumi:"template"`
	// The URI referencing the template. Use only one of Template or TemplateLink.
	TemplateLink TemplateLinkResponsePtrInput `pulumi:"templateLink"`
	// The timestamp of the template deployment.
	Timestamp pulumi.StringInput `pulumi:"timestamp"`
}

func (DeploymentPropertiesExtendedResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentPropertiesExtendedResponse)(nil)).Elem()
}

func (i DeploymentPropertiesExtendedResponseArgs) ToDeploymentPropertiesExtendedResponseOutput() DeploymentPropertiesExtendedResponseOutput {
	return i.ToDeploymentPropertiesExtendedResponseOutputWithContext(context.Background())
}

func (i DeploymentPropertiesExtendedResponseArgs) ToDeploymentPropertiesExtendedResponseOutputWithContext(ctx context.Context) DeploymentPropertiesExtendedResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentPropertiesExtendedResponseOutput)
}

func (i DeploymentPropertiesExtendedResponseArgs) ToDeploymentPropertiesExtendedResponsePtrOutput() DeploymentPropertiesExtendedResponsePtrOutput {
	return i.ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(context.Background())
}

func (i DeploymentPropertiesExtendedResponseArgs) ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(ctx context.Context) DeploymentPropertiesExtendedResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentPropertiesExtendedResponseOutput).ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(ctx)
}

// DeploymentPropertiesExtendedResponsePtrInput is an input type that accepts DeploymentPropertiesExtendedResponseArgs, DeploymentPropertiesExtendedResponsePtr and DeploymentPropertiesExtendedResponsePtrOutput values.
// You can construct a concrete instance of `DeploymentPropertiesExtendedResponsePtrInput` via:
//
//          DeploymentPropertiesExtendedResponseArgs{...}
//
//  or:
//
//          nil
type DeploymentPropertiesExtendedResponsePtrInput interface {
	pulumi.Input

	ToDeploymentPropertiesExtendedResponsePtrOutput() DeploymentPropertiesExtendedResponsePtrOutput
	ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(context.Context) DeploymentPropertiesExtendedResponsePtrOutput
}

type deploymentPropertiesExtendedResponsePtrType DeploymentPropertiesExtendedResponseArgs

func DeploymentPropertiesExtendedResponsePtr(v *DeploymentPropertiesExtendedResponseArgs) DeploymentPropertiesExtendedResponsePtrInput {
	return (*deploymentPropertiesExtendedResponsePtrType)(v)
}

func (*deploymentPropertiesExtendedResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentPropertiesExtendedResponse)(nil)).Elem()
}

func (i *deploymentPropertiesExtendedResponsePtrType) ToDeploymentPropertiesExtendedResponsePtrOutput() DeploymentPropertiesExtendedResponsePtrOutput {
	return i.ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(context.Background())
}

func (i *deploymentPropertiesExtendedResponsePtrType) ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(ctx context.Context) DeploymentPropertiesExtendedResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentPropertiesExtendedResponsePtrOutput)
}

// Deployment properties with additional details.
type DeploymentPropertiesExtendedResponseOutput struct{ *pulumi.OutputState }

func (DeploymentPropertiesExtendedResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentPropertiesExtendedResponse)(nil)).Elem()
}

func (o DeploymentPropertiesExtendedResponseOutput) ToDeploymentPropertiesExtendedResponseOutput() DeploymentPropertiesExtendedResponseOutput {
	return o
}

func (o DeploymentPropertiesExtendedResponseOutput) ToDeploymentPropertiesExtendedResponseOutputWithContext(ctx context.Context) DeploymentPropertiesExtendedResponseOutput {
	return o
}

func (o DeploymentPropertiesExtendedResponseOutput) ToDeploymentPropertiesExtendedResponsePtrOutput() DeploymentPropertiesExtendedResponsePtrOutput {
	return o.ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(context.Background())
}

func (o DeploymentPropertiesExtendedResponseOutput) ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(ctx context.Context) DeploymentPropertiesExtendedResponsePtrOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) *DeploymentPropertiesExtendedResponse {
		return &v
	}).(DeploymentPropertiesExtendedResponsePtrOutput)
}

// The correlation ID of the deployment.
func (o DeploymentPropertiesExtendedResponseOutput) CorrelationId() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) string { return v.CorrelationId }).(pulumi.StringOutput)
}

// The debug setting of the deployment.
func (o DeploymentPropertiesExtendedResponseOutput) DebugSetting() DebugSettingResponsePtrOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) *DebugSettingResponse { return v.DebugSetting }).(DebugSettingResponsePtrOutput)
}

// The list of deployment dependencies.
func (o DeploymentPropertiesExtendedResponseOutput) Dependencies() DependencyResponseArrayOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) []DependencyResponse { return v.Dependencies }).(DependencyResponseArrayOutput)
}

// The duration of the template deployment.
func (o DeploymentPropertiesExtendedResponseOutput) Duration() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) string { return v.Duration }).(pulumi.StringOutput)
}

// The deployment mode. Possible values are Incremental and Complete.
func (o DeploymentPropertiesExtendedResponseOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) *string { return v.Mode }).(pulumi.StringPtrOutput)
}

// The deployment on error behavior.
func (o DeploymentPropertiesExtendedResponseOutput) OnErrorDeployment() OnErrorDeploymentExtendedResponsePtrOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) *OnErrorDeploymentExtendedResponse {
		return v.OnErrorDeployment
	}).(OnErrorDeploymentExtendedResponsePtrOutput)
}

// Key/value pairs that represent deployment output.
func (o DeploymentPropertiesExtendedResponseOutput) Outputs() pulumi.AnyOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) interface{} { return v.Outputs }).(pulumi.AnyOutput)
}

// Deployment parameters. Use only one of Parameters or ParametersLink.
func (o DeploymentPropertiesExtendedResponseOutput) Parameters() pulumi.AnyOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) interface{} { return v.Parameters }).(pulumi.AnyOutput)
}

// The URI referencing the parameters. Use only one of Parameters or ParametersLink.
func (o DeploymentPropertiesExtendedResponseOutput) ParametersLink() ParametersLinkResponsePtrOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) *ParametersLinkResponse { return v.ParametersLink }).(ParametersLinkResponsePtrOutput)
}

// The list of resource providers needed for the deployment.
func (o DeploymentPropertiesExtendedResponseOutput) Providers() ProviderResponseArrayOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) []ProviderResponse { return v.Providers }).(ProviderResponseArrayOutput)
}

// The state of the provisioning.
func (o DeploymentPropertiesExtendedResponseOutput) ProvisioningState() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) string { return v.ProvisioningState }).(pulumi.StringOutput)
}

// The template content. Use only one of Template or TemplateLink.
func (o DeploymentPropertiesExtendedResponseOutput) Template() pulumi.AnyOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) interface{} { return v.Template }).(pulumi.AnyOutput)
}

// The URI referencing the template. Use only one of Template or TemplateLink.
func (o DeploymentPropertiesExtendedResponseOutput) TemplateLink() TemplateLinkResponsePtrOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) *TemplateLinkResponse { return v.TemplateLink }).(TemplateLinkResponsePtrOutput)
}

// The timestamp of the template deployment.
func (o DeploymentPropertiesExtendedResponseOutput) Timestamp() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentPropertiesExtendedResponse) string { return v.Timestamp }).(pulumi.StringOutput)
}

type DeploymentPropertiesExtendedResponsePtrOutput struct{ *pulumi.OutputState }

func (DeploymentPropertiesExtendedResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentPropertiesExtendedResponse)(nil)).Elem()
}

func (o DeploymentPropertiesExtendedResponsePtrOutput) ToDeploymentPropertiesExtendedResponsePtrOutput() DeploymentPropertiesExtendedResponsePtrOutput {
	return o
}

func (o DeploymentPropertiesExtendedResponsePtrOutput) ToDeploymentPropertiesExtendedResponsePtrOutputWithContext(ctx context.Context) DeploymentPropertiesExtendedResponsePtrOutput {
	return o
}

func (o DeploymentPropertiesExtendedResponsePtrOutput) Elem() DeploymentPropertiesExtendedResponseOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) DeploymentPropertiesExtendedResponse { return *v }).(DeploymentPropertiesExtendedResponseOutput)
}

// The correlation ID of the deployment.
func (o DeploymentPropertiesExtendedResponsePtrOutput) CorrelationId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return &v.CorrelationId
	}).(pulumi.StringPtrOutput)
}

// The debug setting of the deployment.
func (o DeploymentPropertiesExtendedResponsePtrOutput) DebugSetting() DebugSettingResponsePtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *DebugSettingResponse {
		if v == nil {
			return nil
		}
		return v.DebugSetting
	}).(DebugSettingResponsePtrOutput)
}

// The list of deployment dependencies.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Dependencies() DependencyResponseArrayOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) []DependencyResponse {
		if v == nil {
			return nil
		}
		return v.Dependencies
	}).(DependencyResponseArrayOutput)
}

// The duration of the template deployment.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Duration() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Duration
	}).(pulumi.StringPtrOutput)
}

// The deployment mode. Possible values are Incremental and Complete.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return v.Mode
	}).(pulumi.StringPtrOutput)
}

// The deployment on error behavior.
func (o DeploymentPropertiesExtendedResponsePtrOutput) OnErrorDeployment() OnErrorDeploymentExtendedResponsePtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *OnErrorDeploymentExtendedResponse {
		if v == nil {
			return nil
		}
		return v.OnErrorDeployment
	}).(OnErrorDeploymentExtendedResponsePtrOutput)
}

// Key/value pairs that represent deployment output.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Outputs() pulumi.AnyOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) interface{} {
		if v == nil {
			return nil
		}
		return v.Outputs
	}).(pulumi.AnyOutput)
}

// Deployment parameters. Use only one of Parameters or ParametersLink.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Parameters() pulumi.AnyOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) interface{} {
		if v == nil {
			return nil
		}
		return v.Parameters
	}).(pulumi.AnyOutput)
}

// The URI referencing the parameters. Use only one of Parameters or ParametersLink.
func (o DeploymentPropertiesExtendedResponsePtrOutput) ParametersLink() ParametersLinkResponsePtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *ParametersLinkResponse {
		if v == nil {
			return nil
		}
		return v.ParametersLink
	}).(ParametersLinkResponsePtrOutput)
}

// The list of resource providers needed for the deployment.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Providers() ProviderResponseArrayOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) []ProviderResponse {
		if v == nil {
			return nil
		}
		return v.Providers
	}).(ProviderResponseArrayOutput)
}

// The state of the provisioning.
func (o DeploymentPropertiesExtendedResponsePtrOutput) ProvisioningState() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ProvisioningState
	}).(pulumi.StringPtrOutput)
}

// The template content. Use only one of Template or TemplateLink.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Template() pulumi.AnyOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) interface{} {
		if v == nil {
			return nil
		}
		return v.Template
	}).(pulumi.AnyOutput)
}

// The URI referencing the template. Use only one of Template or TemplateLink.
func (o DeploymentPropertiesExtendedResponsePtrOutput) TemplateLink() TemplateLinkResponsePtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *TemplateLinkResponse {
		if v == nil {
			return nil
		}
		return v.TemplateLink
	}).(TemplateLinkResponsePtrOutput)
}

// The timestamp of the template deployment.
func (o DeploymentPropertiesExtendedResponsePtrOutput) Timestamp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentPropertiesExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Timestamp
	}).(pulumi.StringPtrOutput)
}

// Identity for the resource.
type Identity struct {
	// The identity type.
	Type *string `pulumi:"type"`
	// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
	UserAssignedIdentities map[string]interface{} `pulumi:"userAssignedIdentities"`
}

// IdentityInput is an input type that accepts IdentityArgs and IdentityOutput values.
// You can construct a concrete instance of `IdentityInput` via:
//
//          IdentityArgs{...}
type IdentityInput interface {
	pulumi.Input

	ToIdentityOutput() IdentityOutput
	ToIdentityOutputWithContext(context.Context) IdentityOutput
}

// Identity for the resource.
type IdentityArgs struct {
	// The identity type.
	Type *ResourceIdentityType `pulumi:"type"`
	// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
	UserAssignedIdentities pulumi.MapInput `pulumi:"userAssignedIdentities"`
}

func (IdentityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Identity)(nil)).Elem()
}

func (i IdentityArgs) ToIdentityOutput() IdentityOutput {
	return i.ToIdentityOutputWithContext(context.Background())
}

func (i IdentityArgs) ToIdentityOutputWithContext(ctx context.Context) IdentityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityOutput)
}

func (i IdentityArgs) ToIdentityPtrOutput() IdentityPtrOutput {
	return i.ToIdentityPtrOutputWithContext(context.Background())
}

func (i IdentityArgs) ToIdentityPtrOutputWithContext(ctx context.Context) IdentityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityOutput).ToIdentityPtrOutputWithContext(ctx)
}

// IdentityPtrInput is an input type that accepts IdentityArgs, IdentityPtr and IdentityPtrOutput values.
// You can construct a concrete instance of `IdentityPtrInput` via:
//
//          IdentityArgs{...}
//
//  or:
//
//          nil
type IdentityPtrInput interface {
	pulumi.Input

	ToIdentityPtrOutput() IdentityPtrOutput
	ToIdentityPtrOutputWithContext(context.Context) IdentityPtrOutput
}

type identityPtrType IdentityArgs

func IdentityPtr(v *IdentityArgs) IdentityPtrInput {
	return (*identityPtrType)(v)
}

func (*identityPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Identity)(nil)).Elem()
}

func (i *identityPtrType) ToIdentityPtrOutput() IdentityPtrOutput {
	return i.ToIdentityPtrOutputWithContext(context.Background())
}

func (i *identityPtrType) ToIdentityPtrOutputWithContext(ctx context.Context) IdentityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityPtrOutput)
}

// Identity for the resource.
type IdentityOutput struct{ *pulumi.OutputState }

func (IdentityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Identity)(nil)).Elem()
}

func (o IdentityOutput) ToIdentityOutput() IdentityOutput {
	return o
}

func (o IdentityOutput) ToIdentityOutputWithContext(ctx context.Context) IdentityOutput {
	return o
}

func (o IdentityOutput) ToIdentityPtrOutput() IdentityPtrOutput {
	return o.ToIdentityPtrOutputWithContext(context.Background())
}

func (o IdentityOutput) ToIdentityPtrOutputWithContext(ctx context.Context) IdentityPtrOutput {
	return o.ApplyT(func(v Identity) *Identity {
		return &v
	}).(IdentityPtrOutput)
}

// The identity type.
func (o IdentityOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Identity) *string { return v.Type }).(pulumi.StringPtrOutput)
}

// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
func (o IdentityOutput) UserAssignedIdentities() pulumi.MapOutput {
	return o.ApplyT(func(v Identity) map[string]interface{} { return v.UserAssignedIdentities }).(pulumi.MapOutput)
}

type IdentityPtrOutput struct{ *pulumi.OutputState }

func (IdentityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Identity)(nil)).Elem()
}

func (o IdentityPtrOutput) ToIdentityPtrOutput() IdentityPtrOutput {
	return o
}

func (o IdentityPtrOutput) ToIdentityPtrOutputWithContext(ctx context.Context) IdentityPtrOutput {
	return o
}

func (o IdentityPtrOutput) Elem() IdentityOutput {
	return o.ApplyT(func(v *Identity) Identity { return *v }).(IdentityOutput)
}

// The identity type.
func (o IdentityPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Identity) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
func (o IdentityPtrOutput) UserAssignedIdentities() pulumi.MapOutput {
	return o.ApplyT(func(v *Identity) map[string]interface{} {
		if v == nil {
			return nil
		}
		return v.UserAssignedIdentities
	}).(pulumi.MapOutput)
}

// Identity for the resource.
type IdentityResponse struct {
	// The principal ID of resource identity.
	PrincipalId string `pulumi:"principalId"`
	// The tenant ID of resource.
	TenantId string `pulumi:"tenantId"`
	// The identity type.
	Type *string `pulumi:"type"`
	// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
	UserAssignedIdentities map[string]IdentityResponseUserAssignedIdentities `pulumi:"userAssignedIdentities"`
}

// IdentityResponseInput is an input type that accepts IdentityResponseArgs and IdentityResponseOutput values.
// You can construct a concrete instance of `IdentityResponseInput` via:
//
//          IdentityResponseArgs{...}
type IdentityResponseInput interface {
	pulumi.Input

	ToIdentityResponseOutput() IdentityResponseOutput
	ToIdentityResponseOutputWithContext(context.Context) IdentityResponseOutput
}

// Identity for the resource.
type IdentityResponseArgs struct {
	// The principal ID of resource identity.
	PrincipalId pulumi.StringInput `pulumi:"principalId"`
	// The tenant ID of resource.
	TenantId pulumi.StringInput `pulumi:"tenantId"`
	// The identity type.
	Type pulumi.StringPtrInput `pulumi:"type"`
	// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
	UserAssignedIdentities IdentityResponseUserAssignedIdentitiesMapInput `pulumi:"userAssignedIdentities"`
}

func (IdentityResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*IdentityResponse)(nil)).Elem()
}

func (i IdentityResponseArgs) ToIdentityResponseOutput() IdentityResponseOutput {
	return i.ToIdentityResponseOutputWithContext(context.Background())
}

func (i IdentityResponseArgs) ToIdentityResponseOutputWithContext(ctx context.Context) IdentityResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityResponseOutput)
}

func (i IdentityResponseArgs) ToIdentityResponsePtrOutput() IdentityResponsePtrOutput {
	return i.ToIdentityResponsePtrOutputWithContext(context.Background())
}

func (i IdentityResponseArgs) ToIdentityResponsePtrOutputWithContext(ctx context.Context) IdentityResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityResponseOutput).ToIdentityResponsePtrOutputWithContext(ctx)
}

// IdentityResponsePtrInput is an input type that accepts IdentityResponseArgs, IdentityResponsePtr and IdentityResponsePtrOutput values.
// You can construct a concrete instance of `IdentityResponsePtrInput` via:
//
//          IdentityResponseArgs{...}
//
//  or:
//
//          nil
type IdentityResponsePtrInput interface {
	pulumi.Input

	ToIdentityResponsePtrOutput() IdentityResponsePtrOutput
	ToIdentityResponsePtrOutputWithContext(context.Context) IdentityResponsePtrOutput
}

type identityResponsePtrType IdentityResponseArgs

func IdentityResponsePtr(v *IdentityResponseArgs) IdentityResponsePtrInput {
	return (*identityResponsePtrType)(v)
}

func (*identityResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**IdentityResponse)(nil)).Elem()
}

func (i *identityResponsePtrType) ToIdentityResponsePtrOutput() IdentityResponsePtrOutput {
	return i.ToIdentityResponsePtrOutputWithContext(context.Background())
}

func (i *identityResponsePtrType) ToIdentityResponsePtrOutputWithContext(ctx context.Context) IdentityResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityResponsePtrOutput)
}

// Identity for the resource.
type IdentityResponseOutput struct{ *pulumi.OutputState }

func (IdentityResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*IdentityResponse)(nil)).Elem()
}

func (o IdentityResponseOutput) ToIdentityResponseOutput() IdentityResponseOutput {
	return o
}

func (o IdentityResponseOutput) ToIdentityResponseOutputWithContext(ctx context.Context) IdentityResponseOutput {
	return o
}

func (o IdentityResponseOutput) ToIdentityResponsePtrOutput() IdentityResponsePtrOutput {
	return o.ToIdentityResponsePtrOutputWithContext(context.Background())
}

func (o IdentityResponseOutput) ToIdentityResponsePtrOutputWithContext(ctx context.Context) IdentityResponsePtrOutput {
	return o.ApplyT(func(v IdentityResponse) *IdentityResponse {
		return &v
	}).(IdentityResponsePtrOutput)
}

// The principal ID of resource identity.
func (o IdentityResponseOutput) PrincipalId() pulumi.StringOutput {
	return o.ApplyT(func(v IdentityResponse) string { return v.PrincipalId }).(pulumi.StringOutput)
}

// The tenant ID of resource.
func (o IdentityResponseOutput) TenantId() pulumi.StringOutput {
	return o.ApplyT(func(v IdentityResponse) string { return v.TenantId }).(pulumi.StringOutput)
}

// The identity type.
func (o IdentityResponseOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v IdentityResponse) *string { return v.Type }).(pulumi.StringPtrOutput)
}

// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
func (o IdentityResponseOutput) UserAssignedIdentities() IdentityResponseUserAssignedIdentitiesMapOutput {
	return o.ApplyT(func(v IdentityResponse) map[string]IdentityResponseUserAssignedIdentities {
		return v.UserAssignedIdentities
	}).(IdentityResponseUserAssignedIdentitiesMapOutput)
}

type IdentityResponsePtrOutput struct{ *pulumi.OutputState }

func (IdentityResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**IdentityResponse)(nil)).Elem()
}

func (o IdentityResponsePtrOutput) ToIdentityResponsePtrOutput() IdentityResponsePtrOutput {
	return o
}

func (o IdentityResponsePtrOutput) ToIdentityResponsePtrOutputWithContext(ctx context.Context) IdentityResponsePtrOutput {
	return o
}

func (o IdentityResponsePtrOutput) Elem() IdentityResponseOutput {
	return o.ApplyT(func(v *IdentityResponse) IdentityResponse { return *v }).(IdentityResponseOutput)
}

// The principal ID of resource identity.
func (o IdentityResponsePtrOutput) PrincipalId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *IdentityResponse) *string {
		if v == nil {
			return nil
		}
		return &v.PrincipalId
	}).(pulumi.StringPtrOutput)
}

// The tenant ID of resource.
func (o IdentityResponsePtrOutput) TenantId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *IdentityResponse) *string {
		if v == nil {
			return nil
		}
		return &v.TenantId
	}).(pulumi.StringPtrOutput)
}

// The identity type.
func (o IdentityResponsePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *IdentityResponse) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
func (o IdentityResponsePtrOutput) UserAssignedIdentities() IdentityResponseUserAssignedIdentitiesMapOutput {
	return o.ApplyT(func(v *IdentityResponse) map[string]IdentityResponseUserAssignedIdentities {
		if v == nil {
			return nil
		}
		return v.UserAssignedIdentities
	}).(IdentityResponseUserAssignedIdentitiesMapOutput)
}

type IdentityResponseUserAssignedIdentities struct {
	// The client id of user assigned identity.
	ClientId string `pulumi:"clientId"`
	// The principal id of user assigned identity.
	PrincipalId string `pulumi:"principalId"`
}

// IdentityResponseUserAssignedIdentitiesInput is an input type that accepts IdentityResponseUserAssignedIdentitiesArgs and IdentityResponseUserAssignedIdentitiesOutput values.
// You can construct a concrete instance of `IdentityResponseUserAssignedIdentitiesInput` via:
//
//          IdentityResponseUserAssignedIdentitiesArgs{...}
type IdentityResponseUserAssignedIdentitiesInput interface {
	pulumi.Input

	ToIdentityResponseUserAssignedIdentitiesOutput() IdentityResponseUserAssignedIdentitiesOutput
	ToIdentityResponseUserAssignedIdentitiesOutputWithContext(context.Context) IdentityResponseUserAssignedIdentitiesOutput
}

type IdentityResponseUserAssignedIdentitiesArgs struct {
	// The client id of user assigned identity.
	ClientId pulumi.StringInput `pulumi:"clientId"`
	// The principal id of user assigned identity.
	PrincipalId pulumi.StringInput `pulumi:"principalId"`
}

func (IdentityResponseUserAssignedIdentitiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*IdentityResponseUserAssignedIdentities)(nil)).Elem()
}

func (i IdentityResponseUserAssignedIdentitiesArgs) ToIdentityResponseUserAssignedIdentitiesOutput() IdentityResponseUserAssignedIdentitiesOutput {
	return i.ToIdentityResponseUserAssignedIdentitiesOutputWithContext(context.Background())
}

func (i IdentityResponseUserAssignedIdentitiesArgs) ToIdentityResponseUserAssignedIdentitiesOutputWithContext(ctx context.Context) IdentityResponseUserAssignedIdentitiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityResponseUserAssignedIdentitiesOutput)
}

// IdentityResponseUserAssignedIdentitiesMapInput is an input type that accepts IdentityResponseUserAssignedIdentitiesMap and IdentityResponseUserAssignedIdentitiesMapOutput values.
// You can construct a concrete instance of `IdentityResponseUserAssignedIdentitiesMapInput` via:
//
//          IdentityResponseUserAssignedIdentitiesMap{ "key": IdentityResponseUserAssignedIdentitiesArgs{...} }
type IdentityResponseUserAssignedIdentitiesMapInput interface {
	pulumi.Input

	ToIdentityResponseUserAssignedIdentitiesMapOutput() IdentityResponseUserAssignedIdentitiesMapOutput
	ToIdentityResponseUserAssignedIdentitiesMapOutputWithContext(context.Context) IdentityResponseUserAssignedIdentitiesMapOutput
}

type IdentityResponseUserAssignedIdentitiesMap map[string]IdentityResponseUserAssignedIdentitiesInput

func (IdentityResponseUserAssignedIdentitiesMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]IdentityResponseUserAssignedIdentities)(nil)).Elem()
}

func (i IdentityResponseUserAssignedIdentitiesMap) ToIdentityResponseUserAssignedIdentitiesMapOutput() IdentityResponseUserAssignedIdentitiesMapOutput {
	return i.ToIdentityResponseUserAssignedIdentitiesMapOutputWithContext(context.Background())
}

func (i IdentityResponseUserAssignedIdentitiesMap) ToIdentityResponseUserAssignedIdentitiesMapOutputWithContext(ctx context.Context) IdentityResponseUserAssignedIdentitiesMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(IdentityResponseUserAssignedIdentitiesMapOutput)
}

type IdentityResponseUserAssignedIdentitiesOutput struct{ *pulumi.OutputState }

func (IdentityResponseUserAssignedIdentitiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*IdentityResponseUserAssignedIdentities)(nil)).Elem()
}

func (o IdentityResponseUserAssignedIdentitiesOutput) ToIdentityResponseUserAssignedIdentitiesOutput() IdentityResponseUserAssignedIdentitiesOutput {
	return o
}

func (o IdentityResponseUserAssignedIdentitiesOutput) ToIdentityResponseUserAssignedIdentitiesOutputWithContext(ctx context.Context) IdentityResponseUserAssignedIdentitiesOutput {
	return o
}

// The client id of user assigned identity.
func (o IdentityResponseUserAssignedIdentitiesOutput) ClientId() pulumi.StringOutput {
	return o.ApplyT(func(v IdentityResponseUserAssignedIdentities) string { return v.ClientId }).(pulumi.StringOutput)
}

// The principal id of user assigned identity.
func (o IdentityResponseUserAssignedIdentitiesOutput) PrincipalId() pulumi.StringOutput {
	return o.ApplyT(func(v IdentityResponseUserAssignedIdentities) string { return v.PrincipalId }).(pulumi.StringOutput)
}

type IdentityResponseUserAssignedIdentitiesMapOutput struct{ *pulumi.OutputState }

func (IdentityResponseUserAssignedIdentitiesMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]IdentityResponseUserAssignedIdentities)(nil)).Elem()
}

func (o IdentityResponseUserAssignedIdentitiesMapOutput) ToIdentityResponseUserAssignedIdentitiesMapOutput() IdentityResponseUserAssignedIdentitiesMapOutput {
	return o
}

func (o IdentityResponseUserAssignedIdentitiesMapOutput) ToIdentityResponseUserAssignedIdentitiesMapOutputWithContext(ctx context.Context) IdentityResponseUserAssignedIdentitiesMapOutput {
	return o
}

func (o IdentityResponseUserAssignedIdentitiesMapOutput) MapIndex(k pulumi.StringInput) IdentityResponseUserAssignedIdentitiesOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) IdentityResponseUserAssignedIdentities {
		return vs[0].(map[string]IdentityResponseUserAssignedIdentities)[vs[1].(string)]
	}).(IdentityResponseUserAssignedIdentitiesOutput)
}

// Deployment on error behavior.
type OnErrorDeployment struct {
	// The deployment to be used on error case.
	DeploymentName *string `pulumi:"deploymentName"`
	// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
	Type *string `pulumi:"type"`
}

// OnErrorDeploymentInput is an input type that accepts OnErrorDeploymentArgs and OnErrorDeploymentOutput values.
// You can construct a concrete instance of `OnErrorDeploymentInput` via:
//
//          OnErrorDeploymentArgs{...}
type OnErrorDeploymentInput interface {
	pulumi.Input

	ToOnErrorDeploymentOutput() OnErrorDeploymentOutput
	ToOnErrorDeploymentOutputWithContext(context.Context) OnErrorDeploymentOutput
}

// Deployment on error behavior.
type OnErrorDeploymentArgs struct {
	// The deployment to be used on error case.
	DeploymentName pulumi.StringPtrInput `pulumi:"deploymentName"`
	// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
	Type *OnErrorDeploymentType `pulumi:"type"`
}

func (OnErrorDeploymentArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*OnErrorDeployment)(nil)).Elem()
}

func (i OnErrorDeploymentArgs) ToOnErrorDeploymentOutput() OnErrorDeploymentOutput {
	return i.ToOnErrorDeploymentOutputWithContext(context.Background())
}

func (i OnErrorDeploymentArgs) ToOnErrorDeploymentOutputWithContext(ctx context.Context) OnErrorDeploymentOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OnErrorDeploymentOutput)
}

func (i OnErrorDeploymentArgs) ToOnErrorDeploymentPtrOutput() OnErrorDeploymentPtrOutput {
	return i.ToOnErrorDeploymentPtrOutputWithContext(context.Background())
}

func (i OnErrorDeploymentArgs) ToOnErrorDeploymentPtrOutputWithContext(ctx context.Context) OnErrorDeploymentPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OnErrorDeploymentOutput).ToOnErrorDeploymentPtrOutputWithContext(ctx)
}

// OnErrorDeploymentPtrInput is an input type that accepts OnErrorDeploymentArgs, OnErrorDeploymentPtr and OnErrorDeploymentPtrOutput values.
// You can construct a concrete instance of `OnErrorDeploymentPtrInput` via:
//
//          OnErrorDeploymentArgs{...}
//
//  or:
//
//          nil
type OnErrorDeploymentPtrInput interface {
	pulumi.Input

	ToOnErrorDeploymentPtrOutput() OnErrorDeploymentPtrOutput
	ToOnErrorDeploymentPtrOutputWithContext(context.Context) OnErrorDeploymentPtrOutput
}

type onErrorDeploymentPtrType OnErrorDeploymentArgs

func OnErrorDeploymentPtr(v *OnErrorDeploymentArgs) OnErrorDeploymentPtrInput {
	return (*onErrorDeploymentPtrType)(v)
}

func (*onErrorDeploymentPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**OnErrorDeployment)(nil)).Elem()
}

func (i *onErrorDeploymentPtrType) ToOnErrorDeploymentPtrOutput() OnErrorDeploymentPtrOutput {
	return i.ToOnErrorDeploymentPtrOutputWithContext(context.Background())
}

func (i *onErrorDeploymentPtrType) ToOnErrorDeploymentPtrOutputWithContext(ctx context.Context) OnErrorDeploymentPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OnErrorDeploymentPtrOutput)
}

// Deployment on error behavior.
type OnErrorDeploymentOutput struct{ *pulumi.OutputState }

func (OnErrorDeploymentOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*OnErrorDeployment)(nil)).Elem()
}

func (o OnErrorDeploymentOutput) ToOnErrorDeploymentOutput() OnErrorDeploymentOutput {
	return o
}

func (o OnErrorDeploymentOutput) ToOnErrorDeploymentOutputWithContext(ctx context.Context) OnErrorDeploymentOutput {
	return o
}

func (o OnErrorDeploymentOutput) ToOnErrorDeploymentPtrOutput() OnErrorDeploymentPtrOutput {
	return o.ToOnErrorDeploymentPtrOutputWithContext(context.Background())
}

func (o OnErrorDeploymentOutput) ToOnErrorDeploymentPtrOutputWithContext(ctx context.Context) OnErrorDeploymentPtrOutput {
	return o.ApplyT(func(v OnErrorDeployment) *OnErrorDeployment {
		return &v
	}).(OnErrorDeploymentPtrOutput)
}

// The deployment to be used on error case.
func (o OnErrorDeploymentOutput) DeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v OnErrorDeployment) *string { return v.DeploymentName }).(pulumi.StringPtrOutput)
}

// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
func (o OnErrorDeploymentOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v OnErrorDeployment) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type OnErrorDeploymentPtrOutput struct{ *pulumi.OutputState }

func (OnErrorDeploymentPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**OnErrorDeployment)(nil)).Elem()
}

func (o OnErrorDeploymentPtrOutput) ToOnErrorDeploymentPtrOutput() OnErrorDeploymentPtrOutput {
	return o
}

func (o OnErrorDeploymentPtrOutput) ToOnErrorDeploymentPtrOutputWithContext(ctx context.Context) OnErrorDeploymentPtrOutput {
	return o
}

func (o OnErrorDeploymentPtrOutput) Elem() OnErrorDeploymentOutput {
	return o.ApplyT(func(v *OnErrorDeployment) OnErrorDeployment { return *v }).(OnErrorDeploymentOutput)
}

// The deployment to be used on error case.
func (o OnErrorDeploymentPtrOutput) DeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *OnErrorDeployment) *string {
		if v == nil {
			return nil
		}
		return v.DeploymentName
	}).(pulumi.StringPtrOutput)
}

// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
func (o OnErrorDeploymentPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *OnErrorDeployment) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// Deployment on error behavior with additional details.
type OnErrorDeploymentExtendedResponse struct {
	// The deployment to be used on error case.
	DeploymentName *string `pulumi:"deploymentName"`
	// The state of the provisioning for the on error deployment.
	ProvisioningState string `pulumi:"provisioningState"`
	// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
	Type *string `pulumi:"type"`
}

// OnErrorDeploymentExtendedResponseInput is an input type that accepts OnErrorDeploymentExtendedResponseArgs and OnErrorDeploymentExtendedResponseOutput values.
// You can construct a concrete instance of `OnErrorDeploymentExtendedResponseInput` via:
//
//          OnErrorDeploymentExtendedResponseArgs{...}
type OnErrorDeploymentExtendedResponseInput interface {
	pulumi.Input

	ToOnErrorDeploymentExtendedResponseOutput() OnErrorDeploymentExtendedResponseOutput
	ToOnErrorDeploymentExtendedResponseOutputWithContext(context.Context) OnErrorDeploymentExtendedResponseOutput
}

// Deployment on error behavior with additional details.
type OnErrorDeploymentExtendedResponseArgs struct {
	// The deployment to be used on error case.
	DeploymentName pulumi.StringPtrInput `pulumi:"deploymentName"`
	// The state of the provisioning for the on error deployment.
	ProvisioningState pulumi.StringInput `pulumi:"provisioningState"`
	// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (OnErrorDeploymentExtendedResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*OnErrorDeploymentExtendedResponse)(nil)).Elem()
}

func (i OnErrorDeploymentExtendedResponseArgs) ToOnErrorDeploymentExtendedResponseOutput() OnErrorDeploymentExtendedResponseOutput {
	return i.ToOnErrorDeploymentExtendedResponseOutputWithContext(context.Background())
}

func (i OnErrorDeploymentExtendedResponseArgs) ToOnErrorDeploymentExtendedResponseOutputWithContext(ctx context.Context) OnErrorDeploymentExtendedResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OnErrorDeploymentExtendedResponseOutput)
}

func (i OnErrorDeploymentExtendedResponseArgs) ToOnErrorDeploymentExtendedResponsePtrOutput() OnErrorDeploymentExtendedResponsePtrOutput {
	return i.ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(context.Background())
}

func (i OnErrorDeploymentExtendedResponseArgs) ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(ctx context.Context) OnErrorDeploymentExtendedResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OnErrorDeploymentExtendedResponseOutput).ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(ctx)
}

// OnErrorDeploymentExtendedResponsePtrInput is an input type that accepts OnErrorDeploymentExtendedResponseArgs, OnErrorDeploymentExtendedResponsePtr and OnErrorDeploymentExtendedResponsePtrOutput values.
// You can construct a concrete instance of `OnErrorDeploymentExtendedResponsePtrInput` via:
//
//          OnErrorDeploymentExtendedResponseArgs{...}
//
//  or:
//
//          nil
type OnErrorDeploymentExtendedResponsePtrInput interface {
	pulumi.Input

	ToOnErrorDeploymentExtendedResponsePtrOutput() OnErrorDeploymentExtendedResponsePtrOutput
	ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(context.Context) OnErrorDeploymentExtendedResponsePtrOutput
}

type onErrorDeploymentExtendedResponsePtrType OnErrorDeploymentExtendedResponseArgs

func OnErrorDeploymentExtendedResponsePtr(v *OnErrorDeploymentExtendedResponseArgs) OnErrorDeploymentExtendedResponsePtrInput {
	return (*onErrorDeploymentExtendedResponsePtrType)(v)
}

func (*onErrorDeploymentExtendedResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**OnErrorDeploymentExtendedResponse)(nil)).Elem()
}

func (i *onErrorDeploymentExtendedResponsePtrType) ToOnErrorDeploymentExtendedResponsePtrOutput() OnErrorDeploymentExtendedResponsePtrOutput {
	return i.ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(context.Background())
}

func (i *onErrorDeploymentExtendedResponsePtrType) ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(ctx context.Context) OnErrorDeploymentExtendedResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OnErrorDeploymentExtendedResponsePtrOutput)
}

// Deployment on error behavior with additional details.
type OnErrorDeploymentExtendedResponseOutput struct{ *pulumi.OutputState }

func (OnErrorDeploymentExtendedResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*OnErrorDeploymentExtendedResponse)(nil)).Elem()
}

func (o OnErrorDeploymentExtendedResponseOutput) ToOnErrorDeploymentExtendedResponseOutput() OnErrorDeploymentExtendedResponseOutput {
	return o
}

func (o OnErrorDeploymentExtendedResponseOutput) ToOnErrorDeploymentExtendedResponseOutputWithContext(ctx context.Context) OnErrorDeploymentExtendedResponseOutput {
	return o
}

func (o OnErrorDeploymentExtendedResponseOutput) ToOnErrorDeploymentExtendedResponsePtrOutput() OnErrorDeploymentExtendedResponsePtrOutput {
	return o.ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(context.Background())
}

func (o OnErrorDeploymentExtendedResponseOutput) ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(ctx context.Context) OnErrorDeploymentExtendedResponsePtrOutput {
	return o.ApplyT(func(v OnErrorDeploymentExtendedResponse) *OnErrorDeploymentExtendedResponse {
		return &v
	}).(OnErrorDeploymentExtendedResponsePtrOutput)
}

// The deployment to be used on error case.
func (o OnErrorDeploymentExtendedResponseOutput) DeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v OnErrorDeploymentExtendedResponse) *string { return v.DeploymentName }).(pulumi.StringPtrOutput)
}

// The state of the provisioning for the on error deployment.
func (o OnErrorDeploymentExtendedResponseOutput) ProvisioningState() pulumi.StringOutput {
	return o.ApplyT(func(v OnErrorDeploymentExtendedResponse) string { return v.ProvisioningState }).(pulumi.StringOutput)
}

// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
func (o OnErrorDeploymentExtendedResponseOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v OnErrorDeploymentExtendedResponse) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type OnErrorDeploymentExtendedResponsePtrOutput struct{ *pulumi.OutputState }

func (OnErrorDeploymentExtendedResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**OnErrorDeploymentExtendedResponse)(nil)).Elem()
}

func (o OnErrorDeploymentExtendedResponsePtrOutput) ToOnErrorDeploymentExtendedResponsePtrOutput() OnErrorDeploymentExtendedResponsePtrOutput {
	return o
}

func (o OnErrorDeploymentExtendedResponsePtrOutput) ToOnErrorDeploymentExtendedResponsePtrOutputWithContext(ctx context.Context) OnErrorDeploymentExtendedResponsePtrOutput {
	return o
}

func (o OnErrorDeploymentExtendedResponsePtrOutput) Elem() OnErrorDeploymentExtendedResponseOutput {
	return o.ApplyT(func(v *OnErrorDeploymentExtendedResponse) OnErrorDeploymentExtendedResponse { return *v }).(OnErrorDeploymentExtendedResponseOutput)
}

// The deployment to be used on error case.
func (o OnErrorDeploymentExtendedResponsePtrOutput) DeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *OnErrorDeploymentExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return v.DeploymentName
	}).(pulumi.StringPtrOutput)
}

// The state of the provisioning for the on error deployment.
func (o OnErrorDeploymentExtendedResponsePtrOutput) ProvisioningState() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *OnErrorDeploymentExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ProvisioningState
	}).(pulumi.StringPtrOutput)
}

// The deployment on error behavior type. Possible values are LastSuccessful and SpecificDeployment.
func (o OnErrorDeploymentExtendedResponsePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *OnErrorDeploymentExtendedResponse) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// Entity representing the reference to the deployment parameters.
type ParametersLink struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion *string `pulumi:"contentVersion"`
	// The URI of the parameters file.
	Uri string `pulumi:"uri"`
}

// ParametersLinkInput is an input type that accepts ParametersLinkArgs and ParametersLinkOutput values.
// You can construct a concrete instance of `ParametersLinkInput` via:
//
//          ParametersLinkArgs{...}
type ParametersLinkInput interface {
	pulumi.Input

	ToParametersLinkOutput() ParametersLinkOutput
	ToParametersLinkOutputWithContext(context.Context) ParametersLinkOutput
}

// Entity representing the reference to the deployment parameters.
type ParametersLinkArgs struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion pulumi.StringPtrInput `pulumi:"contentVersion"`
	// The URI of the parameters file.
	Uri pulumi.StringInput `pulumi:"uri"`
}

func (ParametersLinkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ParametersLink)(nil)).Elem()
}

func (i ParametersLinkArgs) ToParametersLinkOutput() ParametersLinkOutput {
	return i.ToParametersLinkOutputWithContext(context.Background())
}

func (i ParametersLinkArgs) ToParametersLinkOutputWithContext(ctx context.Context) ParametersLinkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ParametersLinkOutput)
}

func (i ParametersLinkArgs) ToParametersLinkPtrOutput() ParametersLinkPtrOutput {
	return i.ToParametersLinkPtrOutputWithContext(context.Background())
}

func (i ParametersLinkArgs) ToParametersLinkPtrOutputWithContext(ctx context.Context) ParametersLinkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ParametersLinkOutput).ToParametersLinkPtrOutputWithContext(ctx)
}

// ParametersLinkPtrInput is an input type that accepts ParametersLinkArgs, ParametersLinkPtr and ParametersLinkPtrOutput values.
// You can construct a concrete instance of `ParametersLinkPtrInput` via:
//
//          ParametersLinkArgs{...}
//
//  or:
//
//          nil
type ParametersLinkPtrInput interface {
	pulumi.Input

	ToParametersLinkPtrOutput() ParametersLinkPtrOutput
	ToParametersLinkPtrOutputWithContext(context.Context) ParametersLinkPtrOutput
}

type parametersLinkPtrType ParametersLinkArgs

func ParametersLinkPtr(v *ParametersLinkArgs) ParametersLinkPtrInput {
	return (*parametersLinkPtrType)(v)
}

func (*parametersLinkPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ParametersLink)(nil)).Elem()
}

func (i *parametersLinkPtrType) ToParametersLinkPtrOutput() ParametersLinkPtrOutput {
	return i.ToParametersLinkPtrOutputWithContext(context.Background())
}

func (i *parametersLinkPtrType) ToParametersLinkPtrOutputWithContext(ctx context.Context) ParametersLinkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ParametersLinkPtrOutput)
}

// Entity representing the reference to the deployment parameters.
type ParametersLinkOutput struct{ *pulumi.OutputState }

func (ParametersLinkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ParametersLink)(nil)).Elem()
}

func (o ParametersLinkOutput) ToParametersLinkOutput() ParametersLinkOutput {
	return o
}

func (o ParametersLinkOutput) ToParametersLinkOutputWithContext(ctx context.Context) ParametersLinkOutput {
	return o
}

func (o ParametersLinkOutput) ToParametersLinkPtrOutput() ParametersLinkPtrOutput {
	return o.ToParametersLinkPtrOutputWithContext(context.Background())
}

func (o ParametersLinkOutput) ToParametersLinkPtrOutputWithContext(ctx context.Context) ParametersLinkPtrOutput {
	return o.ApplyT(func(v ParametersLink) *ParametersLink {
		return &v
	}).(ParametersLinkPtrOutput)
}

// If included, must match the ContentVersion in the template.
func (o ParametersLinkOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ParametersLink) *string { return v.ContentVersion }).(pulumi.StringPtrOutput)
}

// The URI of the parameters file.
func (o ParametersLinkOutput) Uri() pulumi.StringOutput {
	return o.ApplyT(func(v ParametersLink) string { return v.Uri }).(pulumi.StringOutput)
}

type ParametersLinkPtrOutput struct{ *pulumi.OutputState }

func (ParametersLinkPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ParametersLink)(nil)).Elem()
}

func (o ParametersLinkPtrOutput) ToParametersLinkPtrOutput() ParametersLinkPtrOutput {
	return o
}

func (o ParametersLinkPtrOutput) ToParametersLinkPtrOutputWithContext(ctx context.Context) ParametersLinkPtrOutput {
	return o
}

func (o ParametersLinkPtrOutput) Elem() ParametersLinkOutput {
	return o.ApplyT(func(v *ParametersLink) ParametersLink { return *v }).(ParametersLinkOutput)
}

// If included, must match the ContentVersion in the template.
func (o ParametersLinkPtrOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ParametersLink) *string {
		if v == nil {
			return nil
		}
		return v.ContentVersion
	}).(pulumi.StringPtrOutput)
}

// The URI of the parameters file.
func (o ParametersLinkPtrOutput) Uri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ParametersLink) *string {
		if v == nil {
			return nil
		}
		return &v.Uri
	}).(pulumi.StringPtrOutput)
}

// Entity representing the reference to the deployment parameters.
type ParametersLinkResponse struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion *string `pulumi:"contentVersion"`
	// The URI of the parameters file.
	Uri string `pulumi:"uri"`
}

// ParametersLinkResponseInput is an input type that accepts ParametersLinkResponseArgs and ParametersLinkResponseOutput values.
// You can construct a concrete instance of `ParametersLinkResponseInput` via:
//
//          ParametersLinkResponseArgs{...}
type ParametersLinkResponseInput interface {
	pulumi.Input

	ToParametersLinkResponseOutput() ParametersLinkResponseOutput
	ToParametersLinkResponseOutputWithContext(context.Context) ParametersLinkResponseOutput
}

// Entity representing the reference to the deployment parameters.
type ParametersLinkResponseArgs struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion pulumi.StringPtrInput `pulumi:"contentVersion"`
	// The URI of the parameters file.
	Uri pulumi.StringInput `pulumi:"uri"`
}

func (ParametersLinkResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ParametersLinkResponse)(nil)).Elem()
}

func (i ParametersLinkResponseArgs) ToParametersLinkResponseOutput() ParametersLinkResponseOutput {
	return i.ToParametersLinkResponseOutputWithContext(context.Background())
}

func (i ParametersLinkResponseArgs) ToParametersLinkResponseOutputWithContext(ctx context.Context) ParametersLinkResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ParametersLinkResponseOutput)
}

func (i ParametersLinkResponseArgs) ToParametersLinkResponsePtrOutput() ParametersLinkResponsePtrOutput {
	return i.ToParametersLinkResponsePtrOutputWithContext(context.Background())
}

func (i ParametersLinkResponseArgs) ToParametersLinkResponsePtrOutputWithContext(ctx context.Context) ParametersLinkResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ParametersLinkResponseOutput).ToParametersLinkResponsePtrOutputWithContext(ctx)
}

// ParametersLinkResponsePtrInput is an input type that accepts ParametersLinkResponseArgs, ParametersLinkResponsePtr and ParametersLinkResponsePtrOutput values.
// You can construct a concrete instance of `ParametersLinkResponsePtrInput` via:
//
//          ParametersLinkResponseArgs{...}
//
//  or:
//
//          nil
type ParametersLinkResponsePtrInput interface {
	pulumi.Input

	ToParametersLinkResponsePtrOutput() ParametersLinkResponsePtrOutput
	ToParametersLinkResponsePtrOutputWithContext(context.Context) ParametersLinkResponsePtrOutput
}

type parametersLinkResponsePtrType ParametersLinkResponseArgs

func ParametersLinkResponsePtr(v *ParametersLinkResponseArgs) ParametersLinkResponsePtrInput {
	return (*parametersLinkResponsePtrType)(v)
}

func (*parametersLinkResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ParametersLinkResponse)(nil)).Elem()
}

func (i *parametersLinkResponsePtrType) ToParametersLinkResponsePtrOutput() ParametersLinkResponsePtrOutput {
	return i.ToParametersLinkResponsePtrOutputWithContext(context.Background())
}

func (i *parametersLinkResponsePtrType) ToParametersLinkResponsePtrOutputWithContext(ctx context.Context) ParametersLinkResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ParametersLinkResponsePtrOutput)
}

// Entity representing the reference to the deployment parameters.
type ParametersLinkResponseOutput struct{ *pulumi.OutputState }

func (ParametersLinkResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ParametersLinkResponse)(nil)).Elem()
}

func (o ParametersLinkResponseOutput) ToParametersLinkResponseOutput() ParametersLinkResponseOutput {
	return o
}

func (o ParametersLinkResponseOutput) ToParametersLinkResponseOutputWithContext(ctx context.Context) ParametersLinkResponseOutput {
	return o
}

func (o ParametersLinkResponseOutput) ToParametersLinkResponsePtrOutput() ParametersLinkResponsePtrOutput {
	return o.ToParametersLinkResponsePtrOutputWithContext(context.Background())
}

func (o ParametersLinkResponseOutput) ToParametersLinkResponsePtrOutputWithContext(ctx context.Context) ParametersLinkResponsePtrOutput {
	return o.ApplyT(func(v ParametersLinkResponse) *ParametersLinkResponse {
		return &v
	}).(ParametersLinkResponsePtrOutput)
}

// If included, must match the ContentVersion in the template.
func (o ParametersLinkResponseOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ParametersLinkResponse) *string { return v.ContentVersion }).(pulumi.StringPtrOutput)
}

// The URI of the parameters file.
func (o ParametersLinkResponseOutput) Uri() pulumi.StringOutput {
	return o.ApplyT(func(v ParametersLinkResponse) string { return v.Uri }).(pulumi.StringOutput)
}

type ParametersLinkResponsePtrOutput struct{ *pulumi.OutputState }

func (ParametersLinkResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ParametersLinkResponse)(nil)).Elem()
}

func (o ParametersLinkResponsePtrOutput) ToParametersLinkResponsePtrOutput() ParametersLinkResponsePtrOutput {
	return o
}

func (o ParametersLinkResponsePtrOutput) ToParametersLinkResponsePtrOutputWithContext(ctx context.Context) ParametersLinkResponsePtrOutput {
	return o
}

func (o ParametersLinkResponsePtrOutput) Elem() ParametersLinkResponseOutput {
	return o.ApplyT(func(v *ParametersLinkResponse) ParametersLinkResponse { return *v }).(ParametersLinkResponseOutput)
}

// If included, must match the ContentVersion in the template.
func (o ParametersLinkResponsePtrOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ParametersLinkResponse) *string {
		if v == nil {
			return nil
		}
		return v.ContentVersion
	}).(pulumi.StringPtrOutput)
}

// The URI of the parameters file.
func (o ParametersLinkResponsePtrOutput) Uri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ParametersLinkResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Uri
	}).(pulumi.StringPtrOutput)
}

// Plan for the resource.
type Plan struct {
	// The plan ID.
	Name *string `pulumi:"name"`
	// The offer ID.
	Product *string `pulumi:"product"`
	// The promotion code.
	PromotionCode *string `pulumi:"promotionCode"`
	// The publisher ID.
	Publisher *string `pulumi:"publisher"`
	// The plan's version.
	Version *string `pulumi:"version"`
}

// PlanInput is an input type that accepts PlanArgs and PlanOutput values.
// You can construct a concrete instance of `PlanInput` via:
//
//          PlanArgs{...}
type PlanInput interface {
	pulumi.Input

	ToPlanOutput() PlanOutput
	ToPlanOutputWithContext(context.Context) PlanOutput
}

// Plan for the resource.
type PlanArgs struct {
	// The plan ID.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The offer ID.
	Product pulumi.StringPtrInput `pulumi:"product"`
	// The promotion code.
	PromotionCode pulumi.StringPtrInput `pulumi:"promotionCode"`
	// The publisher ID.
	Publisher pulumi.StringPtrInput `pulumi:"publisher"`
	// The plan's version.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (PlanArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Plan)(nil)).Elem()
}

func (i PlanArgs) ToPlanOutput() PlanOutput {
	return i.ToPlanOutputWithContext(context.Background())
}

func (i PlanArgs) ToPlanOutputWithContext(ctx context.Context) PlanOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PlanOutput)
}

func (i PlanArgs) ToPlanPtrOutput() PlanPtrOutput {
	return i.ToPlanPtrOutputWithContext(context.Background())
}

func (i PlanArgs) ToPlanPtrOutputWithContext(ctx context.Context) PlanPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PlanOutput).ToPlanPtrOutputWithContext(ctx)
}

// PlanPtrInput is an input type that accepts PlanArgs, PlanPtr and PlanPtrOutput values.
// You can construct a concrete instance of `PlanPtrInput` via:
//
//          PlanArgs{...}
//
//  or:
//
//          nil
type PlanPtrInput interface {
	pulumi.Input

	ToPlanPtrOutput() PlanPtrOutput
	ToPlanPtrOutputWithContext(context.Context) PlanPtrOutput
}

type planPtrType PlanArgs

func PlanPtr(v *PlanArgs) PlanPtrInput {
	return (*planPtrType)(v)
}

func (*planPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Plan)(nil)).Elem()
}

func (i *planPtrType) ToPlanPtrOutput() PlanPtrOutput {
	return i.ToPlanPtrOutputWithContext(context.Background())
}

func (i *planPtrType) ToPlanPtrOutputWithContext(ctx context.Context) PlanPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PlanPtrOutput)
}

// Plan for the resource.
type PlanOutput struct{ *pulumi.OutputState }

func (PlanOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Plan)(nil)).Elem()
}

func (o PlanOutput) ToPlanOutput() PlanOutput {
	return o
}

func (o PlanOutput) ToPlanOutputWithContext(ctx context.Context) PlanOutput {
	return o
}

func (o PlanOutput) ToPlanPtrOutput() PlanPtrOutput {
	return o.ToPlanPtrOutputWithContext(context.Background())
}

func (o PlanOutput) ToPlanPtrOutputWithContext(ctx context.Context) PlanPtrOutput {
	return o.ApplyT(func(v Plan) *Plan {
		return &v
	}).(PlanPtrOutput)
}

// The plan ID.
func (o PlanOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Plan) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The offer ID.
func (o PlanOutput) Product() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Plan) *string { return v.Product }).(pulumi.StringPtrOutput)
}

// The promotion code.
func (o PlanOutput) PromotionCode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Plan) *string { return v.PromotionCode }).(pulumi.StringPtrOutput)
}

// The publisher ID.
func (o PlanOutput) Publisher() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Plan) *string { return v.Publisher }).(pulumi.StringPtrOutput)
}

// The plan's version.
func (o PlanOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Plan) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type PlanPtrOutput struct{ *pulumi.OutputState }

func (PlanPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Plan)(nil)).Elem()
}

func (o PlanPtrOutput) ToPlanPtrOutput() PlanPtrOutput {
	return o
}

func (o PlanPtrOutput) ToPlanPtrOutputWithContext(ctx context.Context) PlanPtrOutput {
	return o
}

func (o PlanPtrOutput) Elem() PlanOutput {
	return o.ApplyT(func(v *Plan) Plan { return *v }).(PlanOutput)
}

// The plan ID.
func (o PlanPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Plan) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// The offer ID.
func (o PlanPtrOutput) Product() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Plan) *string {
		if v == nil {
			return nil
		}
		return v.Product
	}).(pulumi.StringPtrOutput)
}

// The promotion code.
func (o PlanPtrOutput) PromotionCode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Plan) *string {
		if v == nil {
			return nil
		}
		return v.PromotionCode
	}).(pulumi.StringPtrOutput)
}

// The publisher ID.
func (o PlanPtrOutput) Publisher() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Plan) *string {
		if v == nil {
			return nil
		}
		return v.Publisher
	}).(pulumi.StringPtrOutput)
}

// The plan's version.
func (o PlanPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Plan) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// Plan for the resource.
type PlanResponse struct {
	// The plan ID.
	Name *string `pulumi:"name"`
	// The offer ID.
	Product *string `pulumi:"product"`
	// The promotion code.
	PromotionCode *string `pulumi:"promotionCode"`
	// The publisher ID.
	Publisher *string `pulumi:"publisher"`
	// The plan's version.
	Version *string `pulumi:"version"`
}

// PlanResponseInput is an input type that accepts PlanResponseArgs and PlanResponseOutput values.
// You can construct a concrete instance of `PlanResponseInput` via:
//
//          PlanResponseArgs{...}
type PlanResponseInput interface {
	pulumi.Input

	ToPlanResponseOutput() PlanResponseOutput
	ToPlanResponseOutputWithContext(context.Context) PlanResponseOutput
}

// Plan for the resource.
type PlanResponseArgs struct {
	// The plan ID.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The offer ID.
	Product pulumi.StringPtrInput `pulumi:"product"`
	// The promotion code.
	PromotionCode pulumi.StringPtrInput `pulumi:"promotionCode"`
	// The publisher ID.
	Publisher pulumi.StringPtrInput `pulumi:"publisher"`
	// The plan's version.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (PlanResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PlanResponse)(nil)).Elem()
}

func (i PlanResponseArgs) ToPlanResponseOutput() PlanResponseOutput {
	return i.ToPlanResponseOutputWithContext(context.Background())
}

func (i PlanResponseArgs) ToPlanResponseOutputWithContext(ctx context.Context) PlanResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PlanResponseOutput)
}

func (i PlanResponseArgs) ToPlanResponsePtrOutput() PlanResponsePtrOutput {
	return i.ToPlanResponsePtrOutputWithContext(context.Background())
}

func (i PlanResponseArgs) ToPlanResponsePtrOutputWithContext(ctx context.Context) PlanResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PlanResponseOutput).ToPlanResponsePtrOutputWithContext(ctx)
}

// PlanResponsePtrInput is an input type that accepts PlanResponseArgs, PlanResponsePtr and PlanResponsePtrOutput values.
// You can construct a concrete instance of `PlanResponsePtrInput` via:
//
//          PlanResponseArgs{...}
//
//  or:
//
//          nil
type PlanResponsePtrInput interface {
	pulumi.Input

	ToPlanResponsePtrOutput() PlanResponsePtrOutput
	ToPlanResponsePtrOutputWithContext(context.Context) PlanResponsePtrOutput
}

type planResponsePtrType PlanResponseArgs

func PlanResponsePtr(v *PlanResponseArgs) PlanResponsePtrInput {
	return (*planResponsePtrType)(v)
}

func (*planResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PlanResponse)(nil)).Elem()
}

func (i *planResponsePtrType) ToPlanResponsePtrOutput() PlanResponsePtrOutput {
	return i.ToPlanResponsePtrOutputWithContext(context.Background())
}

func (i *planResponsePtrType) ToPlanResponsePtrOutputWithContext(ctx context.Context) PlanResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PlanResponsePtrOutput)
}

// Plan for the resource.
type PlanResponseOutput struct{ *pulumi.OutputState }

func (PlanResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PlanResponse)(nil)).Elem()
}

func (o PlanResponseOutput) ToPlanResponseOutput() PlanResponseOutput {
	return o
}

func (o PlanResponseOutput) ToPlanResponseOutputWithContext(ctx context.Context) PlanResponseOutput {
	return o
}

func (o PlanResponseOutput) ToPlanResponsePtrOutput() PlanResponsePtrOutput {
	return o.ToPlanResponsePtrOutputWithContext(context.Background())
}

func (o PlanResponseOutput) ToPlanResponsePtrOutputWithContext(ctx context.Context) PlanResponsePtrOutput {
	return o.ApplyT(func(v PlanResponse) *PlanResponse {
		return &v
	}).(PlanResponsePtrOutput)
}

// The plan ID.
func (o PlanResponseOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PlanResponse) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The offer ID.
func (o PlanResponseOutput) Product() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PlanResponse) *string { return v.Product }).(pulumi.StringPtrOutput)
}

// The promotion code.
func (o PlanResponseOutput) PromotionCode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PlanResponse) *string { return v.PromotionCode }).(pulumi.StringPtrOutput)
}

// The publisher ID.
func (o PlanResponseOutput) Publisher() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PlanResponse) *string { return v.Publisher }).(pulumi.StringPtrOutput)
}

// The plan's version.
func (o PlanResponseOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PlanResponse) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type PlanResponsePtrOutput struct{ *pulumi.OutputState }

func (PlanResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PlanResponse)(nil)).Elem()
}

func (o PlanResponsePtrOutput) ToPlanResponsePtrOutput() PlanResponsePtrOutput {
	return o
}

func (o PlanResponsePtrOutput) ToPlanResponsePtrOutputWithContext(ctx context.Context) PlanResponsePtrOutput {
	return o
}

func (o PlanResponsePtrOutput) Elem() PlanResponseOutput {
	return o.ApplyT(func(v *PlanResponse) PlanResponse { return *v }).(PlanResponseOutput)
}

// The plan ID.
func (o PlanResponsePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PlanResponse) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// The offer ID.
func (o PlanResponsePtrOutput) Product() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PlanResponse) *string {
		if v == nil {
			return nil
		}
		return v.Product
	}).(pulumi.StringPtrOutput)
}

// The promotion code.
func (o PlanResponsePtrOutput) PromotionCode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PlanResponse) *string {
		if v == nil {
			return nil
		}
		return v.PromotionCode
	}).(pulumi.StringPtrOutput)
}

// The publisher ID.
func (o PlanResponsePtrOutput) Publisher() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PlanResponse) *string {
		if v == nil {
			return nil
		}
		return v.Publisher
	}).(pulumi.StringPtrOutput)
}

// The plan's version.
func (o PlanResponsePtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PlanResponse) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// Resource type managed by the resource provider.
type ProviderResourceTypeResponse struct {
	// The aliases that are supported by this resource type.
	Aliases []AliasTypeResponse `pulumi:"aliases"`
	// The API version.
	ApiVersions []string `pulumi:"apiVersions"`
	// The additional capabilities offered by this resource type.
	Capabilities *string `pulumi:"capabilities"`
	// The collection of locations where this resource type can be created.
	Locations []string `pulumi:"locations"`
	// The properties.
	Properties map[string]string `pulumi:"properties"`
	// The resource type.
	ResourceType *string `pulumi:"resourceType"`
}

// ProviderResourceTypeResponseInput is an input type that accepts ProviderResourceTypeResponseArgs and ProviderResourceTypeResponseOutput values.
// You can construct a concrete instance of `ProviderResourceTypeResponseInput` via:
//
//          ProviderResourceTypeResponseArgs{...}
type ProviderResourceTypeResponseInput interface {
	pulumi.Input

	ToProviderResourceTypeResponseOutput() ProviderResourceTypeResponseOutput
	ToProviderResourceTypeResponseOutputWithContext(context.Context) ProviderResourceTypeResponseOutput
}

// Resource type managed by the resource provider.
type ProviderResourceTypeResponseArgs struct {
	// The aliases that are supported by this resource type.
	Aliases AliasTypeResponseArrayInput `pulumi:"aliases"`
	// The API version.
	ApiVersions pulumi.StringArrayInput `pulumi:"apiVersions"`
	// The additional capabilities offered by this resource type.
	Capabilities pulumi.StringPtrInput `pulumi:"capabilities"`
	// The collection of locations where this resource type can be created.
	Locations pulumi.StringArrayInput `pulumi:"locations"`
	// The properties.
	Properties pulumi.StringMapInput `pulumi:"properties"`
	// The resource type.
	ResourceType pulumi.StringPtrInput `pulumi:"resourceType"`
}

func (ProviderResourceTypeResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ProviderResourceTypeResponse)(nil)).Elem()
}

func (i ProviderResourceTypeResponseArgs) ToProviderResourceTypeResponseOutput() ProviderResourceTypeResponseOutput {
	return i.ToProviderResourceTypeResponseOutputWithContext(context.Background())
}

func (i ProviderResourceTypeResponseArgs) ToProviderResourceTypeResponseOutputWithContext(ctx context.Context) ProviderResourceTypeResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProviderResourceTypeResponseOutput)
}

// ProviderResourceTypeResponseArrayInput is an input type that accepts ProviderResourceTypeResponseArray and ProviderResourceTypeResponseArrayOutput values.
// You can construct a concrete instance of `ProviderResourceTypeResponseArrayInput` via:
//
//          ProviderResourceTypeResponseArray{ ProviderResourceTypeResponseArgs{...} }
type ProviderResourceTypeResponseArrayInput interface {
	pulumi.Input

	ToProviderResourceTypeResponseArrayOutput() ProviderResourceTypeResponseArrayOutput
	ToProviderResourceTypeResponseArrayOutputWithContext(context.Context) ProviderResourceTypeResponseArrayOutput
}

type ProviderResourceTypeResponseArray []ProviderResourceTypeResponseInput

func (ProviderResourceTypeResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ProviderResourceTypeResponse)(nil)).Elem()
}

func (i ProviderResourceTypeResponseArray) ToProviderResourceTypeResponseArrayOutput() ProviderResourceTypeResponseArrayOutput {
	return i.ToProviderResourceTypeResponseArrayOutputWithContext(context.Background())
}

func (i ProviderResourceTypeResponseArray) ToProviderResourceTypeResponseArrayOutputWithContext(ctx context.Context) ProviderResourceTypeResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProviderResourceTypeResponseArrayOutput)
}

// Resource type managed by the resource provider.
type ProviderResourceTypeResponseOutput struct{ *pulumi.OutputState }

func (ProviderResourceTypeResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ProviderResourceTypeResponse)(nil)).Elem()
}

func (o ProviderResourceTypeResponseOutput) ToProviderResourceTypeResponseOutput() ProviderResourceTypeResponseOutput {
	return o
}

func (o ProviderResourceTypeResponseOutput) ToProviderResourceTypeResponseOutputWithContext(ctx context.Context) ProviderResourceTypeResponseOutput {
	return o
}

// The aliases that are supported by this resource type.
func (o ProviderResourceTypeResponseOutput) Aliases() AliasTypeResponseArrayOutput {
	return o.ApplyT(func(v ProviderResourceTypeResponse) []AliasTypeResponse { return v.Aliases }).(AliasTypeResponseArrayOutput)
}

// The API version.
func (o ProviderResourceTypeResponseOutput) ApiVersions() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ProviderResourceTypeResponse) []string { return v.ApiVersions }).(pulumi.StringArrayOutput)
}

// The additional capabilities offered by this resource type.
func (o ProviderResourceTypeResponseOutput) Capabilities() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ProviderResourceTypeResponse) *string { return v.Capabilities }).(pulumi.StringPtrOutput)
}

// The collection of locations where this resource type can be created.
func (o ProviderResourceTypeResponseOutput) Locations() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ProviderResourceTypeResponse) []string { return v.Locations }).(pulumi.StringArrayOutput)
}

// The properties.
func (o ProviderResourceTypeResponseOutput) Properties() pulumi.StringMapOutput {
	return o.ApplyT(func(v ProviderResourceTypeResponse) map[string]string { return v.Properties }).(pulumi.StringMapOutput)
}

// The resource type.
func (o ProviderResourceTypeResponseOutput) ResourceType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ProviderResourceTypeResponse) *string { return v.ResourceType }).(pulumi.StringPtrOutput)
}

type ProviderResourceTypeResponseArrayOutput struct{ *pulumi.OutputState }

func (ProviderResourceTypeResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ProviderResourceTypeResponse)(nil)).Elem()
}

func (o ProviderResourceTypeResponseArrayOutput) ToProviderResourceTypeResponseArrayOutput() ProviderResourceTypeResponseArrayOutput {
	return o
}

func (o ProviderResourceTypeResponseArrayOutput) ToProviderResourceTypeResponseArrayOutputWithContext(ctx context.Context) ProviderResourceTypeResponseArrayOutput {
	return o
}

func (o ProviderResourceTypeResponseArrayOutput) Index(i pulumi.IntInput) ProviderResourceTypeResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ProviderResourceTypeResponse {
		return vs[0].([]ProviderResourceTypeResponse)[vs[1].(int)]
	}).(ProviderResourceTypeResponseOutput)
}

// Resource provider information.
type ProviderResponse struct {
	// The provider ID.
	Id string `pulumi:"id"`
	// The namespace of the resource provider.
	Namespace *string `pulumi:"namespace"`
	// The registration policy of the resource provider.
	RegistrationPolicy string `pulumi:"registrationPolicy"`
	// The registration state of the resource provider.
	RegistrationState string `pulumi:"registrationState"`
	// The collection of provider resource types.
	ResourceTypes []ProviderResourceTypeResponse `pulumi:"resourceTypes"`
}

// ProviderResponseInput is an input type that accepts ProviderResponseArgs and ProviderResponseOutput values.
// You can construct a concrete instance of `ProviderResponseInput` via:
//
//          ProviderResponseArgs{...}
type ProviderResponseInput interface {
	pulumi.Input

	ToProviderResponseOutput() ProviderResponseOutput
	ToProviderResponseOutputWithContext(context.Context) ProviderResponseOutput
}

// Resource provider information.
type ProviderResponseArgs struct {
	// The provider ID.
	Id pulumi.StringInput `pulumi:"id"`
	// The namespace of the resource provider.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
	// The registration policy of the resource provider.
	RegistrationPolicy pulumi.StringInput `pulumi:"registrationPolicy"`
	// The registration state of the resource provider.
	RegistrationState pulumi.StringInput `pulumi:"registrationState"`
	// The collection of provider resource types.
	ResourceTypes ProviderResourceTypeResponseArrayInput `pulumi:"resourceTypes"`
}

func (ProviderResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ProviderResponse)(nil)).Elem()
}

func (i ProviderResponseArgs) ToProviderResponseOutput() ProviderResponseOutput {
	return i.ToProviderResponseOutputWithContext(context.Background())
}

func (i ProviderResponseArgs) ToProviderResponseOutputWithContext(ctx context.Context) ProviderResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProviderResponseOutput)
}

// ProviderResponseArrayInput is an input type that accepts ProviderResponseArray and ProviderResponseArrayOutput values.
// You can construct a concrete instance of `ProviderResponseArrayInput` via:
//
//          ProviderResponseArray{ ProviderResponseArgs{...} }
type ProviderResponseArrayInput interface {
	pulumi.Input

	ToProviderResponseArrayOutput() ProviderResponseArrayOutput
	ToProviderResponseArrayOutputWithContext(context.Context) ProviderResponseArrayOutput
}

type ProviderResponseArray []ProviderResponseInput

func (ProviderResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ProviderResponse)(nil)).Elem()
}

func (i ProviderResponseArray) ToProviderResponseArrayOutput() ProviderResponseArrayOutput {
	return i.ToProviderResponseArrayOutputWithContext(context.Background())
}

func (i ProviderResponseArray) ToProviderResponseArrayOutputWithContext(ctx context.Context) ProviderResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProviderResponseArrayOutput)
}

// Resource provider information.
type ProviderResponseOutput struct{ *pulumi.OutputState }

func (ProviderResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ProviderResponse)(nil)).Elem()
}

func (o ProviderResponseOutput) ToProviderResponseOutput() ProviderResponseOutput {
	return o
}

func (o ProviderResponseOutput) ToProviderResponseOutputWithContext(ctx context.Context) ProviderResponseOutput {
	return o
}

// The provider ID.
func (o ProviderResponseOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v ProviderResponse) string { return v.Id }).(pulumi.StringOutput)
}

// The namespace of the resource provider.
func (o ProviderResponseOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ProviderResponse) *string { return v.Namespace }).(pulumi.StringPtrOutput)
}

// The registration policy of the resource provider.
func (o ProviderResponseOutput) RegistrationPolicy() pulumi.StringOutput {
	return o.ApplyT(func(v ProviderResponse) string { return v.RegistrationPolicy }).(pulumi.StringOutput)
}

// The registration state of the resource provider.
func (o ProviderResponseOutput) RegistrationState() pulumi.StringOutput {
	return o.ApplyT(func(v ProviderResponse) string { return v.RegistrationState }).(pulumi.StringOutput)
}

// The collection of provider resource types.
func (o ProviderResponseOutput) ResourceTypes() ProviderResourceTypeResponseArrayOutput {
	return o.ApplyT(func(v ProviderResponse) []ProviderResourceTypeResponse { return v.ResourceTypes }).(ProviderResourceTypeResponseArrayOutput)
}

type ProviderResponseArrayOutput struct{ *pulumi.OutputState }

func (ProviderResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ProviderResponse)(nil)).Elem()
}

func (o ProviderResponseArrayOutput) ToProviderResponseArrayOutput() ProviderResponseArrayOutput {
	return o
}

func (o ProviderResponseArrayOutput) ToProviderResponseArrayOutputWithContext(ctx context.Context) ProviderResponseArrayOutput {
	return o
}

func (o ProviderResponseArrayOutput) Index(i pulumi.IntInput) ProviderResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ProviderResponse {
		return vs[0].([]ProviderResponse)[vs[1].(int)]
	}).(ProviderResponseOutput)
}

// The resource group properties.
type ResourceGroupPropertiesResponse struct {
	// The provisioning state.
	ProvisioningState string `pulumi:"provisioningState"`
}

// ResourceGroupPropertiesResponseInput is an input type that accepts ResourceGroupPropertiesResponseArgs and ResourceGroupPropertiesResponseOutput values.
// You can construct a concrete instance of `ResourceGroupPropertiesResponseInput` via:
//
//          ResourceGroupPropertiesResponseArgs{...}
type ResourceGroupPropertiesResponseInput interface {
	pulumi.Input

	ToResourceGroupPropertiesResponseOutput() ResourceGroupPropertiesResponseOutput
	ToResourceGroupPropertiesResponseOutputWithContext(context.Context) ResourceGroupPropertiesResponseOutput
}

// The resource group properties.
type ResourceGroupPropertiesResponseArgs struct {
	// The provisioning state.
	ProvisioningState pulumi.StringInput `pulumi:"provisioningState"`
}

func (ResourceGroupPropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceGroupPropertiesResponse)(nil)).Elem()
}

func (i ResourceGroupPropertiesResponseArgs) ToResourceGroupPropertiesResponseOutput() ResourceGroupPropertiesResponseOutput {
	return i.ToResourceGroupPropertiesResponseOutputWithContext(context.Background())
}

func (i ResourceGroupPropertiesResponseArgs) ToResourceGroupPropertiesResponseOutputWithContext(ctx context.Context) ResourceGroupPropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceGroupPropertiesResponseOutput)
}

func (i ResourceGroupPropertiesResponseArgs) ToResourceGroupPropertiesResponsePtrOutput() ResourceGroupPropertiesResponsePtrOutput {
	return i.ToResourceGroupPropertiesResponsePtrOutputWithContext(context.Background())
}

func (i ResourceGroupPropertiesResponseArgs) ToResourceGroupPropertiesResponsePtrOutputWithContext(ctx context.Context) ResourceGroupPropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceGroupPropertiesResponseOutput).ToResourceGroupPropertiesResponsePtrOutputWithContext(ctx)
}

// ResourceGroupPropertiesResponsePtrInput is an input type that accepts ResourceGroupPropertiesResponseArgs, ResourceGroupPropertiesResponsePtr and ResourceGroupPropertiesResponsePtrOutput values.
// You can construct a concrete instance of `ResourceGroupPropertiesResponsePtrInput` via:
//
//          ResourceGroupPropertiesResponseArgs{...}
//
//  or:
//
//          nil
type ResourceGroupPropertiesResponsePtrInput interface {
	pulumi.Input

	ToResourceGroupPropertiesResponsePtrOutput() ResourceGroupPropertiesResponsePtrOutput
	ToResourceGroupPropertiesResponsePtrOutputWithContext(context.Context) ResourceGroupPropertiesResponsePtrOutput
}

type resourceGroupPropertiesResponsePtrType ResourceGroupPropertiesResponseArgs

func ResourceGroupPropertiesResponsePtr(v *ResourceGroupPropertiesResponseArgs) ResourceGroupPropertiesResponsePtrInput {
	return (*resourceGroupPropertiesResponsePtrType)(v)
}

func (*resourceGroupPropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceGroupPropertiesResponse)(nil)).Elem()
}

func (i *resourceGroupPropertiesResponsePtrType) ToResourceGroupPropertiesResponsePtrOutput() ResourceGroupPropertiesResponsePtrOutput {
	return i.ToResourceGroupPropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *resourceGroupPropertiesResponsePtrType) ToResourceGroupPropertiesResponsePtrOutputWithContext(ctx context.Context) ResourceGroupPropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceGroupPropertiesResponsePtrOutput)
}

// The resource group properties.
type ResourceGroupPropertiesResponseOutput struct{ *pulumi.OutputState }

func (ResourceGroupPropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceGroupPropertiesResponse)(nil)).Elem()
}

func (o ResourceGroupPropertiesResponseOutput) ToResourceGroupPropertiesResponseOutput() ResourceGroupPropertiesResponseOutput {
	return o
}

func (o ResourceGroupPropertiesResponseOutput) ToResourceGroupPropertiesResponseOutputWithContext(ctx context.Context) ResourceGroupPropertiesResponseOutput {
	return o
}

func (o ResourceGroupPropertiesResponseOutput) ToResourceGroupPropertiesResponsePtrOutput() ResourceGroupPropertiesResponsePtrOutput {
	return o.ToResourceGroupPropertiesResponsePtrOutputWithContext(context.Background())
}

func (o ResourceGroupPropertiesResponseOutput) ToResourceGroupPropertiesResponsePtrOutputWithContext(ctx context.Context) ResourceGroupPropertiesResponsePtrOutput {
	return o.ApplyT(func(v ResourceGroupPropertiesResponse) *ResourceGroupPropertiesResponse {
		return &v
	}).(ResourceGroupPropertiesResponsePtrOutput)
}

// The provisioning state.
func (o ResourceGroupPropertiesResponseOutput) ProvisioningState() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceGroupPropertiesResponse) string { return v.ProvisioningState }).(pulumi.StringOutput)
}

type ResourceGroupPropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (ResourceGroupPropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceGroupPropertiesResponse)(nil)).Elem()
}

func (o ResourceGroupPropertiesResponsePtrOutput) ToResourceGroupPropertiesResponsePtrOutput() ResourceGroupPropertiesResponsePtrOutput {
	return o
}

func (o ResourceGroupPropertiesResponsePtrOutput) ToResourceGroupPropertiesResponsePtrOutputWithContext(ctx context.Context) ResourceGroupPropertiesResponsePtrOutput {
	return o
}

func (o ResourceGroupPropertiesResponsePtrOutput) Elem() ResourceGroupPropertiesResponseOutput {
	return o.ApplyT(func(v *ResourceGroupPropertiesResponse) ResourceGroupPropertiesResponse { return *v }).(ResourceGroupPropertiesResponseOutput)
}

// The provisioning state.
func (o ResourceGroupPropertiesResponsePtrOutput) ProvisioningState() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceGroupPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ProvisioningState
	}).(pulumi.StringPtrOutput)
}

// SKU for the resource.
type Sku struct {
	// The SKU capacity.
	Capacity *int `pulumi:"capacity"`
	// The SKU family.
	Family *string `pulumi:"family"`
	// The SKU model.
	Model *string `pulumi:"model"`
	// The SKU name.
	Name *string `pulumi:"name"`
	// The SKU size.
	Size *string `pulumi:"size"`
	// The SKU tier.
	Tier *string `pulumi:"tier"`
}

// SkuInput is an input type that accepts SkuArgs and SkuOutput values.
// You can construct a concrete instance of `SkuInput` via:
//
//          SkuArgs{...}
type SkuInput interface {
	pulumi.Input

	ToSkuOutput() SkuOutput
	ToSkuOutputWithContext(context.Context) SkuOutput
}

// SKU for the resource.
type SkuArgs struct {
	// The SKU capacity.
	Capacity pulumi.IntPtrInput `pulumi:"capacity"`
	// The SKU family.
	Family pulumi.StringPtrInput `pulumi:"family"`
	// The SKU model.
	Model pulumi.StringPtrInput `pulumi:"model"`
	// The SKU name.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The SKU size.
	Size pulumi.StringPtrInput `pulumi:"size"`
	// The SKU tier.
	Tier pulumi.StringPtrInput `pulumi:"tier"`
}

func (SkuArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Sku)(nil)).Elem()
}

func (i SkuArgs) ToSkuOutput() SkuOutput {
	return i.ToSkuOutputWithContext(context.Background())
}

func (i SkuArgs) ToSkuOutputWithContext(ctx context.Context) SkuOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SkuOutput)
}

func (i SkuArgs) ToSkuPtrOutput() SkuPtrOutput {
	return i.ToSkuPtrOutputWithContext(context.Background())
}

func (i SkuArgs) ToSkuPtrOutputWithContext(ctx context.Context) SkuPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SkuOutput).ToSkuPtrOutputWithContext(ctx)
}

// SkuPtrInput is an input type that accepts SkuArgs, SkuPtr and SkuPtrOutput values.
// You can construct a concrete instance of `SkuPtrInput` via:
//
//          SkuArgs{...}
//
//  or:
//
//          nil
type SkuPtrInput interface {
	pulumi.Input

	ToSkuPtrOutput() SkuPtrOutput
	ToSkuPtrOutputWithContext(context.Context) SkuPtrOutput
}

type skuPtrType SkuArgs

func SkuPtr(v *SkuArgs) SkuPtrInput {
	return (*skuPtrType)(v)
}

func (*skuPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Sku)(nil)).Elem()
}

func (i *skuPtrType) ToSkuPtrOutput() SkuPtrOutput {
	return i.ToSkuPtrOutputWithContext(context.Background())
}

func (i *skuPtrType) ToSkuPtrOutputWithContext(ctx context.Context) SkuPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SkuPtrOutput)
}

// SKU for the resource.
type SkuOutput struct{ *pulumi.OutputState }

func (SkuOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Sku)(nil)).Elem()
}

func (o SkuOutput) ToSkuOutput() SkuOutput {
	return o
}

func (o SkuOutput) ToSkuOutputWithContext(ctx context.Context) SkuOutput {
	return o
}

func (o SkuOutput) ToSkuPtrOutput() SkuPtrOutput {
	return o.ToSkuPtrOutputWithContext(context.Background())
}

func (o SkuOutput) ToSkuPtrOutputWithContext(ctx context.Context) SkuPtrOutput {
	return o.ApplyT(func(v Sku) *Sku {
		return &v
	}).(SkuPtrOutput)
}

// The SKU capacity.
func (o SkuOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v Sku) *int { return v.Capacity }).(pulumi.IntPtrOutput)
}

// The SKU family.
func (o SkuOutput) Family() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Sku) *string { return v.Family }).(pulumi.StringPtrOutput)
}

// The SKU model.
func (o SkuOutput) Model() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Sku) *string { return v.Model }).(pulumi.StringPtrOutput)
}

// The SKU name.
func (o SkuOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Sku) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The SKU size.
func (o SkuOutput) Size() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Sku) *string { return v.Size }).(pulumi.StringPtrOutput)
}

// The SKU tier.
func (o SkuOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Sku) *string { return v.Tier }).(pulumi.StringPtrOutput)
}

type SkuPtrOutput struct{ *pulumi.OutputState }

func (SkuPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Sku)(nil)).Elem()
}

func (o SkuPtrOutput) ToSkuPtrOutput() SkuPtrOutput {
	return o
}

func (o SkuPtrOutput) ToSkuPtrOutputWithContext(ctx context.Context) SkuPtrOutput {
	return o
}

func (o SkuPtrOutput) Elem() SkuOutput {
	return o.ApplyT(func(v *Sku) Sku { return *v }).(SkuOutput)
}

// The SKU capacity.
func (o SkuPtrOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *Sku) *int {
		if v == nil {
			return nil
		}
		return v.Capacity
	}).(pulumi.IntPtrOutput)
}

// The SKU family.
func (o SkuPtrOutput) Family() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Sku) *string {
		if v == nil {
			return nil
		}
		return v.Family
	}).(pulumi.StringPtrOutput)
}

// The SKU model.
func (o SkuPtrOutput) Model() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Sku) *string {
		if v == nil {
			return nil
		}
		return v.Model
	}).(pulumi.StringPtrOutput)
}

// The SKU name.
func (o SkuPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Sku) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// The SKU size.
func (o SkuPtrOutput) Size() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Sku) *string {
		if v == nil {
			return nil
		}
		return v.Size
	}).(pulumi.StringPtrOutput)
}

// The SKU tier.
func (o SkuPtrOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Sku) *string {
		if v == nil {
			return nil
		}
		return v.Tier
	}).(pulumi.StringPtrOutput)
}

// SKU for the resource.
type SkuResponse struct {
	// The SKU capacity.
	Capacity *int `pulumi:"capacity"`
	// The SKU family.
	Family *string `pulumi:"family"`
	// The SKU model.
	Model *string `pulumi:"model"`
	// The SKU name.
	Name *string `pulumi:"name"`
	// The SKU size.
	Size *string `pulumi:"size"`
	// The SKU tier.
	Tier *string `pulumi:"tier"`
}

// SkuResponseInput is an input type that accepts SkuResponseArgs and SkuResponseOutput values.
// You can construct a concrete instance of `SkuResponseInput` via:
//
//          SkuResponseArgs{...}
type SkuResponseInput interface {
	pulumi.Input

	ToSkuResponseOutput() SkuResponseOutput
	ToSkuResponseOutputWithContext(context.Context) SkuResponseOutput
}

// SKU for the resource.
type SkuResponseArgs struct {
	// The SKU capacity.
	Capacity pulumi.IntPtrInput `pulumi:"capacity"`
	// The SKU family.
	Family pulumi.StringPtrInput `pulumi:"family"`
	// The SKU model.
	Model pulumi.StringPtrInput `pulumi:"model"`
	// The SKU name.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The SKU size.
	Size pulumi.StringPtrInput `pulumi:"size"`
	// The SKU tier.
	Tier pulumi.StringPtrInput `pulumi:"tier"`
}

func (SkuResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SkuResponse)(nil)).Elem()
}

func (i SkuResponseArgs) ToSkuResponseOutput() SkuResponseOutput {
	return i.ToSkuResponseOutputWithContext(context.Background())
}

func (i SkuResponseArgs) ToSkuResponseOutputWithContext(ctx context.Context) SkuResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SkuResponseOutput)
}

func (i SkuResponseArgs) ToSkuResponsePtrOutput() SkuResponsePtrOutput {
	return i.ToSkuResponsePtrOutputWithContext(context.Background())
}

func (i SkuResponseArgs) ToSkuResponsePtrOutputWithContext(ctx context.Context) SkuResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SkuResponseOutput).ToSkuResponsePtrOutputWithContext(ctx)
}

// SkuResponsePtrInput is an input type that accepts SkuResponseArgs, SkuResponsePtr and SkuResponsePtrOutput values.
// You can construct a concrete instance of `SkuResponsePtrInput` via:
//
//          SkuResponseArgs{...}
//
//  or:
//
//          nil
type SkuResponsePtrInput interface {
	pulumi.Input

	ToSkuResponsePtrOutput() SkuResponsePtrOutput
	ToSkuResponsePtrOutputWithContext(context.Context) SkuResponsePtrOutput
}

type skuResponsePtrType SkuResponseArgs

func SkuResponsePtr(v *SkuResponseArgs) SkuResponsePtrInput {
	return (*skuResponsePtrType)(v)
}

func (*skuResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**SkuResponse)(nil)).Elem()
}

func (i *skuResponsePtrType) ToSkuResponsePtrOutput() SkuResponsePtrOutput {
	return i.ToSkuResponsePtrOutputWithContext(context.Background())
}

func (i *skuResponsePtrType) ToSkuResponsePtrOutputWithContext(ctx context.Context) SkuResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SkuResponsePtrOutput)
}

// SKU for the resource.
type SkuResponseOutput struct{ *pulumi.OutputState }

func (SkuResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SkuResponse)(nil)).Elem()
}

func (o SkuResponseOutput) ToSkuResponseOutput() SkuResponseOutput {
	return o
}

func (o SkuResponseOutput) ToSkuResponseOutputWithContext(ctx context.Context) SkuResponseOutput {
	return o
}

func (o SkuResponseOutput) ToSkuResponsePtrOutput() SkuResponsePtrOutput {
	return o.ToSkuResponsePtrOutputWithContext(context.Background())
}

func (o SkuResponseOutput) ToSkuResponsePtrOutputWithContext(ctx context.Context) SkuResponsePtrOutput {
	return o.ApplyT(func(v SkuResponse) *SkuResponse {
		return &v
	}).(SkuResponsePtrOutput)
}

// The SKU capacity.
func (o SkuResponseOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v SkuResponse) *int { return v.Capacity }).(pulumi.IntPtrOutput)
}

// The SKU family.
func (o SkuResponseOutput) Family() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SkuResponse) *string { return v.Family }).(pulumi.StringPtrOutput)
}

// The SKU model.
func (o SkuResponseOutput) Model() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SkuResponse) *string { return v.Model }).(pulumi.StringPtrOutput)
}

// The SKU name.
func (o SkuResponseOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SkuResponse) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The SKU size.
func (o SkuResponseOutput) Size() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SkuResponse) *string { return v.Size }).(pulumi.StringPtrOutput)
}

// The SKU tier.
func (o SkuResponseOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SkuResponse) *string { return v.Tier }).(pulumi.StringPtrOutput)
}

type SkuResponsePtrOutput struct{ *pulumi.OutputState }

func (SkuResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SkuResponse)(nil)).Elem()
}

func (o SkuResponsePtrOutput) ToSkuResponsePtrOutput() SkuResponsePtrOutput {
	return o
}

func (o SkuResponsePtrOutput) ToSkuResponsePtrOutputWithContext(ctx context.Context) SkuResponsePtrOutput {
	return o
}

func (o SkuResponsePtrOutput) Elem() SkuResponseOutput {
	return o.ApplyT(func(v *SkuResponse) SkuResponse { return *v }).(SkuResponseOutput)
}

// The SKU capacity.
func (o SkuResponsePtrOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *int {
		if v == nil {
			return nil
		}
		return v.Capacity
	}).(pulumi.IntPtrOutput)
}

// The SKU family.
func (o SkuResponsePtrOutput) Family() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Family
	}).(pulumi.StringPtrOutput)
}

// The SKU model.
func (o SkuResponsePtrOutput) Model() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Model
	}).(pulumi.StringPtrOutput)
}

// The SKU name.
func (o SkuResponsePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// The SKU size.
func (o SkuResponsePtrOutput) Size() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Size
	}).(pulumi.StringPtrOutput)
}

// The SKU tier.
func (o SkuResponsePtrOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Tier
	}).(pulumi.StringPtrOutput)
}

// Entity representing the reference to the template.
type TemplateLink struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion *string `pulumi:"contentVersion"`
	// The URI of the template to deploy.
	Uri string `pulumi:"uri"`
}

// TemplateLinkInput is an input type that accepts TemplateLinkArgs and TemplateLinkOutput values.
// You can construct a concrete instance of `TemplateLinkInput` via:
//
//          TemplateLinkArgs{...}
type TemplateLinkInput interface {
	pulumi.Input

	ToTemplateLinkOutput() TemplateLinkOutput
	ToTemplateLinkOutputWithContext(context.Context) TemplateLinkOutput
}

// Entity representing the reference to the template.
type TemplateLinkArgs struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion pulumi.StringPtrInput `pulumi:"contentVersion"`
	// The URI of the template to deploy.
	Uri pulumi.StringInput `pulumi:"uri"`
}

func (TemplateLinkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*TemplateLink)(nil)).Elem()
}

func (i TemplateLinkArgs) ToTemplateLinkOutput() TemplateLinkOutput {
	return i.ToTemplateLinkOutputWithContext(context.Background())
}

func (i TemplateLinkArgs) ToTemplateLinkOutputWithContext(ctx context.Context) TemplateLinkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemplateLinkOutput)
}

func (i TemplateLinkArgs) ToTemplateLinkPtrOutput() TemplateLinkPtrOutput {
	return i.ToTemplateLinkPtrOutputWithContext(context.Background())
}

func (i TemplateLinkArgs) ToTemplateLinkPtrOutputWithContext(ctx context.Context) TemplateLinkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemplateLinkOutput).ToTemplateLinkPtrOutputWithContext(ctx)
}

// TemplateLinkPtrInput is an input type that accepts TemplateLinkArgs, TemplateLinkPtr and TemplateLinkPtrOutput values.
// You can construct a concrete instance of `TemplateLinkPtrInput` via:
//
//          TemplateLinkArgs{...}
//
//  or:
//
//          nil
type TemplateLinkPtrInput interface {
	pulumi.Input

	ToTemplateLinkPtrOutput() TemplateLinkPtrOutput
	ToTemplateLinkPtrOutputWithContext(context.Context) TemplateLinkPtrOutput
}

type templateLinkPtrType TemplateLinkArgs

func TemplateLinkPtr(v *TemplateLinkArgs) TemplateLinkPtrInput {
	return (*templateLinkPtrType)(v)
}

func (*templateLinkPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**TemplateLink)(nil)).Elem()
}

func (i *templateLinkPtrType) ToTemplateLinkPtrOutput() TemplateLinkPtrOutput {
	return i.ToTemplateLinkPtrOutputWithContext(context.Background())
}

func (i *templateLinkPtrType) ToTemplateLinkPtrOutputWithContext(ctx context.Context) TemplateLinkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemplateLinkPtrOutput)
}

// Entity representing the reference to the template.
type TemplateLinkOutput struct{ *pulumi.OutputState }

func (TemplateLinkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*TemplateLink)(nil)).Elem()
}

func (o TemplateLinkOutput) ToTemplateLinkOutput() TemplateLinkOutput {
	return o
}

func (o TemplateLinkOutput) ToTemplateLinkOutputWithContext(ctx context.Context) TemplateLinkOutput {
	return o
}

func (o TemplateLinkOutput) ToTemplateLinkPtrOutput() TemplateLinkPtrOutput {
	return o.ToTemplateLinkPtrOutputWithContext(context.Background())
}

func (o TemplateLinkOutput) ToTemplateLinkPtrOutputWithContext(ctx context.Context) TemplateLinkPtrOutput {
	return o.ApplyT(func(v TemplateLink) *TemplateLink {
		return &v
	}).(TemplateLinkPtrOutput)
}

// If included, must match the ContentVersion in the template.
func (o TemplateLinkOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v TemplateLink) *string { return v.ContentVersion }).(pulumi.StringPtrOutput)
}

// The URI of the template to deploy.
func (o TemplateLinkOutput) Uri() pulumi.StringOutput {
	return o.ApplyT(func(v TemplateLink) string { return v.Uri }).(pulumi.StringOutput)
}

type TemplateLinkPtrOutput struct{ *pulumi.OutputState }

func (TemplateLinkPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**TemplateLink)(nil)).Elem()
}

func (o TemplateLinkPtrOutput) ToTemplateLinkPtrOutput() TemplateLinkPtrOutput {
	return o
}

func (o TemplateLinkPtrOutput) ToTemplateLinkPtrOutputWithContext(ctx context.Context) TemplateLinkPtrOutput {
	return o
}

func (o TemplateLinkPtrOutput) Elem() TemplateLinkOutput {
	return o.ApplyT(func(v *TemplateLink) TemplateLink { return *v }).(TemplateLinkOutput)
}

// If included, must match the ContentVersion in the template.
func (o TemplateLinkPtrOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *TemplateLink) *string {
		if v == nil {
			return nil
		}
		return v.ContentVersion
	}).(pulumi.StringPtrOutput)
}

// The URI of the template to deploy.
func (o TemplateLinkPtrOutput) Uri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *TemplateLink) *string {
		if v == nil {
			return nil
		}
		return &v.Uri
	}).(pulumi.StringPtrOutput)
}

// Entity representing the reference to the template.
type TemplateLinkResponse struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion *string `pulumi:"contentVersion"`
	// The URI of the template to deploy.
	Uri string `pulumi:"uri"`
}

// TemplateLinkResponseInput is an input type that accepts TemplateLinkResponseArgs and TemplateLinkResponseOutput values.
// You can construct a concrete instance of `TemplateLinkResponseInput` via:
//
//          TemplateLinkResponseArgs{...}
type TemplateLinkResponseInput interface {
	pulumi.Input

	ToTemplateLinkResponseOutput() TemplateLinkResponseOutput
	ToTemplateLinkResponseOutputWithContext(context.Context) TemplateLinkResponseOutput
}

// Entity representing the reference to the template.
type TemplateLinkResponseArgs struct {
	// If included, must match the ContentVersion in the template.
	ContentVersion pulumi.StringPtrInput `pulumi:"contentVersion"`
	// The URI of the template to deploy.
	Uri pulumi.StringInput `pulumi:"uri"`
}

func (TemplateLinkResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*TemplateLinkResponse)(nil)).Elem()
}

func (i TemplateLinkResponseArgs) ToTemplateLinkResponseOutput() TemplateLinkResponseOutput {
	return i.ToTemplateLinkResponseOutputWithContext(context.Background())
}

func (i TemplateLinkResponseArgs) ToTemplateLinkResponseOutputWithContext(ctx context.Context) TemplateLinkResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemplateLinkResponseOutput)
}

func (i TemplateLinkResponseArgs) ToTemplateLinkResponsePtrOutput() TemplateLinkResponsePtrOutput {
	return i.ToTemplateLinkResponsePtrOutputWithContext(context.Background())
}

func (i TemplateLinkResponseArgs) ToTemplateLinkResponsePtrOutputWithContext(ctx context.Context) TemplateLinkResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemplateLinkResponseOutput).ToTemplateLinkResponsePtrOutputWithContext(ctx)
}

// TemplateLinkResponsePtrInput is an input type that accepts TemplateLinkResponseArgs, TemplateLinkResponsePtr and TemplateLinkResponsePtrOutput values.
// You can construct a concrete instance of `TemplateLinkResponsePtrInput` via:
//
//          TemplateLinkResponseArgs{...}
//
//  or:
//
//          nil
type TemplateLinkResponsePtrInput interface {
	pulumi.Input

	ToTemplateLinkResponsePtrOutput() TemplateLinkResponsePtrOutput
	ToTemplateLinkResponsePtrOutputWithContext(context.Context) TemplateLinkResponsePtrOutput
}

type templateLinkResponsePtrType TemplateLinkResponseArgs

func TemplateLinkResponsePtr(v *TemplateLinkResponseArgs) TemplateLinkResponsePtrInput {
	return (*templateLinkResponsePtrType)(v)
}

func (*templateLinkResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**TemplateLinkResponse)(nil)).Elem()
}

func (i *templateLinkResponsePtrType) ToTemplateLinkResponsePtrOutput() TemplateLinkResponsePtrOutput {
	return i.ToTemplateLinkResponsePtrOutputWithContext(context.Background())
}

func (i *templateLinkResponsePtrType) ToTemplateLinkResponsePtrOutputWithContext(ctx context.Context) TemplateLinkResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemplateLinkResponsePtrOutput)
}

// Entity representing the reference to the template.
type TemplateLinkResponseOutput struct{ *pulumi.OutputState }

func (TemplateLinkResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*TemplateLinkResponse)(nil)).Elem()
}

func (o TemplateLinkResponseOutput) ToTemplateLinkResponseOutput() TemplateLinkResponseOutput {
	return o
}

func (o TemplateLinkResponseOutput) ToTemplateLinkResponseOutputWithContext(ctx context.Context) TemplateLinkResponseOutput {
	return o
}

func (o TemplateLinkResponseOutput) ToTemplateLinkResponsePtrOutput() TemplateLinkResponsePtrOutput {
	return o.ToTemplateLinkResponsePtrOutputWithContext(context.Background())
}

func (o TemplateLinkResponseOutput) ToTemplateLinkResponsePtrOutputWithContext(ctx context.Context) TemplateLinkResponsePtrOutput {
	return o.ApplyT(func(v TemplateLinkResponse) *TemplateLinkResponse {
		return &v
	}).(TemplateLinkResponsePtrOutput)
}

// If included, must match the ContentVersion in the template.
func (o TemplateLinkResponseOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v TemplateLinkResponse) *string { return v.ContentVersion }).(pulumi.StringPtrOutput)
}

// The URI of the template to deploy.
func (o TemplateLinkResponseOutput) Uri() pulumi.StringOutput {
	return o.ApplyT(func(v TemplateLinkResponse) string { return v.Uri }).(pulumi.StringOutput)
}

type TemplateLinkResponsePtrOutput struct{ *pulumi.OutputState }

func (TemplateLinkResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**TemplateLinkResponse)(nil)).Elem()
}

func (o TemplateLinkResponsePtrOutput) ToTemplateLinkResponsePtrOutput() TemplateLinkResponsePtrOutput {
	return o
}

func (o TemplateLinkResponsePtrOutput) ToTemplateLinkResponsePtrOutputWithContext(ctx context.Context) TemplateLinkResponsePtrOutput {
	return o
}

func (o TemplateLinkResponsePtrOutput) Elem() TemplateLinkResponseOutput {
	return o.ApplyT(func(v *TemplateLinkResponse) TemplateLinkResponse { return *v }).(TemplateLinkResponseOutput)
}

// If included, must match the ContentVersion in the template.
func (o TemplateLinkResponsePtrOutput) ContentVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *TemplateLinkResponse) *string {
		if v == nil {
			return nil
		}
		return v.ContentVersion
	}).(pulumi.StringPtrOutput)
}

// The URI of the template to deploy.
func (o TemplateLinkResponsePtrOutput) Uri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *TemplateLinkResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Uri
	}).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterOutputType(AliasPathTypeResponseOutput{})
	pulumi.RegisterOutputType(AliasPathTypeResponseArrayOutput{})
	pulumi.RegisterOutputType(AliasTypeResponseOutput{})
	pulumi.RegisterOutputType(AliasTypeResponseArrayOutput{})
	pulumi.RegisterOutputType(BasicDependencyResponseOutput{})
	pulumi.RegisterOutputType(BasicDependencyResponseArrayOutput{})
	pulumi.RegisterOutputType(DebugSettingOutput{})
	pulumi.RegisterOutputType(DebugSettingPtrOutput{})
	pulumi.RegisterOutputType(DebugSettingResponseOutput{})
	pulumi.RegisterOutputType(DebugSettingResponsePtrOutput{})
	pulumi.RegisterOutputType(DependencyResponseOutput{})
	pulumi.RegisterOutputType(DependencyResponseArrayOutput{})
	pulumi.RegisterOutputType(DeploymentPropertiesOutput{})
	pulumi.RegisterOutputType(DeploymentPropertiesPtrOutput{})
	pulumi.RegisterOutputType(DeploymentPropertiesExtendedResponseOutput{})
	pulumi.RegisterOutputType(DeploymentPropertiesExtendedResponsePtrOutput{})
	pulumi.RegisterOutputType(IdentityOutput{})
	pulumi.RegisterOutputType(IdentityPtrOutput{})
	pulumi.RegisterOutputType(IdentityResponseOutput{})
	pulumi.RegisterOutputType(IdentityResponsePtrOutput{})
	pulumi.RegisterOutputType(IdentityResponseUserAssignedIdentitiesOutput{})
	pulumi.RegisterOutputType(IdentityResponseUserAssignedIdentitiesMapOutput{})
	pulumi.RegisterOutputType(OnErrorDeploymentOutput{})
	pulumi.RegisterOutputType(OnErrorDeploymentPtrOutput{})
	pulumi.RegisterOutputType(OnErrorDeploymentExtendedResponseOutput{})
	pulumi.RegisterOutputType(OnErrorDeploymentExtendedResponsePtrOutput{})
	pulumi.RegisterOutputType(ParametersLinkOutput{})
	pulumi.RegisterOutputType(ParametersLinkPtrOutput{})
	pulumi.RegisterOutputType(ParametersLinkResponseOutput{})
	pulumi.RegisterOutputType(ParametersLinkResponsePtrOutput{})
	pulumi.RegisterOutputType(PlanOutput{})
	pulumi.RegisterOutputType(PlanPtrOutput{})
	pulumi.RegisterOutputType(PlanResponseOutput{})
	pulumi.RegisterOutputType(PlanResponsePtrOutput{})
	pulumi.RegisterOutputType(ProviderResourceTypeResponseOutput{})
	pulumi.RegisterOutputType(ProviderResourceTypeResponseArrayOutput{})
	pulumi.RegisterOutputType(ProviderResponseOutput{})
	pulumi.RegisterOutputType(ProviderResponseArrayOutput{})
	pulumi.RegisterOutputType(ResourceGroupPropertiesResponseOutput{})
	pulumi.RegisterOutputType(ResourceGroupPropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(SkuOutput{})
	pulumi.RegisterOutputType(SkuPtrOutput{})
	pulumi.RegisterOutputType(SkuResponseOutput{})
	pulumi.RegisterOutputType(SkuResponsePtrOutput{})
	pulumi.RegisterOutputType(TemplateLinkOutput{})
	pulumi.RegisterOutputType(TemplateLinkPtrOutput{})
	pulumi.RegisterOutputType(TemplateLinkResponseOutput{})
	pulumi.RegisterOutputType(TemplateLinkResponsePtrOutput{})
}