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 v20200701

import (
	"context"
	"reflect"

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

// App resource properties payload
type AppResourceProperties struct {
	// Name of the active deployment of the App
	ActiveDeploymentName *string `pulumi:"activeDeploymentName"`
	// Fully qualified dns Name.
	Fqdn *string `pulumi:"fqdn"`
	// Indicate if only https is allowed.
	HttpsOnly *bool `pulumi:"httpsOnly"`
	// Persistent disk settings
	PersistentDisk *PersistentDisk `pulumi:"persistentDisk"`
	// Indicates whether the App exposes public endpoint
	Public *bool `pulumi:"public"`
	// Temporary disk settings
	TemporaryDisk *TemporaryDisk `pulumi:"temporaryDisk"`
}

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

	ToAppResourcePropertiesOutput() AppResourcePropertiesOutput
	ToAppResourcePropertiesOutputWithContext(context.Context) AppResourcePropertiesOutput
}

// App resource properties payload
type AppResourcePropertiesArgs struct {
	// Name of the active deployment of the App
	ActiveDeploymentName pulumi.StringPtrInput `pulumi:"activeDeploymentName"`
	// Fully qualified dns Name.
	Fqdn pulumi.StringPtrInput `pulumi:"fqdn"`
	// Indicate if only https is allowed.
	HttpsOnly pulumi.BoolPtrInput `pulumi:"httpsOnly"`
	// Persistent disk settings
	PersistentDisk PersistentDiskPtrInput `pulumi:"persistentDisk"`
	// Indicates whether the App exposes public endpoint
	Public pulumi.BoolPtrInput `pulumi:"public"`
	// Temporary disk settings
	TemporaryDisk TemporaryDiskPtrInput `pulumi:"temporaryDisk"`
}

func (AppResourcePropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AppResourceProperties)(nil)).Elem()
}

func (i AppResourcePropertiesArgs) ToAppResourcePropertiesOutput() AppResourcePropertiesOutput {
	return i.ToAppResourcePropertiesOutputWithContext(context.Background())
}

func (i AppResourcePropertiesArgs) ToAppResourcePropertiesOutputWithContext(ctx context.Context) AppResourcePropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AppResourcePropertiesOutput)
}

func (i AppResourcePropertiesArgs) ToAppResourcePropertiesPtrOutput() AppResourcePropertiesPtrOutput {
	return i.ToAppResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i AppResourcePropertiesArgs) ToAppResourcePropertiesPtrOutputWithContext(ctx context.Context) AppResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AppResourcePropertiesOutput).ToAppResourcePropertiesPtrOutputWithContext(ctx)
}

// AppResourcePropertiesPtrInput is an input type that accepts AppResourcePropertiesArgs, AppResourcePropertiesPtr and AppResourcePropertiesPtrOutput values.
// You can construct a concrete instance of `AppResourcePropertiesPtrInput` via:
//
//          AppResourcePropertiesArgs{...}
//
//  or:
//
//          nil
type AppResourcePropertiesPtrInput interface {
	pulumi.Input

	ToAppResourcePropertiesPtrOutput() AppResourcePropertiesPtrOutput
	ToAppResourcePropertiesPtrOutputWithContext(context.Context) AppResourcePropertiesPtrOutput
}

type appResourcePropertiesPtrType AppResourcePropertiesArgs

func AppResourcePropertiesPtr(v *AppResourcePropertiesArgs) AppResourcePropertiesPtrInput {
	return (*appResourcePropertiesPtrType)(v)
}

func (*appResourcePropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AppResourceProperties)(nil)).Elem()
}

func (i *appResourcePropertiesPtrType) ToAppResourcePropertiesPtrOutput() AppResourcePropertiesPtrOutput {
	return i.ToAppResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i *appResourcePropertiesPtrType) ToAppResourcePropertiesPtrOutputWithContext(ctx context.Context) AppResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AppResourcePropertiesPtrOutput)
}

// App resource properties payload
type AppResourcePropertiesOutput struct{ *pulumi.OutputState }

func (AppResourcePropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AppResourceProperties)(nil)).Elem()
}

func (o AppResourcePropertiesOutput) ToAppResourcePropertiesOutput() AppResourcePropertiesOutput {
	return o
}

func (o AppResourcePropertiesOutput) ToAppResourcePropertiesOutputWithContext(ctx context.Context) AppResourcePropertiesOutput {
	return o
}

func (o AppResourcePropertiesOutput) ToAppResourcePropertiesPtrOutput() AppResourcePropertiesPtrOutput {
	return o.ToAppResourcePropertiesPtrOutputWithContext(context.Background())
}

func (o AppResourcePropertiesOutput) ToAppResourcePropertiesPtrOutputWithContext(ctx context.Context) AppResourcePropertiesPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *AppResourceProperties {
		return &v
	}).(AppResourcePropertiesPtrOutput)
}

// Name of the active deployment of the App
func (o AppResourcePropertiesOutput) ActiveDeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *string { return v.ActiveDeploymentName }).(pulumi.StringPtrOutput)
}

// Fully qualified dns Name.
func (o AppResourcePropertiesOutput) Fqdn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *string { return v.Fqdn }).(pulumi.StringPtrOutput)
}

// Indicate if only https is allowed.
func (o AppResourcePropertiesOutput) HttpsOnly() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *bool { return v.HttpsOnly }).(pulumi.BoolPtrOutput)
}

// Persistent disk settings
func (o AppResourcePropertiesOutput) PersistentDisk() PersistentDiskPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *PersistentDisk { return v.PersistentDisk }).(PersistentDiskPtrOutput)
}

// Indicates whether the App exposes public endpoint
func (o AppResourcePropertiesOutput) Public() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *bool { return v.Public }).(pulumi.BoolPtrOutput)
}

// Temporary disk settings
func (o AppResourcePropertiesOutput) TemporaryDisk() TemporaryDiskPtrOutput {
	return o.ApplyT(func(v AppResourceProperties) *TemporaryDisk { return v.TemporaryDisk }).(TemporaryDiskPtrOutput)
}

type AppResourcePropertiesPtrOutput struct{ *pulumi.OutputState }

func (AppResourcePropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AppResourceProperties)(nil)).Elem()
}

func (o AppResourcePropertiesPtrOutput) ToAppResourcePropertiesPtrOutput() AppResourcePropertiesPtrOutput {
	return o
}

func (o AppResourcePropertiesPtrOutput) ToAppResourcePropertiesPtrOutputWithContext(ctx context.Context) AppResourcePropertiesPtrOutput {
	return o
}

func (o AppResourcePropertiesPtrOutput) Elem() AppResourcePropertiesOutput {
	return o.ApplyT(func(v *AppResourceProperties) AppResourceProperties { return *v }).(AppResourcePropertiesOutput)
}

// Name of the active deployment of the App
func (o AppResourcePropertiesPtrOutput) ActiveDeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourceProperties) *string {
		if v == nil {
			return nil
		}
		return v.ActiveDeploymentName
	}).(pulumi.StringPtrOutput)
}

// Fully qualified dns Name.
func (o AppResourcePropertiesPtrOutput) Fqdn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourceProperties) *string {
		if v == nil {
			return nil
		}
		return v.Fqdn
	}).(pulumi.StringPtrOutput)
}

// Indicate if only https is allowed.
func (o AppResourcePropertiesPtrOutput) HttpsOnly() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AppResourceProperties) *bool {
		if v == nil {
			return nil
		}
		return v.HttpsOnly
	}).(pulumi.BoolPtrOutput)
}

// Persistent disk settings
func (o AppResourcePropertiesPtrOutput) PersistentDisk() PersistentDiskPtrOutput {
	return o.ApplyT(func(v *AppResourceProperties) *PersistentDisk {
		if v == nil {
			return nil
		}
		return v.PersistentDisk
	}).(PersistentDiskPtrOutput)
}

// Indicates whether the App exposes public endpoint
func (o AppResourcePropertiesPtrOutput) Public() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AppResourceProperties) *bool {
		if v == nil {
			return nil
		}
		return v.Public
	}).(pulumi.BoolPtrOutput)
}

// Temporary disk settings
func (o AppResourcePropertiesPtrOutput) TemporaryDisk() TemporaryDiskPtrOutput {
	return o.ApplyT(func(v *AppResourceProperties) *TemporaryDisk {
		if v == nil {
			return nil
		}
		return v.TemporaryDisk
	}).(TemporaryDiskPtrOutput)
}

// App resource properties payload
type AppResourcePropertiesResponse struct {
	// Name of the active deployment of the App
	ActiveDeploymentName *string `pulumi:"activeDeploymentName"`
	// Date time when the resource is created
	CreatedTime string `pulumi:"createdTime"`
	// Fully qualified dns Name.
	Fqdn *string `pulumi:"fqdn"`
	// Indicate if only https is allowed.
	HttpsOnly *bool `pulumi:"httpsOnly"`
	// Persistent disk settings
	PersistentDisk *PersistentDiskResponse `pulumi:"persistentDisk"`
	// Provisioning state of the App
	ProvisioningState string `pulumi:"provisioningState"`
	// Indicates whether the App exposes public endpoint
	Public *bool `pulumi:"public"`
	// Temporary disk settings
	TemporaryDisk *TemporaryDiskResponse `pulumi:"temporaryDisk"`
	// URL of the App
	Url string `pulumi:"url"`
}

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

	ToAppResourcePropertiesResponseOutput() AppResourcePropertiesResponseOutput
	ToAppResourcePropertiesResponseOutputWithContext(context.Context) AppResourcePropertiesResponseOutput
}

// App resource properties payload
type AppResourcePropertiesResponseArgs struct {
	// Name of the active deployment of the App
	ActiveDeploymentName pulumi.StringPtrInput `pulumi:"activeDeploymentName"`
	// Date time when the resource is created
	CreatedTime pulumi.StringInput `pulumi:"createdTime"`
	// Fully qualified dns Name.
	Fqdn pulumi.StringPtrInput `pulumi:"fqdn"`
	// Indicate if only https is allowed.
	HttpsOnly pulumi.BoolPtrInput `pulumi:"httpsOnly"`
	// Persistent disk settings
	PersistentDisk PersistentDiskResponsePtrInput `pulumi:"persistentDisk"`
	// Provisioning state of the App
	ProvisioningState pulumi.StringInput `pulumi:"provisioningState"`
	// Indicates whether the App exposes public endpoint
	Public pulumi.BoolPtrInput `pulumi:"public"`
	// Temporary disk settings
	TemporaryDisk TemporaryDiskResponsePtrInput `pulumi:"temporaryDisk"`
	// URL of the App
	Url pulumi.StringInput `pulumi:"url"`
}

func (AppResourcePropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AppResourcePropertiesResponse)(nil)).Elem()
}

func (i AppResourcePropertiesResponseArgs) ToAppResourcePropertiesResponseOutput() AppResourcePropertiesResponseOutput {
	return i.ToAppResourcePropertiesResponseOutputWithContext(context.Background())
}

func (i AppResourcePropertiesResponseArgs) ToAppResourcePropertiesResponseOutputWithContext(ctx context.Context) AppResourcePropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AppResourcePropertiesResponseOutput)
}

func (i AppResourcePropertiesResponseArgs) ToAppResourcePropertiesResponsePtrOutput() AppResourcePropertiesResponsePtrOutput {
	return i.ToAppResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i AppResourcePropertiesResponseArgs) ToAppResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) AppResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AppResourcePropertiesResponseOutput).ToAppResourcePropertiesResponsePtrOutputWithContext(ctx)
}

// AppResourcePropertiesResponsePtrInput is an input type that accepts AppResourcePropertiesResponseArgs, AppResourcePropertiesResponsePtr and AppResourcePropertiesResponsePtrOutput values.
// You can construct a concrete instance of `AppResourcePropertiesResponsePtrInput` via:
//
//          AppResourcePropertiesResponseArgs{...}
//
//  or:
//
//          nil
type AppResourcePropertiesResponsePtrInput interface {
	pulumi.Input

	ToAppResourcePropertiesResponsePtrOutput() AppResourcePropertiesResponsePtrOutput
	ToAppResourcePropertiesResponsePtrOutputWithContext(context.Context) AppResourcePropertiesResponsePtrOutput
}

type appResourcePropertiesResponsePtrType AppResourcePropertiesResponseArgs

func AppResourcePropertiesResponsePtr(v *AppResourcePropertiesResponseArgs) AppResourcePropertiesResponsePtrInput {
	return (*appResourcePropertiesResponsePtrType)(v)
}

func (*appResourcePropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AppResourcePropertiesResponse)(nil)).Elem()
}

func (i *appResourcePropertiesResponsePtrType) ToAppResourcePropertiesResponsePtrOutput() AppResourcePropertiesResponsePtrOutput {
	return i.ToAppResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *appResourcePropertiesResponsePtrType) ToAppResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) AppResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AppResourcePropertiesResponsePtrOutput)
}

// App resource properties payload
type AppResourcePropertiesResponseOutput struct{ *pulumi.OutputState }

func (AppResourcePropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AppResourcePropertiesResponse)(nil)).Elem()
}

func (o AppResourcePropertiesResponseOutput) ToAppResourcePropertiesResponseOutput() AppResourcePropertiesResponseOutput {
	return o
}

func (o AppResourcePropertiesResponseOutput) ToAppResourcePropertiesResponseOutputWithContext(ctx context.Context) AppResourcePropertiesResponseOutput {
	return o
}

func (o AppResourcePropertiesResponseOutput) ToAppResourcePropertiesResponsePtrOutput() AppResourcePropertiesResponsePtrOutput {
	return o.ToAppResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (o AppResourcePropertiesResponseOutput) ToAppResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) AppResourcePropertiesResponsePtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *AppResourcePropertiesResponse {
		return &v
	}).(AppResourcePropertiesResponsePtrOutput)
}

// Name of the active deployment of the App
func (o AppResourcePropertiesResponseOutput) ActiveDeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *string { return v.ActiveDeploymentName }).(pulumi.StringPtrOutput)
}

// Date time when the resource is created
func (o AppResourcePropertiesResponseOutput) CreatedTime() pulumi.StringOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) string { return v.CreatedTime }).(pulumi.StringOutput)
}

// Fully qualified dns Name.
func (o AppResourcePropertiesResponseOutput) Fqdn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *string { return v.Fqdn }).(pulumi.StringPtrOutput)
}

// Indicate if only https is allowed.
func (o AppResourcePropertiesResponseOutput) HttpsOnly() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *bool { return v.HttpsOnly }).(pulumi.BoolPtrOutput)
}

// Persistent disk settings
func (o AppResourcePropertiesResponseOutput) PersistentDisk() PersistentDiskResponsePtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *PersistentDiskResponse { return v.PersistentDisk }).(PersistentDiskResponsePtrOutput)
}

// Provisioning state of the App
func (o AppResourcePropertiesResponseOutput) ProvisioningState() pulumi.StringOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) string { return v.ProvisioningState }).(pulumi.StringOutput)
}

// Indicates whether the App exposes public endpoint
func (o AppResourcePropertiesResponseOutput) Public() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *bool { return v.Public }).(pulumi.BoolPtrOutput)
}

// Temporary disk settings
func (o AppResourcePropertiesResponseOutput) TemporaryDisk() TemporaryDiskResponsePtrOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) *TemporaryDiskResponse { return v.TemporaryDisk }).(TemporaryDiskResponsePtrOutput)
}

// URL of the App
func (o AppResourcePropertiesResponseOutput) Url() pulumi.StringOutput {
	return o.ApplyT(func(v AppResourcePropertiesResponse) string { return v.Url }).(pulumi.StringOutput)
}

type AppResourcePropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (AppResourcePropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AppResourcePropertiesResponse)(nil)).Elem()
}

func (o AppResourcePropertiesResponsePtrOutput) ToAppResourcePropertiesResponsePtrOutput() AppResourcePropertiesResponsePtrOutput {
	return o
}

func (o AppResourcePropertiesResponsePtrOutput) ToAppResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) AppResourcePropertiesResponsePtrOutput {
	return o
}

func (o AppResourcePropertiesResponsePtrOutput) Elem() AppResourcePropertiesResponseOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) AppResourcePropertiesResponse { return *v }).(AppResourcePropertiesResponseOutput)
}

// Name of the active deployment of the App
func (o AppResourcePropertiesResponsePtrOutput) ActiveDeploymentName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.ActiveDeploymentName
	}).(pulumi.StringPtrOutput)
}

// Date time when the resource is created
func (o AppResourcePropertiesResponsePtrOutput) CreatedTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.CreatedTime
	}).(pulumi.StringPtrOutput)
}

// Fully qualified dns Name.
func (o AppResourcePropertiesResponsePtrOutput) Fqdn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.Fqdn
	}).(pulumi.StringPtrOutput)
}

// Indicate if only https is allowed.
func (o AppResourcePropertiesResponsePtrOutput) HttpsOnly() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *bool {
		if v == nil {
			return nil
		}
		return v.HttpsOnly
	}).(pulumi.BoolPtrOutput)
}

// Persistent disk settings
func (o AppResourcePropertiesResponsePtrOutput) PersistentDisk() PersistentDiskResponsePtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *PersistentDiskResponse {
		if v == nil {
			return nil
		}
		return v.PersistentDisk
	}).(PersistentDiskResponsePtrOutput)
}

// Provisioning state of the App
func (o AppResourcePropertiesResponsePtrOutput) ProvisioningState() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ProvisioningState
	}).(pulumi.StringPtrOutput)
}

// Indicates whether the App exposes public endpoint
func (o AppResourcePropertiesResponsePtrOutput) Public() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *bool {
		if v == nil {
			return nil
		}
		return v.Public
	}).(pulumi.BoolPtrOutput)
}

// Temporary disk settings
func (o AppResourcePropertiesResponsePtrOutput) TemporaryDisk() TemporaryDiskResponsePtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *TemporaryDiskResponse {
		if v == nil {
			return nil
		}
		return v.TemporaryDisk
	}).(TemporaryDiskResponsePtrOutput)
}

// URL of the App
func (o AppResourcePropertiesResponsePtrOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AppResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Url
	}).(pulumi.StringPtrOutput)
}

// Binding resource properties payload
type BindingResourceProperties struct {
	// Binding parameters of the Binding resource
	BindingParameters map[string]interface{} `pulumi:"bindingParameters"`
	// The key of the bound resource
	Key *string `pulumi:"key"`
	// The Azure resource id of the bound resource
	ResourceId *string `pulumi:"resourceId"`
}

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

	ToBindingResourcePropertiesOutput() BindingResourcePropertiesOutput
	ToBindingResourcePropertiesOutputWithContext(context.Context) BindingResourcePropertiesOutput
}

// Binding resource properties payload
type BindingResourcePropertiesArgs struct {
	// Binding parameters of the Binding resource
	BindingParameters pulumi.MapInput `pulumi:"bindingParameters"`
	// The key of the bound resource
	Key pulumi.StringPtrInput `pulumi:"key"`
	// The Azure resource id of the bound resource
	ResourceId pulumi.StringPtrInput `pulumi:"resourceId"`
}

func (BindingResourcePropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*BindingResourceProperties)(nil)).Elem()
}

func (i BindingResourcePropertiesArgs) ToBindingResourcePropertiesOutput() BindingResourcePropertiesOutput {
	return i.ToBindingResourcePropertiesOutputWithContext(context.Background())
}

func (i BindingResourcePropertiesArgs) ToBindingResourcePropertiesOutputWithContext(ctx context.Context) BindingResourcePropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingResourcePropertiesOutput)
}

func (i BindingResourcePropertiesArgs) ToBindingResourcePropertiesPtrOutput() BindingResourcePropertiesPtrOutput {
	return i.ToBindingResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i BindingResourcePropertiesArgs) ToBindingResourcePropertiesPtrOutputWithContext(ctx context.Context) BindingResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingResourcePropertiesOutput).ToBindingResourcePropertiesPtrOutputWithContext(ctx)
}

// BindingResourcePropertiesPtrInput is an input type that accepts BindingResourcePropertiesArgs, BindingResourcePropertiesPtr and BindingResourcePropertiesPtrOutput values.
// You can construct a concrete instance of `BindingResourcePropertiesPtrInput` via:
//
//          BindingResourcePropertiesArgs{...}
//
//  or:
//
//          nil
type BindingResourcePropertiesPtrInput interface {
	pulumi.Input

	ToBindingResourcePropertiesPtrOutput() BindingResourcePropertiesPtrOutput
	ToBindingResourcePropertiesPtrOutputWithContext(context.Context) BindingResourcePropertiesPtrOutput
}

type bindingResourcePropertiesPtrType BindingResourcePropertiesArgs

func BindingResourcePropertiesPtr(v *BindingResourcePropertiesArgs) BindingResourcePropertiesPtrInput {
	return (*bindingResourcePropertiesPtrType)(v)
}

func (*bindingResourcePropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**BindingResourceProperties)(nil)).Elem()
}

func (i *bindingResourcePropertiesPtrType) ToBindingResourcePropertiesPtrOutput() BindingResourcePropertiesPtrOutput {
	return i.ToBindingResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i *bindingResourcePropertiesPtrType) ToBindingResourcePropertiesPtrOutputWithContext(ctx context.Context) BindingResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingResourcePropertiesPtrOutput)
}

// Binding resource properties payload
type BindingResourcePropertiesOutput struct{ *pulumi.OutputState }

func (BindingResourcePropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BindingResourceProperties)(nil)).Elem()
}

func (o BindingResourcePropertiesOutput) ToBindingResourcePropertiesOutput() BindingResourcePropertiesOutput {
	return o
}

func (o BindingResourcePropertiesOutput) ToBindingResourcePropertiesOutputWithContext(ctx context.Context) BindingResourcePropertiesOutput {
	return o
}

func (o BindingResourcePropertiesOutput) ToBindingResourcePropertiesPtrOutput() BindingResourcePropertiesPtrOutput {
	return o.ToBindingResourcePropertiesPtrOutputWithContext(context.Background())
}

func (o BindingResourcePropertiesOutput) ToBindingResourcePropertiesPtrOutputWithContext(ctx context.Context) BindingResourcePropertiesPtrOutput {
	return o.ApplyT(func(v BindingResourceProperties) *BindingResourceProperties {
		return &v
	}).(BindingResourcePropertiesPtrOutput)
}

// Binding parameters of the Binding resource
func (o BindingResourcePropertiesOutput) BindingParameters() pulumi.MapOutput {
	return o.ApplyT(func(v BindingResourceProperties) map[string]interface{} { return v.BindingParameters }).(pulumi.MapOutput)
}

// The key of the bound resource
func (o BindingResourcePropertiesOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BindingResourceProperties) *string { return v.Key }).(pulumi.StringPtrOutput)
}

// The Azure resource id of the bound resource
func (o BindingResourcePropertiesOutput) ResourceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BindingResourceProperties) *string { return v.ResourceId }).(pulumi.StringPtrOutput)
}

type BindingResourcePropertiesPtrOutput struct{ *pulumi.OutputState }

func (BindingResourcePropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**BindingResourceProperties)(nil)).Elem()
}

func (o BindingResourcePropertiesPtrOutput) ToBindingResourcePropertiesPtrOutput() BindingResourcePropertiesPtrOutput {
	return o
}

func (o BindingResourcePropertiesPtrOutput) ToBindingResourcePropertiesPtrOutputWithContext(ctx context.Context) BindingResourcePropertiesPtrOutput {
	return o
}

func (o BindingResourcePropertiesPtrOutput) Elem() BindingResourcePropertiesOutput {
	return o.ApplyT(func(v *BindingResourceProperties) BindingResourceProperties { return *v }).(BindingResourcePropertiesOutput)
}

// Binding parameters of the Binding resource
func (o BindingResourcePropertiesPtrOutput) BindingParameters() pulumi.MapOutput {
	return o.ApplyT(func(v *BindingResourceProperties) map[string]interface{} {
		if v == nil {
			return nil
		}
		return v.BindingParameters
	}).(pulumi.MapOutput)
}

// The key of the bound resource
func (o BindingResourcePropertiesPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourceProperties) *string {
		if v == nil {
			return nil
		}
		return v.Key
	}).(pulumi.StringPtrOutput)
}

// The Azure resource id of the bound resource
func (o BindingResourcePropertiesPtrOutput) ResourceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourceProperties) *string {
		if v == nil {
			return nil
		}
		return v.ResourceId
	}).(pulumi.StringPtrOutput)
}

// Binding resource properties payload
type BindingResourcePropertiesResponse struct {
	// Binding parameters of the Binding resource
	BindingParameters map[string]interface{} `pulumi:"bindingParameters"`
	// Creation time of the Binding resource
	CreatedAt string `pulumi:"createdAt"`
	// The generated Spring Boot property file for this binding. The secret will be deducted.
	GeneratedProperties string `pulumi:"generatedProperties"`
	// The key of the bound resource
	Key *string `pulumi:"key"`
	// The Azure resource id of the bound resource
	ResourceId *string `pulumi:"resourceId"`
	// The name of the bound resource
	ResourceName string `pulumi:"resourceName"`
	// The standard Azure resource type of the bound resource
	ResourceType string `pulumi:"resourceType"`
	// Update time of the Binding resource
	UpdatedAt string `pulumi:"updatedAt"`
}

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

	ToBindingResourcePropertiesResponseOutput() BindingResourcePropertiesResponseOutput
	ToBindingResourcePropertiesResponseOutputWithContext(context.Context) BindingResourcePropertiesResponseOutput
}

// Binding resource properties payload
type BindingResourcePropertiesResponseArgs struct {
	// Binding parameters of the Binding resource
	BindingParameters pulumi.MapInput `pulumi:"bindingParameters"`
	// Creation time of the Binding resource
	CreatedAt pulumi.StringInput `pulumi:"createdAt"`
	// The generated Spring Boot property file for this binding. The secret will be deducted.
	GeneratedProperties pulumi.StringInput `pulumi:"generatedProperties"`
	// The key of the bound resource
	Key pulumi.StringPtrInput `pulumi:"key"`
	// The Azure resource id of the bound resource
	ResourceId pulumi.StringPtrInput `pulumi:"resourceId"`
	// The name of the bound resource
	ResourceName pulumi.StringInput `pulumi:"resourceName"`
	// The standard Azure resource type of the bound resource
	ResourceType pulumi.StringInput `pulumi:"resourceType"`
	// Update time of the Binding resource
	UpdatedAt pulumi.StringInput `pulumi:"updatedAt"`
}

func (BindingResourcePropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*BindingResourcePropertiesResponse)(nil)).Elem()
}

func (i BindingResourcePropertiesResponseArgs) ToBindingResourcePropertiesResponseOutput() BindingResourcePropertiesResponseOutput {
	return i.ToBindingResourcePropertiesResponseOutputWithContext(context.Background())
}

func (i BindingResourcePropertiesResponseArgs) ToBindingResourcePropertiesResponseOutputWithContext(ctx context.Context) BindingResourcePropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingResourcePropertiesResponseOutput)
}

func (i BindingResourcePropertiesResponseArgs) ToBindingResourcePropertiesResponsePtrOutput() BindingResourcePropertiesResponsePtrOutput {
	return i.ToBindingResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i BindingResourcePropertiesResponseArgs) ToBindingResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) BindingResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingResourcePropertiesResponseOutput).ToBindingResourcePropertiesResponsePtrOutputWithContext(ctx)
}

// BindingResourcePropertiesResponsePtrInput is an input type that accepts BindingResourcePropertiesResponseArgs, BindingResourcePropertiesResponsePtr and BindingResourcePropertiesResponsePtrOutput values.
// You can construct a concrete instance of `BindingResourcePropertiesResponsePtrInput` via:
//
//          BindingResourcePropertiesResponseArgs{...}
//
//  or:
//
//          nil
type BindingResourcePropertiesResponsePtrInput interface {
	pulumi.Input

	ToBindingResourcePropertiesResponsePtrOutput() BindingResourcePropertiesResponsePtrOutput
	ToBindingResourcePropertiesResponsePtrOutputWithContext(context.Context) BindingResourcePropertiesResponsePtrOutput
}

type bindingResourcePropertiesResponsePtrType BindingResourcePropertiesResponseArgs

func BindingResourcePropertiesResponsePtr(v *BindingResourcePropertiesResponseArgs) BindingResourcePropertiesResponsePtrInput {
	return (*bindingResourcePropertiesResponsePtrType)(v)
}

func (*bindingResourcePropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**BindingResourcePropertiesResponse)(nil)).Elem()
}

func (i *bindingResourcePropertiesResponsePtrType) ToBindingResourcePropertiesResponsePtrOutput() BindingResourcePropertiesResponsePtrOutput {
	return i.ToBindingResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *bindingResourcePropertiesResponsePtrType) ToBindingResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) BindingResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingResourcePropertiesResponsePtrOutput)
}

// Binding resource properties payload
type BindingResourcePropertiesResponseOutput struct{ *pulumi.OutputState }

func (BindingResourcePropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BindingResourcePropertiesResponse)(nil)).Elem()
}

func (o BindingResourcePropertiesResponseOutput) ToBindingResourcePropertiesResponseOutput() BindingResourcePropertiesResponseOutput {
	return o
}

func (o BindingResourcePropertiesResponseOutput) ToBindingResourcePropertiesResponseOutputWithContext(ctx context.Context) BindingResourcePropertiesResponseOutput {
	return o
}

func (o BindingResourcePropertiesResponseOutput) ToBindingResourcePropertiesResponsePtrOutput() BindingResourcePropertiesResponsePtrOutput {
	return o.ToBindingResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (o BindingResourcePropertiesResponseOutput) ToBindingResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) BindingResourcePropertiesResponsePtrOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) *BindingResourcePropertiesResponse {
		return &v
	}).(BindingResourcePropertiesResponsePtrOutput)
}

// Binding parameters of the Binding resource
func (o BindingResourcePropertiesResponseOutput) BindingParameters() pulumi.MapOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) map[string]interface{} { return v.BindingParameters }).(pulumi.MapOutput)
}

// Creation time of the Binding resource
func (o BindingResourcePropertiesResponseOutput) CreatedAt() pulumi.StringOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) string { return v.CreatedAt }).(pulumi.StringOutput)
}

// The generated Spring Boot property file for this binding. The secret will be deducted.
func (o BindingResourcePropertiesResponseOutput) GeneratedProperties() pulumi.StringOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) string { return v.GeneratedProperties }).(pulumi.StringOutput)
}

// The key of the bound resource
func (o BindingResourcePropertiesResponseOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) *string { return v.Key }).(pulumi.StringPtrOutput)
}

// The Azure resource id of the bound resource
func (o BindingResourcePropertiesResponseOutput) ResourceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) *string { return v.ResourceId }).(pulumi.StringPtrOutput)
}

// The name of the bound resource
func (o BindingResourcePropertiesResponseOutput) ResourceName() pulumi.StringOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) string { return v.ResourceName }).(pulumi.StringOutput)
}

// The standard Azure resource type of the bound resource
func (o BindingResourcePropertiesResponseOutput) ResourceType() pulumi.StringOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) string { return v.ResourceType }).(pulumi.StringOutput)
}

// Update time of the Binding resource
func (o BindingResourcePropertiesResponseOutput) UpdatedAt() pulumi.StringOutput {
	return o.ApplyT(func(v BindingResourcePropertiesResponse) string { return v.UpdatedAt }).(pulumi.StringOutput)
}

type BindingResourcePropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (BindingResourcePropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**BindingResourcePropertiesResponse)(nil)).Elem()
}

func (o BindingResourcePropertiesResponsePtrOutput) ToBindingResourcePropertiesResponsePtrOutput() BindingResourcePropertiesResponsePtrOutput {
	return o
}

func (o BindingResourcePropertiesResponsePtrOutput) ToBindingResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) BindingResourcePropertiesResponsePtrOutput {
	return o
}

func (o BindingResourcePropertiesResponsePtrOutput) Elem() BindingResourcePropertiesResponseOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) BindingResourcePropertiesResponse { return *v }).(BindingResourcePropertiesResponseOutput)
}

// Binding parameters of the Binding resource
func (o BindingResourcePropertiesResponsePtrOutput) BindingParameters() pulumi.MapOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) map[string]interface{} {
		if v == nil {
			return nil
		}
		return v.BindingParameters
	}).(pulumi.MapOutput)
}

// Creation time of the Binding resource
func (o BindingResourcePropertiesResponsePtrOutput) CreatedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.CreatedAt
	}).(pulumi.StringPtrOutput)
}

// The generated Spring Boot property file for this binding. The secret will be deducted.
func (o BindingResourcePropertiesResponsePtrOutput) GeneratedProperties() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.GeneratedProperties
	}).(pulumi.StringPtrOutput)
}

// The key of the bound resource
func (o BindingResourcePropertiesResponsePtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.Key
	}).(pulumi.StringPtrOutput)
}

// The Azure resource id of the bound resource
func (o BindingResourcePropertiesResponsePtrOutput) ResourceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.ResourceId
	}).(pulumi.StringPtrOutput)
}

// The name of the bound resource
func (o BindingResourcePropertiesResponsePtrOutput) ResourceName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ResourceName
	}).(pulumi.StringPtrOutput)
}

// The standard Azure resource type of the bound resource
func (o BindingResourcePropertiesResponsePtrOutput) ResourceType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ResourceType
	}).(pulumi.StringPtrOutput)
}

// Update time of the Binding resource
func (o BindingResourcePropertiesResponsePtrOutput) UpdatedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BindingResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.UpdatedAt
	}).(pulumi.StringPtrOutput)
}

// Certificate resource payload.
type CertificateProperties struct {
	// The certificate version of key vault.
	CertVersion *string `pulumi:"certVersion"`
	// The certificate name of key vault.
	KeyVaultCertName string `pulumi:"keyVaultCertName"`
	// The vault uri of user key vault.
	VaultUri string `pulumi:"vaultUri"`
}

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

	ToCertificatePropertiesOutput() CertificatePropertiesOutput
	ToCertificatePropertiesOutputWithContext(context.Context) CertificatePropertiesOutput
}

// Certificate resource payload.
type CertificatePropertiesArgs struct {
	// The certificate version of key vault.
	CertVersion pulumi.StringPtrInput `pulumi:"certVersion"`
	// The certificate name of key vault.
	KeyVaultCertName pulumi.StringInput `pulumi:"keyVaultCertName"`
	// The vault uri of user key vault.
	VaultUri pulumi.StringInput `pulumi:"vaultUri"`
}

func (CertificatePropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*CertificateProperties)(nil)).Elem()
}

func (i CertificatePropertiesArgs) ToCertificatePropertiesOutput() CertificatePropertiesOutput {
	return i.ToCertificatePropertiesOutputWithContext(context.Background())
}

func (i CertificatePropertiesArgs) ToCertificatePropertiesOutputWithContext(ctx context.Context) CertificatePropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CertificatePropertiesOutput)
}

func (i CertificatePropertiesArgs) ToCertificatePropertiesPtrOutput() CertificatePropertiesPtrOutput {
	return i.ToCertificatePropertiesPtrOutputWithContext(context.Background())
}

func (i CertificatePropertiesArgs) ToCertificatePropertiesPtrOutputWithContext(ctx context.Context) CertificatePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CertificatePropertiesOutput).ToCertificatePropertiesPtrOutputWithContext(ctx)
}

// CertificatePropertiesPtrInput is an input type that accepts CertificatePropertiesArgs, CertificatePropertiesPtr and CertificatePropertiesPtrOutput values.
// You can construct a concrete instance of `CertificatePropertiesPtrInput` via:
//
//          CertificatePropertiesArgs{...}
//
//  or:
//
//          nil
type CertificatePropertiesPtrInput interface {
	pulumi.Input

	ToCertificatePropertiesPtrOutput() CertificatePropertiesPtrOutput
	ToCertificatePropertiesPtrOutputWithContext(context.Context) CertificatePropertiesPtrOutput
}

type certificatePropertiesPtrType CertificatePropertiesArgs

func CertificatePropertiesPtr(v *CertificatePropertiesArgs) CertificatePropertiesPtrInput {
	return (*certificatePropertiesPtrType)(v)
}

func (*certificatePropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**CertificateProperties)(nil)).Elem()
}

func (i *certificatePropertiesPtrType) ToCertificatePropertiesPtrOutput() CertificatePropertiesPtrOutput {
	return i.ToCertificatePropertiesPtrOutputWithContext(context.Background())
}

func (i *certificatePropertiesPtrType) ToCertificatePropertiesPtrOutputWithContext(ctx context.Context) CertificatePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CertificatePropertiesPtrOutput)
}

// Certificate resource payload.
type CertificatePropertiesOutput struct{ *pulumi.OutputState }

func (CertificatePropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CertificateProperties)(nil)).Elem()
}

func (o CertificatePropertiesOutput) ToCertificatePropertiesOutput() CertificatePropertiesOutput {
	return o
}

func (o CertificatePropertiesOutput) ToCertificatePropertiesOutputWithContext(ctx context.Context) CertificatePropertiesOutput {
	return o
}

func (o CertificatePropertiesOutput) ToCertificatePropertiesPtrOutput() CertificatePropertiesPtrOutput {
	return o.ToCertificatePropertiesPtrOutputWithContext(context.Background())
}

func (o CertificatePropertiesOutput) ToCertificatePropertiesPtrOutputWithContext(ctx context.Context) CertificatePropertiesPtrOutput {
	return o.ApplyT(func(v CertificateProperties) *CertificateProperties {
		return &v
	}).(CertificatePropertiesPtrOutput)
}

// The certificate version of key vault.
func (o CertificatePropertiesOutput) CertVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CertificateProperties) *string { return v.CertVersion }).(pulumi.StringPtrOutput)
}

// The certificate name of key vault.
func (o CertificatePropertiesOutput) KeyVaultCertName() pulumi.StringOutput {
	return o.ApplyT(func(v CertificateProperties) string { return v.KeyVaultCertName }).(pulumi.StringOutput)
}

// The vault uri of user key vault.
func (o CertificatePropertiesOutput) VaultUri() pulumi.StringOutput {
	return o.ApplyT(func(v CertificateProperties) string { return v.VaultUri }).(pulumi.StringOutput)
}

type CertificatePropertiesPtrOutput struct{ *pulumi.OutputState }

func (CertificatePropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**CertificateProperties)(nil)).Elem()
}

func (o CertificatePropertiesPtrOutput) ToCertificatePropertiesPtrOutput() CertificatePropertiesPtrOutput {
	return o
}

func (o CertificatePropertiesPtrOutput) ToCertificatePropertiesPtrOutputWithContext(ctx context.Context) CertificatePropertiesPtrOutput {
	return o
}

func (o CertificatePropertiesPtrOutput) Elem() CertificatePropertiesOutput {
	return o.ApplyT(func(v *CertificateProperties) CertificateProperties { return *v }).(CertificatePropertiesOutput)
}

// The certificate version of key vault.
func (o CertificatePropertiesPtrOutput) CertVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificateProperties) *string {
		if v == nil {
			return nil
		}
		return v.CertVersion
	}).(pulumi.StringPtrOutput)
}

// The certificate name of key vault.
func (o CertificatePropertiesPtrOutput) KeyVaultCertName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificateProperties) *string {
		if v == nil {
			return nil
		}
		return &v.KeyVaultCertName
	}).(pulumi.StringPtrOutput)
}

// The vault uri of user key vault.
func (o CertificatePropertiesPtrOutput) VaultUri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificateProperties) *string {
		if v == nil {
			return nil
		}
		return &v.VaultUri
	}).(pulumi.StringPtrOutput)
}

// Certificate resource payload.
type CertificatePropertiesResponse struct {
	// The activate date of certificate.
	ActivateDate string `pulumi:"activateDate"`
	// The certificate version of key vault.
	CertVersion *string `pulumi:"certVersion"`
	// The domain list of certificate.
	DnsNames []string `pulumi:"dnsNames"`
	// The expiration date of certificate.
	ExpirationDate string `pulumi:"expirationDate"`
	// The issue date of certificate.
	IssuedDate string `pulumi:"issuedDate"`
	// The issuer of certificate.
	Issuer string `pulumi:"issuer"`
	// The certificate name of key vault.
	KeyVaultCertName string `pulumi:"keyVaultCertName"`
	// The subject name of certificate.
	SubjectName string `pulumi:"subjectName"`
	// The thumbprint of certificate.
	Thumbprint string `pulumi:"thumbprint"`
	// The vault uri of user key vault.
	VaultUri string `pulumi:"vaultUri"`
}

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

	ToCertificatePropertiesResponseOutput() CertificatePropertiesResponseOutput
	ToCertificatePropertiesResponseOutputWithContext(context.Context) CertificatePropertiesResponseOutput
}

// Certificate resource payload.
type CertificatePropertiesResponseArgs struct {
	// The activate date of certificate.
	ActivateDate pulumi.StringInput `pulumi:"activateDate"`
	// The certificate version of key vault.
	CertVersion pulumi.StringPtrInput `pulumi:"certVersion"`
	// The domain list of certificate.
	DnsNames pulumi.StringArrayInput `pulumi:"dnsNames"`
	// The expiration date of certificate.
	ExpirationDate pulumi.StringInput `pulumi:"expirationDate"`
	// The issue date of certificate.
	IssuedDate pulumi.StringInput `pulumi:"issuedDate"`
	// The issuer of certificate.
	Issuer pulumi.StringInput `pulumi:"issuer"`
	// The certificate name of key vault.
	KeyVaultCertName pulumi.StringInput `pulumi:"keyVaultCertName"`
	// The subject name of certificate.
	SubjectName pulumi.StringInput `pulumi:"subjectName"`
	// The thumbprint of certificate.
	Thumbprint pulumi.StringInput `pulumi:"thumbprint"`
	// The vault uri of user key vault.
	VaultUri pulumi.StringInput `pulumi:"vaultUri"`
}

func (CertificatePropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*CertificatePropertiesResponse)(nil)).Elem()
}

func (i CertificatePropertiesResponseArgs) ToCertificatePropertiesResponseOutput() CertificatePropertiesResponseOutput {
	return i.ToCertificatePropertiesResponseOutputWithContext(context.Background())
}

func (i CertificatePropertiesResponseArgs) ToCertificatePropertiesResponseOutputWithContext(ctx context.Context) CertificatePropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CertificatePropertiesResponseOutput)
}

func (i CertificatePropertiesResponseArgs) ToCertificatePropertiesResponsePtrOutput() CertificatePropertiesResponsePtrOutput {
	return i.ToCertificatePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i CertificatePropertiesResponseArgs) ToCertificatePropertiesResponsePtrOutputWithContext(ctx context.Context) CertificatePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CertificatePropertiesResponseOutput).ToCertificatePropertiesResponsePtrOutputWithContext(ctx)
}

// CertificatePropertiesResponsePtrInput is an input type that accepts CertificatePropertiesResponseArgs, CertificatePropertiesResponsePtr and CertificatePropertiesResponsePtrOutput values.
// You can construct a concrete instance of `CertificatePropertiesResponsePtrInput` via:
//
//          CertificatePropertiesResponseArgs{...}
//
//  or:
//
//          nil
type CertificatePropertiesResponsePtrInput interface {
	pulumi.Input

	ToCertificatePropertiesResponsePtrOutput() CertificatePropertiesResponsePtrOutput
	ToCertificatePropertiesResponsePtrOutputWithContext(context.Context) CertificatePropertiesResponsePtrOutput
}

type certificatePropertiesResponsePtrType CertificatePropertiesResponseArgs

func CertificatePropertiesResponsePtr(v *CertificatePropertiesResponseArgs) CertificatePropertiesResponsePtrInput {
	return (*certificatePropertiesResponsePtrType)(v)
}

func (*certificatePropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**CertificatePropertiesResponse)(nil)).Elem()
}

func (i *certificatePropertiesResponsePtrType) ToCertificatePropertiesResponsePtrOutput() CertificatePropertiesResponsePtrOutput {
	return i.ToCertificatePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *certificatePropertiesResponsePtrType) ToCertificatePropertiesResponsePtrOutputWithContext(ctx context.Context) CertificatePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CertificatePropertiesResponsePtrOutput)
}

// Certificate resource payload.
type CertificatePropertiesResponseOutput struct{ *pulumi.OutputState }

func (CertificatePropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CertificatePropertiesResponse)(nil)).Elem()
}

func (o CertificatePropertiesResponseOutput) ToCertificatePropertiesResponseOutput() CertificatePropertiesResponseOutput {
	return o
}

func (o CertificatePropertiesResponseOutput) ToCertificatePropertiesResponseOutputWithContext(ctx context.Context) CertificatePropertiesResponseOutput {
	return o
}

func (o CertificatePropertiesResponseOutput) ToCertificatePropertiesResponsePtrOutput() CertificatePropertiesResponsePtrOutput {
	return o.ToCertificatePropertiesResponsePtrOutputWithContext(context.Background())
}

func (o CertificatePropertiesResponseOutput) ToCertificatePropertiesResponsePtrOutputWithContext(ctx context.Context) CertificatePropertiesResponsePtrOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) *CertificatePropertiesResponse {
		return &v
	}).(CertificatePropertiesResponsePtrOutput)
}

// The activate date of certificate.
func (o CertificatePropertiesResponseOutput) ActivateDate() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.ActivateDate }).(pulumi.StringOutput)
}

// The certificate version of key vault.
func (o CertificatePropertiesResponseOutput) CertVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) *string { return v.CertVersion }).(pulumi.StringPtrOutput)
}

// The domain list of certificate.
func (o CertificatePropertiesResponseOutput) DnsNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) []string { return v.DnsNames }).(pulumi.StringArrayOutput)
}

// The expiration date of certificate.
func (o CertificatePropertiesResponseOutput) ExpirationDate() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.ExpirationDate }).(pulumi.StringOutput)
}

// The issue date of certificate.
func (o CertificatePropertiesResponseOutput) IssuedDate() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.IssuedDate }).(pulumi.StringOutput)
}

// The issuer of certificate.
func (o CertificatePropertiesResponseOutput) Issuer() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.Issuer }).(pulumi.StringOutput)
}

// The certificate name of key vault.
func (o CertificatePropertiesResponseOutput) KeyVaultCertName() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.KeyVaultCertName }).(pulumi.StringOutput)
}

// The subject name of certificate.
func (o CertificatePropertiesResponseOutput) SubjectName() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.SubjectName }).(pulumi.StringOutput)
}

// The thumbprint of certificate.
func (o CertificatePropertiesResponseOutput) Thumbprint() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.Thumbprint }).(pulumi.StringOutput)
}

// The vault uri of user key vault.
func (o CertificatePropertiesResponseOutput) VaultUri() pulumi.StringOutput {
	return o.ApplyT(func(v CertificatePropertiesResponse) string { return v.VaultUri }).(pulumi.StringOutput)
}

type CertificatePropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (CertificatePropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**CertificatePropertiesResponse)(nil)).Elem()
}

func (o CertificatePropertiesResponsePtrOutput) ToCertificatePropertiesResponsePtrOutput() CertificatePropertiesResponsePtrOutput {
	return o
}

func (o CertificatePropertiesResponsePtrOutput) ToCertificatePropertiesResponsePtrOutputWithContext(ctx context.Context) CertificatePropertiesResponsePtrOutput {
	return o
}

func (o CertificatePropertiesResponsePtrOutput) Elem() CertificatePropertiesResponseOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) CertificatePropertiesResponse { return *v }).(CertificatePropertiesResponseOutput)
}

// The activate date of certificate.
func (o CertificatePropertiesResponsePtrOutput) ActivateDate() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ActivateDate
	}).(pulumi.StringPtrOutput)
}

// The certificate version of key vault.
func (o CertificatePropertiesResponsePtrOutput) CertVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.CertVersion
	}).(pulumi.StringPtrOutput)
}

// The domain list of certificate.
func (o CertificatePropertiesResponsePtrOutput) DnsNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) []string {
		if v == nil {
			return nil
		}
		return v.DnsNames
	}).(pulumi.StringArrayOutput)
}

// The expiration date of certificate.
func (o CertificatePropertiesResponsePtrOutput) ExpirationDate() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ExpirationDate
	}).(pulumi.StringPtrOutput)
}

// The issue date of certificate.
func (o CertificatePropertiesResponsePtrOutput) IssuedDate() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.IssuedDate
	}).(pulumi.StringPtrOutput)
}

// The issuer of certificate.
func (o CertificatePropertiesResponsePtrOutput) Issuer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Issuer
	}).(pulumi.StringPtrOutput)
}

// The certificate name of key vault.
func (o CertificatePropertiesResponsePtrOutput) KeyVaultCertName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.KeyVaultCertName
	}).(pulumi.StringPtrOutput)
}

// The subject name of certificate.
func (o CertificatePropertiesResponsePtrOutput) SubjectName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.SubjectName
	}).(pulumi.StringPtrOutput)
}

// The thumbprint of certificate.
func (o CertificatePropertiesResponsePtrOutput) Thumbprint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Thumbprint
	}).(pulumi.StringPtrOutput)
}

// The vault uri of user key vault.
func (o CertificatePropertiesResponsePtrOutput) VaultUri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CertificatePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.VaultUri
	}).(pulumi.StringPtrOutput)
}

// Service properties payload
type ClusterResourceProperties struct {
	// Network profile of the Service
	NetworkProfile *NetworkProfile `pulumi:"networkProfile"`
}

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

	ToClusterResourcePropertiesOutput() ClusterResourcePropertiesOutput
	ToClusterResourcePropertiesOutputWithContext(context.Context) ClusterResourcePropertiesOutput
}

// Service properties payload
type ClusterResourcePropertiesArgs struct {
	// Network profile of the Service
	NetworkProfile NetworkProfilePtrInput `pulumi:"networkProfile"`
}

func (ClusterResourcePropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterResourceProperties)(nil)).Elem()
}

func (i ClusterResourcePropertiesArgs) ToClusterResourcePropertiesOutput() ClusterResourcePropertiesOutput {
	return i.ToClusterResourcePropertiesOutputWithContext(context.Background())
}

func (i ClusterResourcePropertiesArgs) ToClusterResourcePropertiesOutputWithContext(ctx context.Context) ClusterResourcePropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterResourcePropertiesOutput)
}

func (i ClusterResourcePropertiesArgs) ToClusterResourcePropertiesPtrOutput() ClusterResourcePropertiesPtrOutput {
	return i.ToClusterResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i ClusterResourcePropertiesArgs) ToClusterResourcePropertiesPtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterResourcePropertiesOutput).ToClusterResourcePropertiesPtrOutputWithContext(ctx)
}

// ClusterResourcePropertiesPtrInput is an input type that accepts ClusterResourcePropertiesArgs, ClusterResourcePropertiesPtr and ClusterResourcePropertiesPtrOutput values.
// You can construct a concrete instance of `ClusterResourcePropertiesPtrInput` via:
//
//          ClusterResourcePropertiesArgs{...}
//
//  or:
//
//          nil
type ClusterResourcePropertiesPtrInput interface {
	pulumi.Input

	ToClusterResourcePropertiesPtrOutput() ClusterResourcePropertiesPtrOutput
	ToClusterResourcePropertiesPtrOutputWithContext(context.Context) ClusterResourcePropertiesPtrOutput
}

type clusterResourcePropertiesPtrType ClusterResourcePropertiesArgs

func ClusterResourcePropertiesPtr(v *ClusterResourcePropertiesArgs) ClusterResourcePropertiesPtrInput {
	return (*clusterResourcePropertiesPtrType)(v)
}

func (*clusterResourcePropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterResourceProperties)(nil)).Elem()
}

func (i *clusterResourcePropertiesPtrType) ToClusterResourcePropertiesPtrOutput() ClusterResourcePropertiesPtrOutput {
	return i.ToClusterResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i *clusterResourcePropertiesPtrType) ToClusterResourcePropertiesPtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterResourcePropertiesPtrOutput)
}

// Service properties payload
type ClusterResourcePropertiesOutput struct{ *pulumi.OutputState }

func (ClusterResourcePropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterResourceProperties)(nil)).Elem()
}

func (o ClusterResourcePropertiesOutput) ToClusterResourcePropertiesOutput() ClusterResourcePropertiesOutput {
	return o
}

func (o ClusterResourcePropertiesOutput) ToClusterResourcePropertiesOutputWithContext(ctx context.Context) ClusterResourcePropertiesOutput {
	return o
}

func (o ClusterResourcePropertiesOutput) ToClusterResourcePropertiesPtrOutput() ClusterResourcePropertiesPtrOutput {
	return o.ToClusterResourcePropertiesPtrOutputWithContext(context.Background())
}

func (o ClusterResourcePropertiesOutput) ToClusterResourcePropertiesPtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesPtrOutput {
	return o.ApplyT(func(v ClusterResourceProperties) *ClusterResourceProperties {
		return &v
	}).(ClusterResourcePropertiesPtrOutput)
}

// Network profile of the Service
func (o ClusterResourcePropertiesOutput) NetworkProfile() NetworkProfilePtrOutput {
	return o.ApplyT(func(v ClusterResourceProperties) *NetworkProfile { return v.NetworkProfile }).(NetworkProfilePtrOutput)
}

type ClusterResourcePropertiesPtrOutput struct{ *pulumi.OutputState }

func (ClusterResourcePropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterResourceProperties)(nil)).Elem()
}

func (o ClusterResourcePropertiesPtrOutput) ToClusterResourcePropertiesPtrOutput() ClusterResourcePropertiesPtrOutput {
	return o
}

func (o ClusterResourcePropertiesPtrOutput) ToClusterResourcePropertiesPtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesPtrOutput {
	return o
}

func (o ClusterResourcePropertiesPtrOutput) Elem() ClusterResourcePropertiesOutput {
	return o.ApplyT(func(v *ClusterResourceProperties) ClusterResourceProperties { return *v }).(ClusterResourcePropertiesOutput)
}

// Network profile of the Service
func (o ClusterResourcePropertiesPtrOutput) NetworkProfile() NetworkProfilePtrOutput {
	return o.ApplyT(func(v *ClusterResourceProperties) *NetworkProfile {
		if v == nil {
			return nil
		}
		return v.NetworkProfile
	}).(NetworkProfilePtrOutput)
}

// Service properties payload
type ClusterResourcePropertiesResponse struct {
	// Network profile of the Service
	NetworkProfile *NetworkProfileResponse `pulumi:"networkProfile"`
	// Provisioning state of the Service
	ProvisioningState string `pulumi:"provisioningState"`
	// ServiceInstanceEntity GUID which uniquely identifies a created resource
	ServiceId string `pulumi:"serviceId"`
	// Version of the Service
	Version int `pulumi:"version"`
}

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

	ToClusterResourcePropertiesResponseOutput() ClusterResourcePropertiesResponseOutput
	ToClusterResourcePropertiesResponseOutputWithContext(context.Context) ClusterResourcePropertiesResponseOutput
}

// Service properties payload
type ClusterResourcePropertiesResponseArgs struct {
	// Network profile of the Service
	NetworkProfile NetworkProfileResponsePtrInput `pulumi:"networkProfile"`
	// Provisioning state of the Service
	ProvisioningState pulumi.StringInput `pulumi:"provisioningState"`
	// ServiceInstanceEntity GUID which uniquely identifies a created resource
	ServiceId pulumi.StringInput `pulumi:"serviceId"`
	// Version of the Service
	Version pulumi.IntInput `pulumi:"version"`
}

func (ClusterResourcePropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterResourcePropertiesResponse)(nil)).Elem()
}

func (i ClusterResourcePropertiesResponseArgs) ToClusterResourcePropertiesResponseOutput() ClusterResourcePropertiesResponseOutput {
	return i.ToClusterResourcePropertiesResponseOutputWithContext(context.Background())
}

func (i ClusterResourcePropertiesResponseArgs) ToClusterResourcePropertiesResponseOutputWithContext(ctx context.Context) ClusterResourcePropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterResourcePropertiesResponseOutput)
}

func (i ClusterResourcePropertiesResponseArgs) ToClusterResourcePropertiesResponsePtrOutput() ClusterResourcePropertiesResponsePtrOutput {
	return i.ToClusterResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i ClusterResourcePropertiesResponseArgs) ToClusterResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterResourcePropertiesResponseOutput).ToClusterResourcePropertiesResponsePtrOutputWithContext(ctx)
}

// ClusterResourcePropertiesResponsePtrInput is an input type that accepts ClusterResourcePropertiesResponseArgs, ClusterResourcePropertiesResponsePtr and ClusterResourcePropertiesResponsePtrOutput values.
// You can construct a concrete instance of `ClusterResourcePropertiesResponsePtrInput` via:
//
//          ClusterResourcePropertiesResponseArgs{...}
//
//  or:
//
//          nil
type ClusterResourcePropertiesResponsePtrInput interface {
	pulumi.Input

	ToClusterResourcePropertiesResponsePtrOutput() ClusterResourcePropertiesResponsePtrOutput
	ToClusterResourcePropertiesResponsePtrOutputWithContext(context.Context) ClusterResourcePropertiesResponsePtrOutput
}

type clusterResourcePropertiesResponsePtrType ClusterResourcePropertiesResponseArgs

func ClusterResourcePropertiesResponsePtr(v *ClusterResourcePropertiesResponseArgs) ClusterResourcePropertiesResponsePtrInput {
	return (*clusterResourcePropertiesResponsePtrType)(v)
}

func (*clusterResourcePropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterResourcePropertiesResponse)(nil)).Elem()
}

func (i *clusterResourcePropertiesResponsePtrType) ToClusterResourcePropertiesResponsePtrOutput() ClusterResourcePropertiesResponsePtrOutput {
	return i.ToClusterResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *clusterResourcePropertiesResponsePtrType) ToClusterResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterResourcePropertiesResponsePtrOutput)
}

// Service properties payload
type ClusterResourcePropertiesResponseOutput struct{ *pulumi.OutputState }

func (ClusterResourcePropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterResourcePropertiesResponse)(nil)).Elem()
}

func (o ClusterResourcePropertiesResponseOutput) ToClusterResourcePropertiesResponseOutput() ClusterResourcePropertiesResponseOutput {
	return o
}

func (o ClusterResourcePropertiesResponseOutput) ToClusterResourcePropertiesResponseOutputWithContext(ctx context.Context) ClusterResourcePropertiesResponseOutput {
	return o
}

func (o ClusterResourcePropertiesResponseOutput) ToClusterResourcePropertiesResponsePtrOutput() ClusterResourcePropertiesResponsePtrOutput {
	return o.ToClusterResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (o ClusterResourcePropertiesResponseOutput) ToClusterResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesResponsePtrOutput {
	return o.ApplyT(func(v ClusterResourcePropertiesResponse) *ClusterResourcePropertiesResponse {
		return &v
	}).(ClusterResourcePropertiesResponsePtrOutput)
}

// Network profile of the Service
func (o ClusterResourcePropertiesResponseOutput) NetworkProfile() NetworkProfileResponsePtrOutput {
	return o.ApplyT(func(v ClusterResourcePropertiesResponse) *NetworkProfileResponse { return v.NetworkProfile }).(NetworkProfileResponsePtrOutput)
}

// Provisioning state of the Service
func (o ClusterResourcePropertiesResponseOutput) ProvisioningState() pulumi.StringOutput {
	return o.ApplyT(func(v ClusterResourcePropertiesResponse) string { return v.ProvisioningState }).(pulumi.StringOutput)
}

// ServiceInstanceEntity GUID which uniquely identifies a created resource
func (o ClusterResourcePropertiesResponseOutput) ServiceId() pulumi.StringOutput {
	return o.ApplyT(func(v ClusterResourcePropertiesResponse) string { return v.ServiceId }).(pulumi.StringOutput)
}

// Version of the Service
func (o ClusterResourcePropertiesResponseOutput) Version() pulumi.IntOutput {
	return o.ApplyT(func(v ClusterResourcePropertiesResponse) int { return v.Version }).(pulumi.IntOutput)
}

type ClusterResourcePropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (ClusterResourcePropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterResourcePropertiesResponse)(nil)).Elem()
}

func (o ClusterResourcePropertiesResponsePtrOutput) ToClusterResourcePropertiesResponsePtrOutput() ClusterResourcePropertiesResponsePtrOutput {
	return o
}

func (o ClusterResourcePropertiesResponsePtrOutput) ToClusterResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) ClusterResourcePropertiesResponsePtrOutput {
	return o
}

func (o ClusterResourcePropertiesResponsePtrOutput) Elem() ClusterResourcePropertiesResponseOutput {
	return o.ApplyT(func(v *ClusterResourcePropertiesResponse) ClusterResourcePropertiesResponse { return *v }).(ClusterResourcePropertiesResponseOutput)
}

// Network profile of the Service
func (o ClusterResourcePropertiesResponsePtrOutput) NetworkProfile() NetworkProfileResponsePtrOutput {
	return o.ApplyT(func(v *ClusterResourcePropertiesResponse) *NetworkProfileResponse {
		if v == nil {
			return nil
		}
		return v.NetworkProfile
	}).(NetworkProfileResponsePtrOutput)
}

// Provisioning state of the Service
func (o ClusterResourcePropertiesResponsePtrOutput) ProvisioningState() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ProvisioningState
	}).(pulumi.StringPtrOutput)
}

// ServiceInstanceEntity GUID which uniquely identifies a created resource
func (o ClusterResourcePropertiesResponsePtrOutput) ServiceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ServiceId
	}).(pulumi.StringPtrOutput)
}

// Version of the Service
func (o ClusterResourcePropertiesResponsePtrOutput) Version() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ClusterResourcePropertiesResponse) *int {
		if v == nil {
			return nil
		}
		return &v.Version
	}).(pulumi.IntPtrOutput)
}

// Custom domain of app resource payload.
type CustomDomainProperties struct {
	// The bound certificate name of domain.
	CertName *string `pulumi:"certName"`
	// The thumbprint of bound certificate.
	Thumbprint *string `pulumi:"thumbprint"`
}

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

	ToCustomDomainPropertiesOutput() CustomDomainPropertiesOutput
	ToCustomDomainPropertiesOutputWithContext(context.Context) CustomDomainPropertiesOutput
}

// Custom domain of app resource payload.
type CustomDomainPropertiesArgs struct {
	// The bound certificate name of domain.
	CertName pulumi.StringPtrInput `pulumi:"certName"`
	// The thumbprint of bound certificate.
	Thumbprint pulumi.StringPtrInput `pulumi:"thumbprint"`
}

func (CustomDomainPropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*CustomDomainProperties)(nil)).Elem()
}

func (i CustomDomainPropertiesArgs) ToCustomDomainPropertiesOutput() CustomDomainPropertiesOutput {
	return i.ToCustomDomainPropertiesOutputWithContext(context.Background())
}

func (i CustomDomainPropertiesArgs) ToCustomDomainPropertiesOutputWithContext(ctx context.Context) CustomDomainPropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CustomDomainPropertiesOutput)
}

func (i CustomDomainPropertiesArgs) ToCustomDomainPropertiesPtrOutput() CustomDomainPropertiesPtrOutput {
	return i.ToCustomDomainPropertiesPtrOutputWithContext(context.Background())
}

func (i CustomDomainPropertiesArgs) ToCustomDomainPropertiesPtrOutputWithContext(ctx context.Context) CustomDomainPropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CustomDomainPropertiesOutput).ToCustomDomainPropertiesPtrOutputWithContext(ctx)
}

// CustomDomainPropertiesPtrInput is an input type that accepts CustomDomainPropertiesArgs, CustomDomainPropertiesPtr and CustomDomainPropertiesPtrOutput values.
// You can construct a concrete instance of `CustomDomainPropertiesPtrInput` via:
//
//          CustomDomainPropertiesArgs{...}
//
//  or:
//
//          nil
type CustomDomainPropertiesPtrInput interface {
	pulumi.Input

	ToCustomDomainPropertiesPtrOutput() CustomDomainPropertiesPtrOutput
	ToCustomDomainPropertiesPtrOutputWithContext(context.Context) CustomDomainPropertiesPtrOutput
}

type customDomainPropertiesPtrType CustomDomainPropertiesArgs

func CustomDomainPropertiesPtr(v *CustomDomainPropertiesArgs) CustomDomainPropertiesPtrInput {
	return (*customDomainPropertiesPtrType)(v)
}

func (*customDomainPropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**CustomDomainProperties)(nil)).Elem()
}

func (i *customDomainPropertiesPtrType) ToCustomDomainPropertiesPtrOutput() CustomDomainPropertiesPtrOutput {
	return i.ToCustomDomainPropertiesPtrOutputWithContext(context.Background())
}

func (i *customDomainPropertiesPtrType) ToCustomDomainPropertiesPtrOutputWithContext(ctx context.Context) CustomDomainPropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CustomDomainPropertiesPtrOutput)
}

// Custom domain of app resource payload.
type CustomDomainPropertiesOutput struct{ *pulumi.OutputState }

func (CustomDomainPropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CustomDomainProperties)(nil)).Elem()
}

func (o CustomDomainPropertiesOutput) ToCustomDomainPropertiesOutput() CustomDomainPropertiesOutput {
	return o
}

func (o CustomDomainPropertiesOutput) ToCustomDomainPropertiesOutputWithContext(ctx context.Context) CustomDomainPropertiesOutput {
	return o
}

func (o CustomDomainPropertiesOutput) ToCustomDomainPropertiesPtrOutput() CustomDomainPropertiesPtrOutput {
	return o.ToCustomDomainPropertiesPtrOutputWithContext(context.Background())
}

func (o CustomDomainPropertiesOutput) ToCustomDomainPropertiesPtrOutputWithContext(ctx context.Context) CustomDomainPropertiesPtrOutput {
	return o.ApplyT(func(v CustomDomainProperties) *CustomDomainProperties {
		return &v
	}).(CustomDomainPropertiesPtrOutput)
}

// The bound certificate name of domain.
func (o CustomDomainPropertiesOutput) CertName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CustomDomainProperties) *string { return v.CertName }).(pulumi.StringPtrOutput)
}

// The thumbprint of bound certificate.
func (o CustomDomainPropertiesOutput) Thumbprint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CustomDomainProperties) *string { return v.Thumbprint }).(pulumi.StringPtrOutput)
}

type CustomDomainPropertiesPtrOutput struct{ *pulumi.OutputState }

func (CustomDomainPropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**CustomDomainProperties)(nil)).Elem()
}

func (o CustomDomainPropertiesPtrOutput) ToCustomDomainPropertiesPtrOutput() CustomDomainPropertiesPtrOutput {
	return o
}

func (o CustomDomainPropertiesPtrOutput) ToCustomDomainPropertiesPtrOutputWithContext(ctx context.Context) CustomDomainPropertiesPtrOutput {
	return o
}

func (o CustomDomainPropertiesPtrOutput) Elem() CustomDomainPropertiesOutput {
	return o.ApplyT(func(v *CustomDomainProperties) CustomDomainProperties { return *v }).(CustomDomainPropertiesOutput)
}

// The bound certificate name of domain.
func (o CustomDomainPropertiesPtrOutput) CertName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CustomDomainProperties) *string {
		if v == nil {
			return nil
		}
		return v.CertName
	}).(pulumi.StringPtrOutput)
}

// The thumbprint of bound certificate.
func (o CustomDomainPropertiesPtrOutput) Thumbprint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CustomDomainProperties) *string {
		if v == nil {
			return nil
		}
		return v.Thumbprint
	}).(pulumi.StringPtrOutput)
}

// Custom domain of app resource payload.
type CustomDomainPropertiesResponse struct {
	// The app name of domain.
	AppName string `pulumi:"appName"`
	// The bound certificate name of domain.
	CertName *string `pulumi:"certName"`
	// The thumbprint of bound certificate.
	Thumbprint *string `pulumi:"thumbprint"`
}

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

	ToCustomDomainPropertiesResponseOutput() CustomDomainPropertiesResponseOutput
	ToCustomDomainPropertiesResponseOutputWithContext(context.Context) CustomDomainPropertiesResponseOutput
}

// Custom domain of app resource payload.
type CustomDomainPropertiesResponseArgs struct {
	// The app name of domain.
	AppName pulumi.StringInput `pulumi:"appName"`
	// The bound certificate name of domain.
	CertName pulumi.StringPtrInput `pulumi:"certName"`
	// The thumbprint of bound certificate.
	Thumbprint pulumi.StringPtrInput `pulumi:"thumbprint"`
}

func (CustomDomainPropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*CustomDomainPropertiesResponse)(nil)).Elem()
}

func (i CustomDomainPropertiesResponseArgs) ToCustomDomainPropertiesResponseOutput() CustomDomainPropertiesResponseOutput {
	return i.ToCustomDomainPropertiesResponseOutputWithContext(context.Background())
}

func (i CustomDomainPropertiesResponseArgs) ToCustomDomainPropertiesResponseOutputWithContext(ctx context.Context) CustomDomainPropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CustomDomainPropertiesResponseOutput)
}

func (i CustomDomainPropertiesResponseArgs) ToCustomDomainPropertiesResponsePtrOutput() CustomDomainPropertiesResponsePtrOutput {
	return i.ToCustomDomainPropertiesResponsePtrOutputWithContext(context.Background())
}

func (i CustomDomainPropertiesResponseArgs) ToCustomDomainPropertiesResponsePtrOutputWithContext(ctx context.Context) CustomDomainPropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CustomDomainPropertiesResponseOutput).ToCustomDomainPropertiesResponsePtrOutputWithContext(ctx)
}

// CustomDomainPropertiesResponsePtrInput is an input type that accepts CustomDomainPropertiesResponseArgs, CustomDomainPropertiesResponsePtr and CustomDomainPropertiesResponsePtrOutput values.
// You can construct a concrete instance of `CustomDomainPropertiesResponsePtrInput` via:
//
//          CustomDomainPropertiesResponseArgs{...}
//
//  or:
//
//          nil
type CustomDomainPropertiesResponsePtrInput interface {
	pulumi.Input

	ToCustomDomainPropertiesResponsePtrOutput() CustomDomainPropertiesResponsePtrOutput
	ToCustomDomainPropertiesResponsePtrOutputWithContext(context.Context) CustomDomainPropertiesResponsePtrOutput
}

type customDomainPropertiesResponsePtrType CustomDomainPropertiesResponseArgs

func CustomDomainPropertiesResponsePtr(v *CustomDomainPropertiesResponseArgs) CustomDomainPropertiesResponsePtrInput {
	return (*customDomainPropertiesResponsePtrType)(v)
}

func (*customDomainPropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**CustomDomainPropertiesResponse)(nil)).Elem()
}

func (i *customDomainPropertiesResponsePtrType) ToCustomDomainPropertiesResponsePtrOutput() CustomDomainPropertiesResponsePtrOutput {
	return i.ToCustomDomainPropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *customDomainPropertiesResponsePtrType) ToCustomDomainPropertiesResponsePtrOutputWithContext(ctx context.Context) CustomDomainPropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CustomDomainPropertiesResponsePtrOutput)
}

// Custom domain of app resource payload.
type CustomDomainPropertiesResponseOutput struct{ *pulumi.OutputState }

func (CustomDomainPropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CustomDomainPropertiesResponse)(nil)).Elem()
}

func (o CustomDomainPropertiesResponseOutput) ToCustomDomainPropertiesResponseOutput() CustomDomainPropertiesResponseOutput {
	return o
}

func (o CustomDomainPropertiesResponseOutput) ToCustomDomainPropertiesResponseOutputWithContext(ctx context.Context) CustomDomainPropertiesResponseOutput {
	return o
}

func (o CustomDomainPropertiesResponseOutput) ToCustomDomainPropertiesResponsePtrOutput() CustomDomainPropertiesResponsePtrOutput {
	return o.ToCustomDomainPropertiesResponsePtrOutputWithContext(context.Background())
}

func (o CustomDomainPropertiesResponseOutput) ToCustomDomainPropertiesResponsePtrOutputWithContext(ctx context.Context) CustomDomainPropertiesResponsePtrOutput {
	return o.ApplyT(func(v CustomDomainPropertiesResponse) *CustomDomainPropertiesResponse {
		return &v
	}).(CustomDomainPropertiesResponsePtrOutput)
}

// The app name of domain.
func (o CustomDomainPropertiesResponseOutput) AppName() pulumi.StringOutput {
	return o.ApplyT(func(v CustomDomainPropertiesResponse) string { return v.AppName }).(pulumi.StringOutput)
}

// The bound certificate name of domain.
func (o CustomDomainPropertiesResponseOutput) CertName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CustomDomainPropertiesResponse) *string { return v.CertName }).(pulumi.StringPtrOutput)
}

// The thumbprint of bound certificate.
func (o CustomDomainPropertiesResponseOutput) Thumbprint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CustomDomainPropertiesResponse) *string { return v.Thumbprint }).(pulumi.StringPtrOutput)
}

type CustomDomainPropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (CustomDomainPropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**CustomDomainPropertiesResponse)(nil)).Elem()
}

func (o CustomDomainPropertiesResponsePtrOutput) ToCustomDomainPropertiesResponsePtrOutput() CustomDomainPropertiesResponsePtrOutput {
	return o
}

func (o CustomDomainPropertiesResponsePtrOutput) ToCustomDomainPropertiesResponsePtrOutputWithContext(ctx context.Context) CustomDomainPropertiesResponsePtrOutput {
	return o
}

func (o CustomDomainPropertiesResponsePtrOutput) Elem() CustomDomainPropertiesResponseOutput {
	return o.ApplyT(func(v *CustomDomainPropertiesResponse) CustomDomainPropertiesResponse { return *v }).(CustomDomainPropertiesResponseOutput)
}

// The app name of domain.
func (o CustomDomainPropertiesResponsePtrOutput) AppName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CustomDomainPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.AppName
	}).(pulumi.StringPtrOutput)
}

// The bound certificate name of domain.
func (o CustomDomainPropertiesResponsePtrOutput) CertName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CustomDomainPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.CertName
	}).(pulumi.StringPtrOutput)
}

// The thumbprint of bound certificate.
func (o CustomDomainPropertiesResponsePtrOutput) Thumbprint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CustomDomainPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.Thumbprint
	}).(pulumi.StringPtrOutput)
}

// Deployment instance payload
type DeploymentInstanceResponse struct {
	// Discovery status of the deployment instance
	DiscoveryStatus string `pulumi:"discoveryStatus"`
	// Name of the deployment instance
	Name string `pulumi:"name"`
	// Failed reason of the deployment instance
	Reason string `pulumi:"reason"`
	// Start time of the deployment instance
	StartTime string `pulumi:"startTime"`
	// Status of the deployment instance
	Status string `pulumi:"status"`
}

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

	ToDeploymentInstanceResponseOutput() DeploymentInstanceResponseOutput
	ToDeploymentInstanceResponseOutputWithContext(context.Context) DeploymentInstanceResponseOutput
}

// Deployment instance payload
type DeploymentInstanceResponseArgs struct {
	// Discovery status of the deployment instance
	DiscoveryStatus pulumi.StringInput `pulumi:"discoveryStatus"`
	// Name of the deployment instance
	Name pulumi.StringInput `pulumi:"name"`
	// Failed reason of the deployment instance
	Reason pulumi.StringInput `pulumi:"reason"`
	// Start time of the deployment instance
	StartTime pulumi.StringInput `pulumi:"startTime"`
	// Status of the deployment instance
	Status pulumi.StringInput `pulumi:"status"`
}

func (DeploymentInstanceResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentInstanceResponse)(nil)).Elem()
}

func (i DeploymentInstanceResponseArgs) ToDeploymentInstanceResponseOutput() DeploymentInstanceResponseOutput {
	return i.ToDeploymentInstanceResponseOutputWithContext(context.Background())
}

func (i DeploymentInstanceResponseArgs) ToDeploymentInstanceResponseOutputWithContext(ctx context.Context) DeploymentInstanceResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentInstanceResponseOutput)
}

// DeploymentInstanceResponseArrayInput is an input type that accepts DeploymentInstanceResponseArray and DeploymentInstanceResponseArrayOutput values.
// You can construct a concrete instance of `DeploymentInstanceResponseArrayInput` via:
//
//          DeploymentInstanceResponseArray{ DeploymentInstanceResponseArgs{...} }
type DeploymentInstanceResponseArrayInput interface {
	pulumi.Input

	ToDeploymentInstanceResponseArrayOutput() DeploymentInstanceResponseArrayOutput
	ToDeploymentInstanceResponseArrayOutputWithContext(context.Context) DeploymentInstanceResponseArrayOutput
}

type DeploymentInstanceResponseArray []DeploymentInstanceResponseInput

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

func (i DeploymentInstanceResponseArray) ToDeploymentInstanceResponseArrayOutput() DeploymentInstanceResponseArrayOutput {
	return i.ToDeploymentInstanceResponseArrayOutputWithContext(context.Background())
}

func (i DeploymentInstanceResponseArray) ToDeploymentInstanceResponseArrayOutputWithContext(ctx context.Context) DeploymentInstanceResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentInstanceResponseArrayOutput)
}

// Deployment instance payload
type DeploymentInstanceResponseOutput struct{ *pulumi.OutputState }

func (DeploymentInstanceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentInstanceResponse)(nil)).Elem()
}

func (o DeploymentInstanceResponseOutput) ToDeploymentInstanceResponseOutput() DeploymentInstanceResponseOutput {
	return o
}

func (o DeploymentInstanceResponseOutput) ToDeploymentInstanceResponseOutputWithContext(ctx context.Context) DeploymentInstanceResponseOutput {
	return o
}

// Discovery status of the deployment instance
func (o DeploymentInstanceResponseOutput) DiscoveryStatus() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentInstanceResponse) string { return v.DiscoveryStatus }).(pulumi.StringOutput)
}

// Name of the deployment instance
func (o DeploymentInstanceResponseOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentInstanceResponse) string { return v.Name }).(pulumi.StringOutput)
}

// Failed reason of the deployment instance
func (o DeploymentInstanceResponseOutput) Reason() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentInstanceResponse) string { return v.Reason }).(pulumi.StringOutput)
}

// Start time of the deployment instance
func (o DeploymentInstanceResponseOutput) StartTime() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentInstanceResponse) string { return v.StartTime }).(pulumi.StringOutput)
}

// Status of the deployment instance
func (o DeploymentInstanceResponseOutput) Status() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentInstanceResponse) string { return v.Status }).(pulumi.StringOutput)
}

type DeploymentInstanceResponseArrayOutput struct{ *pulumi.OutputState }

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

func (o DeploymentInstanceResponseArrayOutput) ToDeploymentInstanceResponseArrayOutput() DeploymentInstanceResponseArrayOutput {
	return o
}

func (o DeploymentInstanceResponseArrayOutput) ToDeploymentInstanceResponseArrayOutputWithContext(ctx context.Context) DeploymentInstanceResponseArrayOutput {
	return o
}

func (o DeploymentInstanceResponseArrayOutput) Index(i pulumi.IntInput) DeploymentInstanceResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) DeploymentInstanceResponse {
		return vs[0].([]DeploymentInstanceResponse)[vs[1].(int)]
	}).(DeploymentInstanceResponseOutput)
}

// Deployment resource properties payload
type DeploymentResourceProperties struct {
	// Deployment settings of the Deployment
	DeploymentSettings *DeploymentSettings `pulumi:"deploymentSettings"`
	// Uploaded source information of the deployment.
	Source *UserSourceInfo `pulumi:"source"`
}

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

	ToDeploymentResourcePropertiesOutput() DeploymentResourcePropertiesOutput
	ToDeploymentResourcePropertiesOutputWithContext(context.Context) DeploymentResourcePropertiesOutput
}

// Deployment resource properties payload
type DeploymentResourcePropertiesArgs struct {
	// Deployment settings of the Deployment
	DeploymentSettings DeploymentSettingsPtrInput `pulumi:"deploymentSettings"`
	// Uploaded source information of the deployment.
	Source UserSourceInfoPtrInput `pulumi:"source"`
}

func (DeploymentResourcePropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentResourceProperties)(nil)).Elem()
}

func (i DeploymentResourcePropertiesArgs) ToDeploymentResourcePropertiesOutput() DeploymentResourcePropertiesOutput {
	return i.ToDeploymentResourcePropertiesOutputWithContext(context.Background())
}

func (i DeploymentResourcePropertiesArgs) ToDeploymentResourcePropertiesOutputWithContext(ctx context.Context) DeploymentResourcePropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentResourcePropertiesOutput)
}

func (i DeploymentResourcePropertiesArgs) ToDeploymentResourcePropertiesPtrOutput() DeploymentResourcePropertiesPtrOutput {
	return i.ToDeploymentResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i DeploymentResourcePropertiesArgs) ToDeploymentResourcePropertiesPtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentResourcePropertiesOutput).ToDeploymentResourcePropertiesPtrOutputWithContext(ctx)
}

// DeploymentResourcePropertiesPtrInput is an input type that accepts DeploymentResourcePropertiesArgs, DeploymentResourcePropertiesPtr and DeploymentResourcePropertiesPtrOutput values.
// You can construct a concrete instance of `DeploymentResourcePropertiesPtrInput` via:
//
//          DeploymentResourcePropertiesArgs{...}
//
//  or:
//
//          nil
type DeploymentResourcePropertiesPtrInput interface {
	pulumi.Input

	ToDeploymentResourcePropertiesPtrOutput() DeploymentResourcePropertiesPtrOutput
	ToDeploymentResourcePropertiesPtrOutputWithContext(context.Context) DeploymentResourcePropertiesPtrOutput
}

type deploymentResourcePropertiesPtrType DeploymentResourcePropertiesArgs

func DeploymentResourcePropertiesPtr(v *DeploymentResourcePropertiesArgs) DeploymentResourcePropertiesPtrInput {
	return (*deploymentResourcePropertiesPtrType)(v)
}

func (*deploymentResourcePropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentResourceProperties)(nil)).Elem()
}

func (i *deploymentResourcePropertiesPtrType) ToDeploymentResourcePropertiesPtrOutput() DeploymentResourcePropertiesPtrOutput {
	return i.ToDeploymentResourcePropertiesPtrOutputWithContext(context.Background())
}

func (i *deploymentResourcePropertiesPtrType) ToDeploymentResourcePropertiesPtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentResourcePropertiesPtrOutput)
}

// Deployment resource properties payload
type DeploymentResourcePropertiesOutput struct{ *pulumi.OutputState }

func (DeploymentResourcePropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentResourceProperties)(nil)).Elem()
}

func (o DeploymentResourcePropertiesOutput) ToDeploymentResourcePropertiesOutput() DeploymentResourcePropertiesOutput {
	return o
}

func (o DeploymentResourcePropertiesOutput) ToDeploymentResourcePropertiesOutputWithContext(ctx context.Context) DeploymentResourcePropertiesOutput {
	return o
}

func (o DeploymentResourcePropertiesOutput) ToDeploymentResourcePropertiesPtrOutput() DeploymentResourcePropertiesPtrOutput {
	return o.ToDeploymentResourcePropertiesPtrOutputWithContext(context.Background())
}

func (o DeploymentResourcePropertiesOutput) ToDeploymentResourcePropertiesPtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesPtrOutput {
	return o.ApplyT(func(v DeploymentResourceProperties) *DeploymentResourceProperties {
		return &v
	}).(DeploymentResourcePropertiesPtrOutput)
}

// Deployment settings of the Deployment
func (o DeploymentResourcePropertiesOutput) DeploymentSettings() DeploymentSettingsPtrOutput {
	return o.ApplyT(func(v DeploymentResourceProperties) *DeploymentSettings { return v.DeploymentSettings }).(DeploymentSettingsPtrOutput)
}

// Uploaded source information of the deployment.
func (o DeploymentResourcePropertiesOutput) Source() UserSourceInfoPtrOutput {
	return o.ApplyT(func(v DeploymentResourceProperties) *UserSourceInfo { return v.Source }).(UserSourceInfoPtrOutput)
}

type DeploymentResourcePropertiesPtrOutput struct{ *pulumi.OutputState }

func (DeploymentResourcePropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentResourceProperties)(nil)).Elem()
}

func (o DeploymentResourcePropertiesPtrOutput) ToDeploymentResourcePropertiesPtrOutput() DeploymentResourcePropertiesPtrOutput {
	return o
}

func (o DeploymentResourcePropertiesPtrOutput) ToDeploymentResourcePropertiesPtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesPtrOutput {
	return o
}

func (o DeploymentResourcePropertiesPtrOutput) Elem() DeploymentResourcePropertiesOutput {
	return o.ApplyT(func(v *DeploymentResourceProperties) DeploymentResourceProperties { return *v }).(DeploymentResourcePropertiesOutput)
}

// Deployment settings of the Deployment
func (o DeploymentResourcePropertiesPtrOutput) DeploymentSettings() DeploymentSettingsPtrOutput {
	return o.ApplyT(func(v *DeploymentResourceProperties) *DeploymentSettings {
		if v == nil {
			return nil
		}
		return v.DeploymentSettings
	}).(DeploymentSettingsPtrOutput)
}

// Uploaded source information of the deployment.
func (o DeploymentResourcePropertiesPtrOutput) Source() UserSourceInfoPtrOutput {
	return o.ApplyT(func(v *DeploymentResourceProperties) *UserSourceInfo {
		if v == nil {
			return nil
		}
		return v.Source
	}).(UserSourceInfoPtrOutput)
}

// Deployment resource properties payload
type DeploymentResourcePropertiesResponse struct {
	// Indicates whether the Deployment is active
	Active bool `pulumi:"active"`
	// App name of the deployment
	AppName string `pulumi:"appName"`
	// Date time when the resource is created
	CreatedTime string `pulumi:"createdTime"`
	// Deployment settings of the Deployment
	DeploymentSettings *DeploymentSettingsResponse `pulumi:"deploymentSettings"`
	// Collection of instances belong to the Deployment
	Instances []DeploymentInstanceResponse `pulumi:"instances"`
	// Provisioning state of the Deployment
	ProvisioningState string `pulumi:"provisioningState"`
	// Uploaded source information of the deployment.
	Source *UserSourceInfoResponse `pulumi:"source"`
	// Status of the Deployment
	Status string `pulumi:"status"`
}

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

	ToDeploymentResourcePropertiesResponseOutput() DeploymentResourcePropertiesResponseOutput
	ToDeploymentResourcePropertiesResponseOutputWithContext(context.Context) DeploymentResourcePropertiesResponseOutput
}

// Deployment resource properties payload
type DeploymentResourcePropertiesResponseArgs struct {
	// Indicates whether the Deployment is active
	Active pulumi.BoolInput `pulumi:"active"`
	// App name of the deployment
	AppName pulumi.StringInput `pulumi:"appName"`
	// Date time when the resource is created
	CreatedTime pulumi.StringInput `pulumi:"createdTime"`
	// Deployment settings of the Deployment
	DeploymentSettings DeploymentSettingsResponsePtrInput `pulumi:"deploymentSettings"`
	// Collection of instances belong to the Deployment
	Instances DeploymentInstanceResponseArrayInput `pulumi:"instances"`
	// Provisioning state of the Deployment
	ProvisioningState pulumi.StringInput `pulumi:"provisioningState"`
	// Uploaded source information of the deployment.
	Source UserSourceInfoResponsePtrInput `pulumi:"source"`
	// Status of the Deployment
	Status pulumi.StringInput `pulumi:"status"`
}

func (DeploymentResourcePropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentResourcePropertiesResponse)(nil)).Elem()
}

func (i DeploymentResourcePropertiesResponseArgs) ToDeploymentResourcePropertiesResponseOutput() DeploymentResourcePropertiesResponseOutput {
	return i.ToDeploymentResourcePropertiesResponseOutputWithContext(context.Background())
}

func (i DeploymentResourcePropertiesResponseArgs) ToDeploymentResourcePropertiesResponseOutputWithContext(ctx context.Context) DeploymentResourcePropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentResourcePropertiesResponseOutput)
}

func (i DeploymentResourcePropertiesResponseArgs) ToDeploymentResourcePropertiesResponsePtrOutput() DeploymentResourcePropertiesResponsePtrOutput {
	return i.ToDeploymentResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i DeploymentResourcePropertiesResponseArgs) ToDeploymentResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentResourcePropertiesResponseOutput).ToDeploymentResourcePropertiesResponsePtrOutputWithContext(ctx)
}

// DeploymentResourcePropertiesResponsePtrInput is an input type that accepts DeploymentResourcePropertiesResponseArgs, DeploymentResourcePropertiesResponsePtr and DeploymentResourcePropertiesResponsePtrOutput values.
// You can construct a concrete instance of `DeploymentResourcePropertiesResponsePtrInput` via:
//
//          DeploymentResourcePropertiesResponseArgs{...}
//
//  or:
//
//          nil
type DeploymentResourcePropertiesResponsePtrInput interface {
	pulumi.Input

	ToDeploymentResourcePropertiesResponsePtrOutput() DeploymentResourcePropertiesResponsePtrOutput
	ToDeploymentResourcePropertiesResponsePtrOutputWithContext(context.Context) DeploymentResourcePropertiesResponsePtrOutput
}

type deploymentResourcePropertiesResponsePtrType DeploymentResourcePropertiesResponseArgs

func DeploymentResourcePropertiesResponsePtr(v *DeploymentResourcePropertiesResponseArgs) DeploymentResourcePropertiesResponsePtrInput {
	return (*deploymentResourcePropertiesResponsePtrType)(v)
}

func (*deploymentResourcePropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentResourcePropertiesResponse)(nil)).Elem()
}

func (i *deploymentResourcePropertiesResponsePtrType) ToDeploymentResourcePropertiesResponsePtrOutput() DeploymentResourcePropertiesResponsePtrOutput {
	return i.ToDeploymentResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *deploymentResourcePropertiesResponsePtrType) ToDeploymentResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentResourcePropertiesResponsePtrOutput)
}

// Deployment resource properties payload
type DeploymentResourcePropertiesResponseOutput struct{ *pulumi.OutputState }

func (DeploymentResourcePropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentResourcePropertiesResponse)(nil)).Elem()
}

func (o DeploymentResourcePropertiesResponseOutput) ToDeploymentResourcePropertiesResponseOutput() DeploymentResourcePropertiesResponseOutput {
	return o
}

func (o DeploymentResourcePropertiesResponseOutput) ToDeploymentResourcePropertiesResponseOutputWithContext(ctx context.Context) DeploymentResourcePropertiesResponseOutput {
	return o
}

func (o DeploymentResourcePropertiesResponseOutput) ToDeploymentResourcePropertiesResponsePtrOutput() DeploymentResourcePropertiesResponsePtrOutput {
	return o.ToDeploymentResourcePropertiesResponsePtrOutputWithContext(context.Background())
}

func (o DeploymentResourcePropertiesResponseOutput) ToDeploymentResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesResponsePtrOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) *DeploymentResourcePropertiesResponse {
		return &v
	}).(DeploymentResourcePropertiesResponsePtrOutput)
}

// Indicates whether the Deployment is active
func (o DeploymentResourcePropertiesResponseOutput) Active() pulumi.BoolOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) bool { return v.Active }).(pulumi.BoolOutput)
}

// App name of the deployment
func (o DeploymentResourcePropertiesResponseOutput) AppName() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) string { return v.AppName }).(pulumi.StringOutput)
}

// Date time when the resource is created
func (o DeploymentResourcePropertiesResponseOutput) CreatedTime() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) string { return v.CreatedTime }).(pulumi.StringOutput)
}

// Deployment settings of the Deployment
func (o DeploymentResourcePropertiesResponseOutput) DeploymentSettings() DeploymentSettingsResponsePtrOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) *DeploymentSettingsResponse { return v.DeploymentSettings }).(DeploymentSettingsResponsePtrOutput)
}

// Collection of instances belong to the Deployment
func (o DeploymentResourcePropertiesResponseOutput) Instances() DeploymentInstanceResponseArrayOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) []DeploymentInstanceResponse { return v.Instances }).(DeploymentInstanceResponseArrayOutput)
}

// Provisioning state of the Deployment
func (o DeploymentResourcePropertiesResponseOutput) ProvisioningState() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) string { return v.ProvisioningState }).(pulumi.StringOutput)
}

// Uploaded source information of the deployment.
func (o DeploymentResourcePropertiesResponseOutput) Source() UserSourceInfoResponsePtrOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) *UserSourceInfoResponse { return v.Source }).(UserSourceInfoResponsePtrOutput)
}

// Status of the Deployment
func (o DeploymentResourcePropertiesResponseOutput) Status() pulumi.StringOutput {
	return o.ApplyT(func(v DeploymentResourcePropertiesResponse) string { return v.Status }).(pulumi.StringOutput)
}

type DeploymentResourcePropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (DeploymentResourcePropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentResourcePropertiesResponse)(nil)).Elem()
}

func (o DeploymentResourcePropertiesResponsePtrOutput) ToDeploymentResourcePropertiesResponsePtrOutput() DeploymentResourcePropertiesResponsePtrOutput {
	return o
}

func (o DeploymentResourcePropertiesResponsePtrOutput) ToDeploymentResourcePropertiesResponsePtrOutputWithContext(ctx context.Context) DeploymentResourcePropertiesResponsePtrOutput {
	return o
}

func (o DeploymentResourcePropertiesResponsePtrOutput) Elem() DeploymentResourcePropertiesResponseOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) DeploymentResourcePropertiesResponse { return *v }).(DeploymentResourcePropertiesResponseOutput)
}

// Indicates whether the Deployment is active
func (o DeploymentResourcePropertiesResponsePtrOutput) Active() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *bool {
		if v == nil {
			return nil
		}
		return &v.Active
	}).(pulumi.BoolPtrOutput)
}

// App name of the deployment
func (o DeploymentResourcePropertiesResponsePtrOutput) AppName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.AppName
	}).(pulumi.StringPtrOutput)
}

// Date time when the resource is created
func (o DeploymentResourcePropertiesResponsePtrOutput) CreatedTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.CreatedTime
	}).(pulumi.StringPtrOutput)
}

// Deployment settings of the Deployment
func (o DeploymentResourcePropertiesResponsePtrOutput) DeploymentSettings() DeploymentSettingsResponsePtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *DeploymentSettingsResponse {
		if v == nil {
			return nil
		}
		return v.DeploymentSettings
	}).(DeploymentSettingsResponsePtrOutput)
}

// Collection of instances belong to the Deployment
func (o DeploymentResourcePropertiesResponsePtrOutput) Instances() DeploymentInstanceResponseArrayOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) []DeploymentInstanceResponse {
		if v == nil {
			return nil
		}
		return v.Instances
	}).(DeploymentInstanceResponseArrayOutput)
}

// Provisioning state of the Deployment
func (o DeploymentResourcePropertiesResponsePtrOutput) ProvisioningState() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.ProvisioningState
	}).(pulumi.StringPtrOutput)
}

// Uploaded source information of the deployment.
func (o DeploymentResourcePropertiesResponsePtrOutput) Source() UserSourceInfoResponsePtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *UserSourceInfoResponse {
		if v == nil {
			return nil
		}
		return v.Source
	}).(UserSourceInfoResponsePtrOutput)
}

// Status of the Deployment
func (o DeploymentResourcePropertiesResponsePtrOutput) Status() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentResourcePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return &v.Status
	}).(pulumi.StringPtrOutput)
}

// Deployment settings payload
type DeploymentSettings struct {
	// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
	Cpu *int `pulumi:"cpu"`
	// Collection of environment variables
	EnvironmentVariables map[string]string `pulumi:"environmentVariables"`
	// JVM parameter
	JvmOptions *string `pulumi:"jvmOptions"`
	// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
	MemoryInGB *int `pulumi:"memoryInGB"`
	// The path to the .NET executable relative to zip root
	NetCoreMainEntryPath *string `pulumi:"netCoreMainEntryPath"`
	// Runtime version
	RuntimeVersion *string `pulumi:"runtimeVersion"`
}

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

	ToDeploymentSettingsOutput() DeploymentSettingsOutput
	ToDeploymentSettingsOutputWithContext(context.Context) DeploymentSettingsOutput
}

// Deployment settings payload
type DeploymentSettingsArgs struct {
	// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
	Cpu pulumi.IntPtrInput `pulumi:"cpu"`
	// Collection of environment variables
	EnvironmentVariables pulumi.StringMapInput `pulumi:"environmentVariables"`
	// JVM parameter
	JvmOptions pulumi.StringPtrInput `pulumi:"jvmOptions"`
	// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
	MemoryInGB pulumi.IntPtrInput `pulumi:"memoryInGB"`
	// The path to the .NET executable relative to zip root
	NetCoreMainEntryPath pulumi.StringPtrInput `pulumi:"netCoreMainEntryPath"`
	// Runtime version
	RuntimeVersion pulumi.StringPtrInput `pulumi:"runtimeVersion"`
}

func (DeploymentSettingsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentSettings)(nil)).Elem()
}

func (i DeploymentSettingsArgs) ToDeploymentSettingsOutput() DeploymentSettingsOutput {
	return i.ToDeploymentSettingsOutputWithContext(context.Background())
}

func (i DeploymentSettingsArgs) ToDeploymentSettingsOutputWithContext(ctx context.Context) DeploymentSettingsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentSettingsOutput)
}

func (i DeploymentSettingsArgs) ToDeploymentSettingsPtrOutput() DeploymentSettingsPtrOutput {
	return i.ToDeploymentSettingsPtrOutputWithContext(context.Background())
}

func (i DeploymentSettingsArgs) ToDeploymentSettingsPtrOutputWithContext(ctx context.Context) DeploymentSettingsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentSettingsOutput).ToDeploymentSettingsPtrOutputWithContext(ctx)
}

// DeploymentSettingsPtrInput is an input type that accepts DeploymentSettingsArgs, DeploymentSettingsPtr and DeploymentSettingsPtrOutput values.
// You can construct a concrete instance of `DeploymentSettingsPtrInput` via:
//
//          DeploymentSettingsArgs{...}
//
//  or:
//
//          nil
type DeploymentSettingsPtrInput interface {
	pulumi.Input

	ToDeploymentSettingsPtrOutput() DeploymentSettingsPtrOutput
	ToDeploymentSettingsPtrOutputWithContext(context.Context) DeploymentSettingsPtrOutput
}

type deploymentSettingsPtrType DeploymentSettingsArgs

func DeploymentSettingsPtr(v *DeploymentSettingsArgs) DeploymentSettingsPtrInput {
	return (*deploymentSettingsPtrType)(v)
}

func (*deploymentSettingsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentSettings)(nil)).Elem()
}

func (i *deploymentSettingsPtrType) ToDeploymentSettingsPtrOutput() DeploymentSettingsPtrOutput {
	return i.ToDeploymentSettingsPtrOutputWithContext(context.Background())
}

func (i *deploymentSettingsPtrType) ToDeploymentSettingsPtrOutputWithContext(ctx context.Context) DeploymentSettingsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentSettingsPtrOutput)
}

// Deployment settings payload
type DeploymentSettingsOutput struct{ *pulumi.OutputState }

func (DeploymentSettingsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentSettings)(nil)).Elem()
}

func (o DeploymentSettingsOutput) ToDeploymentSettingsOutput() DeploymentSettingsOutput {
	return o
}

func (o DeploymentSettingsOutput) ToDeploymentSettingsOutputWithContext(ctx context.Context) DeploymentSettingsOutput {
	return o
}

func (o DeploymentSettingsOutput) ToDeploymentSettingsPtrOutput() DeploymentSettingsPtrOutput {
	return o.ToDeploymentSettingsPtrOutputWithContext(context.Background())
}

func (o DeploymentSettingsOutput) ToDeploymentSettingsPtrOutputWithContext(ctx context.Context) DeploymentSettingsPtrOutput {
	return o.ApplyT(func(v DeploymentSettings) *DeploymentSettings {
		return &v
	}).(DeploymentSettingsPtrOutput)
}

// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
func (o DeploymentSettingsOutput) Cpu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v DeploymentSettings) *int { return v.Cpu }).(pulumi.IntPtrOutput)
}

// Collection of environment variables
func (o DeploymentSettingsOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v DeploymentSettings) map[string]string { return v.EnvironmentVariables }).(pulumi.StringMapOutput)
}

// JVM parameter
func (o DeploymentSettingsOutput) JvmOptions() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentSettings) *string { return v.JvmOptions }).(pulumi.StringPtrOutput)
}

// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
func (o DeploymentSettingsOutput) MemoryInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v DeploymentSettings) *int { return v.MemoryInGB }).(pulumi.IntPtrOutput)
}

// The path to the .NET executable relative to zip root
func (o DeploymentSettingsOutput) NetCoreMainEntryPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentSettings) *string { return v.NetCoreMainEntryPath }).(pulumi.StringPtrOutput)
}

// Runtime version
func (o DeploymentSettingsOutput) RuntimeVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentSettings) *string { return v.RuntimeVersion }).(pulumi.StringPtrOutput)
}

type DeploymentSettingsPtrOutput struct{ *pulumi.OutputState }

func (DeploymentSettingsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentSettings)(nil)).Elem()
}

func (o DeploymentSettingsPtrOutput) ToDeploymentSettingsPtrOutput() DeploymentSettingsPtrOutput {
	return o
}

func (o DeploymentSettingsPtrOutput) ToDeploymentSettingsPtrOutputWithContext(ctx context.Context) DeploymentSettingsPtrOutput {
	return o
}

func (o DeploymentSettingsPtrOutput) Elem() DeploymentSettingsOutput {
	return o.ApplyT(func(v *DeploymentSettings) DeploymentSettings { return *v }).(DeploymentSettingsOutput)
}

// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
func (o DeploymentSettingsPtrOutput) Cpu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *DeploymentSettings) *int {
		if v == nil {
			return nil
		}
		return v.Cpu
	}).(pulumi.IntPtrOutput)
}

// Collection of environment variables
func (o DeploymentSettingsPtrOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v *DeploymentSettings) map[string]string {
		if v == nil {
			return nil
		}
		return v.EnvironmentVariables
	}).(pulumi.StringMapOutput)
}

// JVM parameter
func (o DeploymentSettingsPtrOutput) JvmOptions() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentSettings) *string {
		if v == nil {
			return nil
		}
		return v.JvmOptions
	}).(pulumi.StringPtrOutput)
}

// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
func (o DeploymentSettingsPtrOutput) MemoryInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *DeploymentSettings) *int {
		if v == nil {
			return nil
		}
		return v.MemoryInGB
	}).(pulumi.IntPtrOutput)
}

// The path to the .NET executable relative to zip root
func (o DeploymentSettingsPtrOutput) NetCoreMainEntryPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentSettings) *string {
		if v == nil {
			return nil
		}
		return v.NetCoreMainEntryPath
	}).(pulumi.StringPtrOutput)
}

// Runtime version
func (o DeploymentSettingsPtrOutput) RuntimeVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentSettings) *string {
		if v == nil {
			return nil
		}
		return v.RuntimeVersion
	}).(pulumi.StringPtrOutput)
}

// Deployment settings payload
type DeploymentSettingsResponse struct {
	// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
	Cpu *int `pulumi:"cpu"`
	// Collection of environment variables
	EnvironmentVariables map[string]string `pulumi:"environmentVariables"`
	// JVM parameter
	JvmOptions *string `pulumi:"jvmOptions"`
	// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
	MemoryInGB *int `pulumi:"memoryInGB"`
	// The path to the .NET executable relative to zip root
	NetCoreMainEntryPath *string `pulumi:"netCoreMainEntryPath"`
	// Runtime version
	RuntimeVersion *string `pulumi:"runtimeVersion"`
}

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

	ToDeploymentSettingsResponseOutput() DeploymentSettingsResponseOutput
	ToDeploymentSettingsResponseOutputWithContext(context.Context) DeploymentSettingsResponseOutput
}

// Deployment settings payload
type DeploymentSettingsResponseArgs struct {
	// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
	Cpu pulumi.IntPtrInput `pulumi:"cpu"`
	// Collection of environment variables
	EnvironmentVariables pulumi.StringMapInput `pulumi:"environmentVariables"`
	// JVM parameter
	JvmOptions pulumi.StringPtrInput `pulumi:"jvmOptions"`
	// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
	MemoryInGB pulumi.IntPtrInput `pulumi:"memoryInGB"`
	// The path to the .NET executable relative to zip root
	NetCoreMainEntryPath pulumi.StringPtrInput `pulumi:"netCoreMainEntryPath"`
	// Runtime version
	RuntimeVersion pulumi.StringPtrInput `pulumi:"runtimeVersion"`
}

func (DeploymentSettingsResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentSettingsResponse)(nil)).Elem()
}

func (i DeploymentSettingsResponseArgs) ToDeploymentSettingsResponseOutput() DeploymentSettingsResponseOutput {
	return i.ToDeploymentSettingsResponseOutputWithContext(context.Background())
}

func (i DeploymentSettingsResponseArgs) ToDeploymentSettingsResponseOutputWithContext(ctx context.Context) DeploymentSettingsResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentSettingsResponseOutput)
}

func (i DeploymentSettingsResponseArgs) ToDeploymentSettingsResponsePtrOutput() DeploymentSettingsResponsePtrOutput {
	return i.ToDeploymentSettingsResponsePtrOutputWithContext(context.Background())
}

func (i DeploymentSettingsResponseArgs) ToDeploymentSettingsResponsePtrOutputWithContext(ctx context.Context) DeploymentSettingsResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentSettingsResponseOutput).ToDeploymentSettingsResponsePtrOutputWithContext(ctx)
}

// DeploymentSettingsResponsePtrInput is an input type that accepts DeploymentSettingsResponseArgs, DeploymentSettingsResponsePtr and DeploymentSettingsResponsePtrOutput values.
// You can construct a concrete instance of `DeploymentSettingsResponsePtrInput` via:
//
//          DeploymentSettingsResponseArgs{...}
//
//  or:
//
//          nil
type DeploymentSettingsResponsePtrInput interface {
	pulumi.Input

	ToDeploymentSettingsResponsePtrOutput() DeploymentSettingsResponsePtrOutput
	ToDeploymentSettingsResponsePtrOutputWithContext(context.Context) DeploymentSettingsResponsePtrOutput
}

type deploymentSettingsResponsePtrType DeploymentSettingsResponseArgs

func DeploymentSettingsResponsePtr(v *DeploymentSettingsResponseArgs) DeploymentSettingsResponsePtrInput {
	return (*deploymentSettingsResponsePtrType)(v)
}

func (*deploymentSettingsResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentSettingsResponse)(nil)).Elem()
}

func (i *deploymentSettingsResponsePtrType) ToDeploymentSettingsResponsePtrOutput() DeploymentSettingsResponsePtrOutput {
	return i.ToDeploymentSettingsResponsePtrOutputWithContext(context.Background())
}

func (i *deploymentSettingsResponsePtrType) ToDeploymentSettingsResponsePtrOutputWithContext(ctx context.Context) DeploymentSettingsResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DeploymentSettingsResponsePtrOutput)
}

// Deployment settings payload
type DeploymentSettingsResponseOutput struct{ *pulumi.OutputState }

func (DeploymentSettingsResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DeploymentSettingsResponse)(nil)).Elem()
}

func (o DeploymentSettingsResponseOutput) ToDeploymentSettingsResponseOutput() DeploymentSettingsResponseOutput {
	return o
}

func (o DeploymentSettingsResponseOutput) ToDeploymentSettingsResponseOutputWithContext(ctx context.Context) DeploymentSettingsResponseOutput {
	return o
}

func (o DeploymentSettingsResponseOutput) ToDeploymentSettingsResponsePtrOutput() DeploymentSettingsResponsePtrOutput {
	return o.ToDeploymentSettingsResponsePtrOutputWithContext(context.Background())
}

func (o DeploymentSettingsResponseOutput) ToDeploymentSettingsResponsePtrOutputWithContext(ctx context.Context) DeploymentSettingsResponsePtrOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) *DeploymentSettingsResponse {
		return &v
	}).(DeploymentSettingsResponsePtrOutput)
}

// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
func (o DeploymentSettingsResponseOutput) Cpu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) *int { return v.Cpu }).(pulumi.IntPtrOutput)
}

// Collection of environment variables
func (o DeploymentSettingsResponseOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) map[string]string { return v.EnvironmentVariables }).(pulumi.StringMapOutput)
}

// JVM parameter
func (o DeploymentSettingsResponseOutput) JvmOptions() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) *string { return v.JvmOptions }).(pulumi.StringPtrOutput)
}

// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
func (o DeploymentSettingsResponseOutput) MemoryInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) *int { return v.MemoryInGB }).(pulumi.IntPtrOutput)
}

// The path to the .NET executable relative to zip root
func (o DeploymentSettingsResponseOutput) NetCoreMainEntryPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) *string { return v.NetCoreMainEntryPath }).(pulumi.StringPtrOutput)
}

// Runtime version
func (o DeploymentSettingsResponseOutput) RuntimeVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DeploymentSettingsResponse) *string { return v.RuntimeVersion }).(pulumi.StringPtrOutput)
}

type DeploymentSettingsResponsePtrOutput struct{ *pulumi.OutputState }

func (DeploymentSettingsResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DeploymentSettingsResponse)(nil)).Elem()
}

func (o DeploymentSettingsResponsePtrOutput) ToDeploymentSettingsResponsePtrOutput() DeploymentSettingsResponsePtrOutput {
	return o
}

func (o DeploymentSettingsResponsePtrOutput) ToDeploymentSettingsResponsePtrOutputWithContext(ctx context.Context) DeploymentSettingsResponsePtrOutput {
	return o
}

func (o DeploymentSettingsResponsePtrOutput) Elem() DeploymentSettingsResponseOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) DeploymentSettingsResponse { return *v }).(DeploymentSettingsResponseOutput)
}

// Required CPU, basic tier should be 1, standard tier should be in range (1, 4)
func (o DeploymentSettingsResponsePtrOutput) Cpu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) *int {
		if v == nil {
			return nil
		}
		return v.Cpu
	}).(pulumi.IntPtrOutput)
}

// Collection of environment variables
func (o DeploymentSettingsResponsePtrOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) map[string]string {
		if v == nil {
			return nil
		}
		return v.EnvironmentVariables
	}).(pulumi.StringMapOutput)
}

// JVM parameter
func (o DeploymentSettingsResponsePtrOutput) JvmOptions() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) *string {
		if v == nil {
			return nil
		}
		return v.JvmOptions
	}).(pulumi.StringPtrOutput)
}

// Required Memory size in GB, basic tier should be in range (1, 2), standard tier should be in range (1, 8)
func (o DeploymentSettingsResponsePtrOutput) MemoryInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) *int {
		if v == nil {
			return nil
		}
		return v.MemoryInGB
	}).(pulumi.IntPtrOutput)
}

// The path to the .NET executable relative to zip root
func (o DeploymentSettingsResponsePtrOutput) NetCoreMainEntryPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) *string {
		if v == nil {
			return nil
		}
		return v.NetCoreMainEntryPath
	}).(pulumi.StringPtrOutput)
}

// Runtime version
func (o DeploymentSettingsResponsePtrOutput) RuntimeVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DeploymentSettingsResponse) *string {
		if v == nil {
			return nil
		}
		return v.RuntimeVersion
	}).(pulumi.StringPtrOutput)
}

// Managed identity properties retrieved from ARM request headers.
type ManagedIdentityProperties struct {
	// Principal Id
	PrincipalId *string `pulumi:"principalId"`
	// Tenant Id
	TenantId *string `pulumi:"tenantId"`
	// Type of the managed identity
	Type *string `pulumi:"type"`
}

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

	ToManagedIdentityPropertiesOutput() ManagedIdentityPropertiesOutput
	ToManagedIdentityPropertiesOutputWithContext(context.Context) ManagedIdentityPropertiesOutput
}

// Managed identity properties retrieved from ARM request headers.
type ManagedIdentityPropertiesArgs struct {
	// Principal Id
	PrincipalId pulumi.StringPtrInput `pulumi:"principalId"`
	// Tenant Id
	TenantId pulumi.StringPtrInput `pulumi:"tenantId"`
	// Type of the managed identity
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (ManagedIdentityPropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedIdentityProperties)(nil)).Elem()
}

func (i ManagedIdentityPropertiesArgs) ToManagedIdentityPropertiesOutput() ManagedIdentityPropertiesOutput {
	return i.ToManagedIdentityPropertiesOutputWithContext(context.Background())
}

func (i ManagedIdentityPropertiesArgs) ToManagedIdentityPropertiesOutputWithContext(ctx context.Context) ManagedIdentityPropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedIdentityPropertiesOutput)
}

func (i ManagedIdentityPropertiesArgs) ToManagedIdentityPropertiesPtrOutput() ManagedIdentityPropertiesPtrOutput {
	return i.ToManagedIdentityPropertiesPtrOutputWithContext(context.Background())
}

func (i ManagedIdentityPropertiesArgs) ToManagedIdentityPropertiesPtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedIdentityPropertiesOutput).ToManagedIdentityPropertiesPtrOutputWithContext(ctx)
}

// ManagedIdentityPropertiesPtrInput is an input type that accepts ManagedIdentityPropertiesArgs, ManagedIdentityPropertiesPtr and ManagedIdentityPropertiesPtrOutput values.
// You can construct a concrete instance of `ManagedIdentityPropertiesPtrInput` via:
//
//          ManagedIdentityPropertiesArgs{...}
//
//  or:
//
//          nil
type ManagedIdentityPropertiesPtrInput interface {
	pulumi.Input

	ToManagedIdentityPropertiesPtrOutput() ManagedIdentityPropertiesPtrOutput
	ToManagedIdentityPropertiesPtrOutputWithContext(context.Context) ManagedIdentityPropertiesPtrOutput
}

type managedIdentityPropertiesPtrType ManagedIdentityPropertiesArgs

func ManagedIdentityPropertiesPtr(v *ManagedIdentityPropertiesArgs) ManagedIdentityPropertiesPtrInput {
	return (*managedIdentityPropertiesPtrType)(v)
}

func (*managedIdentityPropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedIdentityProperties)(nil)).Elem()
}

func (i *managedIdentityPropertiesPtrType) ToManagedIdentityPropertiesPtrOutput() ManagedIdentityPropertiesPtrOutput {
	return i.ToManagedIdentityPropertiesPtrOutputWithContext(context.Background())
}

func (i *managedIdentityPropertiesPtrType) ToManagedIdentityPropertiesPtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedIdentityPropertiesPtrOutput)
}

// Managed identity properties retrieved from ARM request headers.
type ManagedIdentityPropertiesOutput struct{ *pulumi.OutputState }

func (ManagedIdentityPropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedIdentityProperties)(nil)).Elem()
}

func (o ManagedIdentityPropertiesOutput) ToManagedIdentityPropertiesOutput() ManagedIdentityPropertiesOutput {
	return o
}

func (o ManagedIdentityPropertiesOutput) ToManagedIdentityPropertiesOutputWithContext(ctx context.Context) ManagedIdentityPropertiesOutput {
	return o
}

func (o ManagedIdentityPropertiesOutput) ToManagedIdentityPropertiesPtrOutput() ManagedIdentityPropertiesPtrOutput {
	return o.ToManagedIdentityPropertiesPtrOutputWithContext(context.Background())
}

func (o ManagedIdentityPropertiesOutput) ToManagedIdentityPropertiesPtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesPtrOutput {
	return o.ApplyT(func(v ManagedIdentityProperties) *ManagedIdentityProperties {
		return &v
	}).(ManagedIdentityPropertiesPtrOutput)
}

// Principal Id
func (o ManagedIdentityPropertiesOutput) PrincipalId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedIdentityProperties) *string { return v.PrincipalId }).(pulumi.StringPtrOutput)
}

// Tenant Id
func (o ManagedIdentityPropertiesOutput) TenantId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedIdentityProperties) *string { return v.TenantId }).(pulumi.StringPtrOutput)
}

// Type of the managed identity
func (o ManagedIdentityPropertiesOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedIdentityProperties) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ManagedIdentityPropertiesPtrOutput struct{ *pulumi.OutputState }

func (ManagedIdentityPropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedIdentityProperties)(nil)).Elem()
}

func (o ManagedIdentityPropertiesPtrOutput) ToManagedIdentityPropertiesPtrOutput() ManagedIdentityPropertiesPtrOutput {
	return o
}

func (o ManagedIdentityPropertiesPtrOutput) ToManagedIdentityPropertiesPtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesPtrOutput {
	return o
}

func (o ManagedIdentityPropertiesPtrOutput) Elem() ManagedIdentityPropertiesOutput {
	return o.ApplyT(func(v *ManagedIdentityProperties) ManagedIdentityProperties { return *v }).(ManagedIdentityPropertiesOutput)
}

// Principal Id
func (o ManagedIdentityPropertiesPtrOutput) PrincipalId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedIdentityProperties) *string {
		if v == nil {
			return nil
		}
		return v.PrincipalId
	}).(pulumi.StringPtrOutput)
}

// Tenant Id
func (o ManagedIdentityPropertiesPtrOutput) TenantId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedIdentityProperties) *string {
		if v == nil {
			return nil
		}
		return v.TenantId
	}).(pulumi.StringPtrOutput)
}

// Type of the managed identity
func (o ManagedIdentityPropertiesPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedIdentityProperties) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// Managed identity properties retrieved from ARM request headers.
type ManagedIdentityPropertiesResponse struct {
	// Principal Id
	PrincipalId *string `pulumi:"principalId"`
	// Tenant Id
	TenantId *string `pulumi:"tenantId"`
	// Type of the managed identity
	Type *string `pulumi:"type"`
}

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

	ToManagedIdentityPropertiesResponseOutput() ManagedIdentityPropertiesResponseOutput
	ToManagedIdentityPropertiesResponseOutputWithContext(context.Context) ManagedIdentityPropertiesResponseOutput
}

// Managed identity properties retrieved from ARM request headers.
type ManagedIdentityPropertiesResponseArgs struct {
	// Principal Id
	PrincipalId pulumi.StringPtrInput `pulumi:"principalId"`
	// Tenant Id
	TenantId pulumi.StringPtrInput `pulumi:"tenantId"`
	// Type of the managed identity
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (ManagedIdentityPropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedIdentityPropertiesResponse)(nil)).Elem()
}

func (i ManagedIdentityPropertiesResponseArgs) ToManagedIdentityPropertiesResponseOutput() ManagedIdentityPropertiesResponseOutput {
	return i.ToManagedIdentityPropertiesResponseOutputWithContext(context.Background())
}

func (i ManagedIdentityPropertiesResponseArgs) ToManagedIdentityPropertiesResponseOutputWithContext(ctx context.Context) ManagedIdentityPropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedIdentityPropertiesResponseOutput)
}

func (i ManagedIdentityPropertiesResponseArgs) ToManagedIdentityPropertiesResponsePtrOutput() ManagedIdentityPropertiesResponsePtrOutput {
	return i.ToManagedIdentityPropertiesResponsePtrOutputWithContext(context.Background())
}

func (i ManagedIdentityPropertiesResponseArgs) ToManagedIdentityPropertiesResponsePtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedIdentityPropertiesResponseOutput).ToManagedIdentityPropertiesResponsePtrOutputWithContext(ctx)
}

// ManagedIdentityPropertiesResponsePtrInput is an input type that accepts ManagedIdentityPropertiesResponseArgs, ManagedIdentityPropertiesResponsePtr and ManagedIdentityPropertiesResponsePtrOutput values.
// You can construct a concrete instance of `ManagedIdentityPropertiesResponsePtrInput` via:
//
//          ManagedIdentityPropertiesResponseArgs{...}
//
//  or:
//
//          nil
type ManagedIdentityPropertiesResponsePtrInput interface {
	pulumi.Input

	ToManagedIdentityPropertiesResponsePtrOutput() ManagedIdentityPropertiesResponsePtrOutput
	ToManagedIdentityPropertiesResponsePtrOutputWithContext(context.Context) ManagedIdentityPropertiesResponsePtrOutput
}

type managedIdentityPropertiesResponsePtrType ManagedIdentityPropertiesResponseArgs

func ManagedIdentityPropertiesResponsePtr(v *ManagedIdentityPropertiesResponseArgs) ManagedIdentityPropertiesResponsePtrInput {
	return (*managedIdentityPropertiesResponsePtrType)(v)
}

func (*managedIdentityPropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedIdentityPropertiesResponse)(nil)).Elem()
}

func (i *managedIdentityPropertiesResponsePtrType) ToManagedIdentityPropertiesResponsePtrOutput() ManagedIdentityPropertiesResponsePtrOutput {
	return i.ToManagedIdentityPropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *managedIdentityPropertiesResponsePtrType) ToManagedIdentityPropertiesResponsePtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedIdentityPropertiesResponsePtrOutput)
}

// Managed identity properties retrieved from ARM request headers.
type ManagedIdentityPropertiesResponseOutput struct{ *pulumi.OutputState }

func (ManagedIdentityPropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedIdentityPropertiesResponse)(nil)).Elem()
}

func (o ManagedIdentityPropertiesResponseOutput) ToManagedIdentityPropertiesResponseOutput() ManagedIdentityPropertiesResponseOutput {
	return o
}

func (o ManagedIdentityPropertiesResponseOutput) ToManagedIdentityPropertiesResponseOutputWithContext(ctx context.Context) ManagedIdentityPropertiesResponseOutput {
	return o
}

func (o ManagedIdentityPropertiesResponseOutput) ToManagedIdentityPropertiesResponsePtrOutput() ManagedIdentityPropertiesResponsePtrOutput {
	return o.ToManagedIdentityPropertiesResponsePtrOutputWithContext(context.Background())
}

func (o ManagedIdentityPropertiesResponseOutput) ToManagedIdentityPropertiesResponsePtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesResponsePtrOutput {
	return o.ApplyT(func(v ManagedIdentityPropertiesResponse) *ManagedIdentityPropertiesResponse {
		return &v
	}).(ManagedIdentityPropertiesResponsePtrOutput)
}

// Principal Id
func (o ManagedIdentityPropertiesResponseOutput) PrincipalId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedIdentityPropertiesResponse) *string { return v.PrincipalId }).(pulumi.StringPtrOutput)
}

// Tenant Id
func (o ManagedIdentityPropertiesResponseOutput) TenantId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedIdentityPropertiesResponse) *string { return v.TenantId }).(pulumi.StringPtrOutput)
}

// Type of the managed identity
func (o ManagedIdentityPropertiesResponseOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedIdentityPropertiesResponse) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ManagedIdentityPropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (ManagedIdentityPropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedIdentityPropertiesResponse)(nil)).Elem()
}

func (o ManagedIdentityPropertiesResponsePtrOutput) ToManagedIdentityPropertiesResponsePtrOutput() ManagedIdentityPropertiesResponsePtrOutput {
	return o
}

func (o ManagedIdentityPropertiesResponsePtrOutput) ToManagedIdentityPropertiesResponsePtrOutputWithContext(ctx context.Context) ManagedIdentityPropertiesResponsePtrOutput {
	return o
}

func (o ManagedIdentityPropertiesResponsePtrOutput) Elem() ManagedIdentityPropertiesResponseOutput {
	return o.ApplyT(func(v *ManagedIdentityPropertiesResponse) ManagedIdentityPropertiesResponse { return *v }).(ManagedIdentityPropertiesResponseOutput)
}

// Principal Id
func (o ManagedIdentityPropertiesResponsePtrOutput) PrincipalId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedIdentityPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.PrincipalId
	}).(pulumi.StringPtrOutput)
}

// Tenant Id
func (o ManagedIdentityPropertiesResponsePtrOutput) TenantId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedIdentityPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.TenantId
	}).(pulumi.StringPtrOutput)
}

// Type of the managed identity
func (o ManagedIdentityPropertiesResponsePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedIdentityPropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// Service network profile payload
type NetworkProfile struct {
	// Name of the resource group containing network resources of Azure Spring Cloud Apps
	AppNetworkResourceGroup *string `pulumi:"appNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
	AppSubnetId *string `pulumi:"appSubnetId"`
	// Azure Spring Cloud service reserved CIDR
	ServiceCidr *string `pulumi:"serviceCidr"`
	// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
	ServiceRuntimeNetworkResourceGroup *string `pulumi:"serviceRuntimeNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
	ServiceRuntimeSubnetId *string `pulumi:"serviceRuntimeSubnetId"`
}

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

	ToNetworkProfileOutput() NetworkProfileOutput
	ToNetworkProfileOutputWithContext(context.Context) NetworkProfileOutput
}

// Service network profile payload
type NetworkProfileArgs struct {
	// Name of the resource group containing network resources of Azure Spring Cloud Apps
	AppNetworkResourceGroup pulumi.StringPtrInput `pulumi:"appNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
	AppSubnetId pulumi.StringPtrInput `pulumi:"appSubnetId"`
	// Azure Spring Cloud service reserved CIDR
	ServiceCidr pulumi.StringPtrInput `pulumi:"serviceCidr"`
	// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
	ServiceRuntimeNetworkResourceGroup pulumi.StringPtrInput `pulumi:"serviceRuntimeNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
	ServiceRuntimeSubnetId pulumi.StringPtrInput `pulumi:"serviceRuntimeSubnetId"`
}

func (NetworkProfileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*NetworkProfile)(nil)).Elem()
}

func (i NetworkProfileArgs) ToNetworkProfileOutput() NetworkProfileOutput {
	return i.ToNetworkProfileOutputWithContext(context.Background())
}

func (i NetworkProfileArgs) ToNetworkProfileOutputWithContext(ctx context.Context) NetworkProfileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileOutput)
}

func (i NetworkProfileArgs) ToNetworkProfilePtrOutput() NetworkProfilePtrOutput {
	return i.ToNetworkProfilePtrOutputWithContext(context.Background())
}

func (i NetworkProfileArgs) ToNetworkProfilePtrOutputWithContext(ctx context.Context) NetworkProfilePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileOutput).ToNetworkProfilePtrOutputWithContext(ctx)
}

// NetworkProfilePtrInput is an input type that accepts NetworkProfileArgs, NetworkProfilePtr and NetworkProfilePtrOutput values.
// You can construct a concrete instance of `NetworkProfilePtrInput` via:
//
//          NetworkProfileArgs{...}
//
//  or:
//
//          nil
type NetworkProfilePtrInput interface {
	pulumi.Input

	ToNetworkProfilePtrOutput() NetworkProfilePtrOutput
	ToNetworkProfilePtrOutputWithContext(context.Context) NetworkProfilePtrOutput
}

type networkProfilePtrType NetworkProfileArgs

func NetworkProfilePtr(v *NetworkProfileArgs) NetworkProfilePtrInput {
	return (*networkProfilePtrType)(v)
}

func (*networkProfilePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkProfile)(nil)).Elem()
}

func (i *networkProfilePtrType) ToNetworkProfilePtrOutput() NetworkProfilePtrOutput {
	return i.ToNetworkProfilePtrOutputWithContext(context.Background())
}

func (i *networkProfilePtrType) ToNetworkProfilePtrOutputWithContext(ctx context.Context) NetworkProfilePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfilePtrOutput)
}

// Service network profile payload
type NetworkProfileOutput struct{ *pulumi.OutputState }

func (NetworkProfileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*NetworkProfile)(nil)).Elem()
}

func (o NetworkProfileOutput) ToNetworkProfileOutput() NetworkProfileOutput {
	return o
}

func (o NetworkProfileOutput) ToNetworkProfileOutputWithContext(ctx context.Context) NetworkProfileOutput {
	return o
}

func (o NetworkProfileOutput) ToNetworkProfilePtrOutput() NetworkProfilePtrOutput {
	return o.ToNetworkProfilePtrOutputWithContext(context.Background())
}

func (o NetworkProfileOutput) ToNetworkProfilePtrOutputWithContext(ctx context.Context) NetworkProfilePtrOutput {
	return o.ApplyT(func(v NetworkProfile) *NetworkProfile {
		return &v
	}).(NetworkProfilePtrOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Apps
func (o NetworkProfileOutput) AppNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfile) *string { return v.AppNetworkResourceGroup }).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
func (o NetworkProfileOutput) AppSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfile) *string { return v.AppSubnetId }).(pulumi.StringPtrOutput)
}

// Azure Spring Cloud service reserved CIDR
func (o NetworkProfileOutput) ServiceCidr() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfile) *string { return v.ServiceCidr }).(pulumi.StringPtrOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
func (o NetworkProfileOutput) ServiceRuntimeNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfile) *string { return v.ServiceRuntimeNetworkResourceGroup }).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
func (o NetworkProfileOutput) ServiceRuntimeSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfile) *string { return v.ServiceRuntimeSubnetId }).(pulumi.StringPtrOutput)
}

type NetworkProfilePtrOutput struct{ *pulumi.OutputState }

func (NetworkProfilePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkProfile)(nil)).Elem()
}

func (o NetworkProfilePtrOutput) ToNetworkProfilePtrOutput() NetworkProfilePtrOutput {
	return o
}

func (o NetworkProfilePtrOutput) ToNetworkProfilePtrOutputWithContext(ctx context.Context) NetworkProfilePtrOutput {
	return o
}

func (o NetworkProfilePtrOutput) Elem() NetworkProfileOutput {
	return o.ApplyT(func(v *NetworkProfile) NetworkProfile { return *v }).(NetworkProfileOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Apps
func (o NetworkProfilePtrOutput) AppNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfile) *string {
		if v == nil {
			return nil
		}
		return v.AppNetworkResourceGroup
	}).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
func (o NetworkProfilePtrOutput) AppSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfile) *string {
		if v == nil {
			return nil
		}
		return v.AppSubnetId
	}).(pulumi.StringPtrOutput)
}

// Azure Spring Cloud service reserved CIDR
func (o NetworkProfilePtrOutput) ServiceCidr() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfile) *string {
		if v == nil {
			return nil
		}
		return v.ServiceCidr
	}).(pulumi.StringPtrOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
func (o NetworkProfilePtrOutput) ServiceRuntimeNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfile) *string {
		if v == nil {
			return nil
		}
		return v.ServiceRuntimeNetworkResourceGroup
	}).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
func (o NetworkProfilePtrOutput) ServiceRuntimeSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfile) *string {
		if v == nil {
			return nil
		}
		return v.ServiceRuntimeSubnetId
	}).(pulumi.StringPtrOutput)
}

// Service network profile payload
type NetworkProfileResponse struct {
	// Name of the resource group containing network resources of Azure Spring Cloud Apps
	AppNetworkResourceGroup *string `pulumi:"appNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
	AppSubnetId *string `pulumi:"appSubnetId"`
	// Desired outbound IP resources for Azure Spring Cloud instance.
	OutboundIPs NetworkProfileResponseOutboundIPs `pulumi:"outboundIPs"`
	// Azure Spring Cloud service reserved CIDR
	ServiceCidr *string `pulumi:"serviceCidr"`
	// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
	ServiceRuntimeNetworkResourceGroup *string `pulumi:"serviceRuntimeNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
	ServiceRuntimeSubnetId *string `pulumi:"serviceRuntimeSubnetId"`
}

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

	ToNetworkProfileResponseOutput() NetworkProfileResponseOutput
	ToNetworkProfileResponseOutputWithContext(context.Context) NetworkProfileResponseOutput
}

// Service network profile payload
type NetworkProfileResponseArgs struct {
	// Name of the resource group containing network resources of Azure Spring Cloud Apps
	AppNetworkResourceGroup pulumi.StringPtrInput `pulumi:"appNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
	AppSubnetId pulumi.StringPtrInput `pulumi:"appSubnetId"`
	// Desired outbound IP resources for Azure Spring Cloud instance.
	OutboundIPs NetworkProfileResponseOutboundIPsInput `pulumi:"outboundIPs"`
	// Azure Spring Cloud service reserved CIDR
	ServiceCidr pulumi.StringPtrInput `pulumi:"serviceCidr"`
	// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
	ServiceRuntimeNetworkResourceGroup pulumi.StringPtrInput `pulumi:"serviceRuntimeNetworkResourceGroup"`
	// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
	ServiceRuntimeSubnetId pulumi.StringPtrInput `pulumi:"serviceRuntimeSubnetId"`
}

func (NetworkProfileResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*NetworkProfileResponse)(nil)).Elem()
}

func (i NetworkProfileResponseArgs) ToNetworkProfileResponseOutput() NetworkProfileResponseOutput {
	return i.ToNetworkProfileResponseOutputWithContext(context.Background())
}

func (i NetworkProfileResponseArgs) ToNetworkProfileResponseOutputWithContext(ctx context.Context) NetworkProfileResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileResponseOutput)
}

func (i NetworkProfileResponseArgs) ToNetworkProfileResponsePtrOutput() NetworkProfileResponsePtrOutput {
	return i.ToNetworkProfileResponsePtrOutputWithContext(context.Background())
}

func (i NetworkProfileResponseArgs) ToNetworkProfileResponsePtrOutputWithContext(ctx context.Context) NetworkProfileResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileResponseOutput).ToNetworkProfileResponsePtrOutputWithContext(ctx)
}

// NetworkProfileResponsePtrInput is an input type that accepts NetworkProfileResponseArgs, NetworkProfileResponsePtr and NetworkProfileResponsePtrOutput values.
// You can construct a concrete instance of `NetworkProfileResponsePtrInput` via:
//
//          NetworkProfileResponseArgs{...}
//
//  or:
//
//          nil
type NetworkProfileResponsePtrInput interface {
	pulumi.Input

	ToNetworkProfileResponsePtrOutput() NetworkProfileResponsePtrOutput
	ToNetworkProfileResponsePtrOutputWithContext(context.Context) NetworkProfileResponsePtrOutput
}

type networkProfileResponsePtrType NetworkProfileResponseArgs

func NetworkProfileResponsePtr(v *NetworkProfileResponseArgs) NetworkProfileResponsePtrInput {
	return (*networkProfileResponsePtrType)(v)
}

func (*networkProfileResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkProfileResponse)(nil)).Elem()
}

func (i *networkProfileResponsePtrType) ToNetworkProfileResponsePtrOutput() NetworkProfileResponsePtrOutput {
	return i.ToNetworkProfileResponsePtrOutputWithContext(context.Background())
}

func (i *networkProfileResponsePtrType) ToNetworkProfileResponsePtrOutputWithContext(ctx context.Context) NetworkProfileResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileResponsePtrOutput)
}

// Service network profile payload
type NetworkProfileResponseOutput struct{ *pulumi.OutputState }

func (NetworkProfileResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*NetworkProfileResponse)(nil)).Elem()
}

func (o NetworkProfileResponseOutput) ToNetworkProfileResponseOutput() NetworkProfileResponseOutput {
	return o
}

func (o NetworkProfileResponseOutput) ToNetworkProfileResponseOutputWithContext(ctx context.Context) NetworkProfileResponseOutput {
	return o
}

func (o NetworkProfileResponseOutput) ToNetworkProfileResponsePtrOutput() NetworkProfileResponsePtrOutput {
	return o.ToNetworkProfileResponsePtrOutputWithContext(context.Background())
}

func (o NetworkProfileResponseOutput) ToNetworkProfileResponsePtrOutputWithContext(ctx context.Context) NetworkProfileResponsePtrOutput {
	return o.ApplyT(func(v NetworkProfileResponse) *NetworkProfileResponse {
		return &v
	}).(NetworkProfileResponsePtrOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Apps
func (o NetworkProfileResponseOutput) AppNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfileResponse) *string { return v.AppNetworkResourceGroup }).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
func (o NetworkProfileResponseOutput) AppSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfileResponse) *string { return v.AppSubnetId }).(pulumi.StringPtrOutput)
}

// Desired outbound IP resources for Azure Spring Cloud instance.
func (o NetworkProfileResponseOutput) OutboundIPs() NetworkProfileResponseOutboundIPsOutput {
	return o.ApplyT(func(v NetworkProfileResponse) NetworkProfileResponseOutboundIPs { return v.OutboundIPs }).(NetworkProfileResponseOutboundIPsOutput)
}

// Azure Spring Cloud service reserved CIDR
func (o NetworkProfileResponseOutput) ServiceCidr() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfileResponse) *string { return v.ServiceCidr }).(pulumi.StringPtrOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
func (o NetworkProfileResponseOutput) ServiceRuntimeNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfileResponse) *string { return v.ServiceRuntimeNetworkResourceGroup }).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
func (o NetworkProfileResponseOutput) ServiceRuntimeSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v NetworkProfileResponse) *string { return v.ServiceRuntimeSubnetId }).(pulumi.StringPtrOutput)
}

type NetworkProfileResponsePtrOutput struct{ *pulumi.OutputState }

func (NetworkProfileResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkProfileResponse)(nil)).Elem()
}

func (o NetworkProfileResponsePtrOutput) ToNetworkProfileResponsePtrOutput() NetworkProfileResponsePtrOutput {
	return o
}

func (o NetworkProfileResponsePtrOutput) ToNetworkProfileResponsePtrOutputWithContext(ctx context.Context) NetworkProfileResponsePtrOutput {
	return o
}

func (o NetworkProfileResponsePtrOutput) Elem() NetworkProfileResponseOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) NetworkProfileResponse { return *v }).(NetworkProfileResponseOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Apps
func (o NetworkProfileResponsePtrOutput) AppNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) *string {
		if v == nil {
			return nil
		}
		return v.AppNetworkResourceGroup
	}).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Apps
func (o NetworkProfileResponsePtrOutput) AppSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) *string {
		if v == nil {
			return nil
		}
		return v.AppSubnetId
	}).(pulumi.StringPtrOutput)
}

// Desired outbound IP resources for Azure Spring Cloud instance.
func (o NetworkProfileResponsePtrOutput) OutboundIPs() NetworkProfileResponseOutboundIPsPtrOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) *NetworkProfileResponseOutboundIPs {
		if v == nil {
			return nil
		}
		return &v.OutboundIPs
	}).(NetworkProfileResponseOutboundIPsPtrOutput)
}

// Azure Spring Cloud service reserved CIDR
func (o NetworkProfileResponsePtrOutput) ServiceCidr() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) *string {
		if v == nil {
			return nil
		}
		return v.ServiceCidr
	}).(pulumi.StringPtrOutput)
}

// Name of the resource group containing network resources of Azure Spring Cloud Service Runtime
func (o NetworkProfileResponsePtrOutput) ServiceRuntimeNetworkResourceGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) *string {
		if v == nil {
			return nil
		}
		return v.ServiceRuntimeNetworkResourceGroup
	}).(pulumi.StringPtrOutput)
}

// Fully qualified resource Id of the subnet to host Azure Spring Cloud Service Runtime
func (o NetworkProfileResponsePtrOutput) ServiceRuntimeSubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkProfileResponse) *string {
		if v == nil {
			return nil
		}
		return v.ServiceRuntimeSubnetId
	}).(pulumi.StringPtrOutput)
}

// Desired outbound IP resources for Azure Spring Cloud instance.
type NetworkProfileResponseOutboundIPs struct {
	// A list of public IP addresses.
	PublicIPs []string `pulumi:"publicIPs"`
}

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

	ToNetworkProfileResponseOutboundIPsOutput() NetworkProfileResponseOutboundIPsOutput
	ToNetworkProfileResponseOutboundIPsOutputWithContext(context.Context) NetworkProfileResponseOutboundIPsOutput
}

// Desired outbound IP resources for Azure Spring Cloud instance.
type NetworkProfileResponseOutboundIPsArgs struct {
	// A list of public IP addresses.
	PublicIPs pulumi.StringArrayInput `pulumi:"publicIPs"`
}

func (NetworkProfileResponseOutboundIPsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*NetworkProfileResponseOutboundIPs)(nil)).Elem()
}

func (i NetworkProfileResponseOutboundIPsArgs) ToNetworkProfileResponseOutboundIPsOutput() NetworkProfileResponseOutboundIPsOutput {
	return i.ToNetworkProfileResponseOutboundIPsOutputWithContext(context.Background())
}

func (i NetworkProfileResponseOutboundIPsArgs) ToNetworkProfileResponseOutboundIPsOutputWithContext(ctx context.Context) NetworkProfileResponseOutboundIPsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileResponseOutboundIPsOutput)
}

func (i NetworkProfileResponseOutboundIPsArgs) ToNetworkProfileResponseOutboundIPsPtrOutput() NetworkProfileResponseOutboundIPsPtrOutput {
	return i.ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(context.Background())
}

func (i NetworkProfileResponseOutboundIPsArgs) ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(ctx context.Context) NetworkProfileResponseOutboundIPsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileResponseOutboundIPsOutput).ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(ctx)
}

// NetworkProfileResponseOutboundIPsPtrInput is an input type that accepts NetworkProfileResponseOutboundIPsArgs, NetworkProfileResponseOutboundIPsPtr and NetworkProfileResponseOutboundIPsPtrOutput values.
// You can construct a concrete instance of `NetworkProfileResponseOutboundIPsPtrInput` via:
//
//          NetworkProfileResponseOutboundIPsArgs{...}
//
//  or:
//
//          nil
type NetworkProfileResponseOutboundIPsPtrInput interface {
	pulumi.Input

	ToNetworkProfileResponseOutboundIPsPtrOutput() NetworkProfileResponseOutboundIPsPtrOutput
	ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(context.Context) NetworkProfileResponseOutboundIPsPtrOutput
}

type networkProfileResponseOutboundIPsPtrType NetworkProfileResponseOutboundIPsArgs

func NetworkProfileResponseOutboundIPsPtr(v *NetworkProfileResponseOutboundIPsArgs) NetworkProfileResponseOutboundIPsPtrInput {
	return (*networkProfileResponseOutboundIPsPtrType)(v)
}

func (*networkProfileResponseOutboundIPsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkProfileResponseOutboundIPs)(nil)).Elem()
}

func (i *networkProfileResponseOutboundIPsPtrType) ToNetworkProfileResponseOutboundIPsPtrOutput() NetworkProfileResponseOutboundIPsPtrOutput {
	return i.ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(context.Background())
}

func (i *networkProfileResponseOutboundIPsPtrType) ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(ctx context.Context) NetworkProfileResponseOutboundIPsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkProfileResponseOutboundIPsPtrOutput)
}

// Desired outbound IP resources for Azure Spring Cloud instance.
type NetworkProfileResponseOutboundIPsOutput struct{ *pulumi.OutputState }

func (NetworkProfileResponseOutboundIPsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*NetworkProfileResponseOutboundIPs)(nil)).Elem()
}

func (o NetworkProfileResponseOutboundIPsOutput) ToNetworkProfileResponseOutboundIPsOutput() NetworkProfileResponseOutboundIPsOutput {
	return o
}

func (o NetworkProfileResponseOutboundIPsOutput) ToNetworkProfileResponseOutboundIPsOutputWithContext(ctx context.Context) NetworkProfileResponseOutboundIPsOutput {
	return o
}

func (o NetworkProfileResponseOutboundIPsOutput) ToNetworkProfileResponseOutboundIPsPtrOutput() NetworkProfileResponseOutboundIPsPtrOutput {
	return o.ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(context.Background())
}

func (o NetworkProfileResponseOutboundIPsOutput) ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(ctx context.Context) NetworkProfileResponseOutboundIPsPtrOutput {
	return o.ApplyT(func(v NetworkProfileResponseOutboundIPs) *NetworkProfileResponseOutboundIPs {
		return &v
	}).(NetworkProfileResponseOutboundIPsPtrOutput)
}

// A list of public IP addresses.
func (o NetworkProfileResponseOutboundIPsOutput) PublicIPs() pulumi.StringArrayOutput {
	return o.ApplyT(func(v NetworkProfileResponseOutboundIPs) []string { return v.PublicIPs }).(pulumi.StringArrayOutput)
}

type NetworkProfileResponseOutboundIPsPtrOutput struct{ *pulumi.OutputState }

func (NetworkProfileResponseOutboundIPsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkProfileResponseOutboundIPs)(nil)).Elem()
}

func (o NetworkProfileResponseOutboundIPsPtrOutput) ToNetworkProfileResponseOutboundIPsPtrOutput() NetworkProfileResponseOutboundIPsPtrOutput {
	return o
}

func (o NetworkProfileResponseOutboundIPsPtrOutput) ToNetworkProfileResponseOutboundIPsPtrOutputWithContext(ctx context.Context) NetworkProfileResponseOutboundIPsPtrOutput {
	return o
}

func (o NetworkProfileResponseOutboundIPsPtrOutput) Elem() NetworkProfileResponseOutboundIPsOutput {
	return o.ApplyT(func(v *NetworkProfileResponseOutboundIPs) NetworkProfileResponseOutboundIPs { return *v }).(NetworkProfileResponseOutboundIPsOutput)
}

// A list of public IP addresses.
func (o NetworkProfileResponseOutboundIPsPtrOutput) PublicIPs() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *NetworkProfileResponseOutboundIPs) []string {
		if v == nil {
			return nil
		}
		return v.PublicIPs
	}).(pulumi.StringArrayOutput)
}

// Persistent disk payload
type PersistentDisk struct {
	// Mount path of the persistent disk
	MountPath *string `pulumi:"mountPath"`
	// Size of the persistent disk in GB
	SizeInGB *int `pulumi:"sizeInGB"`
}

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

	ToPersistentDiskOutput() PersistentDiskOutput
	ToPersistentDiskOutputWithContext(context.Context) PersistentDiskOutput
}

// Persistent disk payload
type PersistentDiskArgs struct {
	// Mount path of the persistent disk
	MountPath pulumi.StringPtrInput `pulumi:"mountPath"`
	// Size of the persistent disk in GB
	SizeInGB pulumi.IntPtrInput `pulumi:"sizeInGB"`
}

func (PersistentDiskArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PersistentDisk)(nil)).Elem()
}

func (i PersistentDiskArgs) ToPersistentDiskOutput() PersistentDiskOutput {
	return i.ToPersistentDiskOutputWithContext(context.Background())
}

func (i PersistentDiskArgs) ToPersistentDiskOutputWithContext(ctx context.Context) PersistentDiskOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PersistentDiskOutput)
}

func (i PersistentDiskArgs) ToPersistentDiskPtrOutput() PersistentDiskPtrOutput {
	return i.ToPersistentDiskPtrOutputWithContext(context.Background())
}

func (i PersistentDiskArgs) ToPersistentDiskPtrOutputWithContext(ctx context.Context) PersistentDiskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PersistentDiskOutput).ToPersistentDiskPtrOutputWithContext(ctx)
}

// PersistentDiskPtrInput is an input type that accepts PersistentDiskArgs, PersistentDiskPtr and PersistentDiskPtrOutput values.
// You can construct a concrete instance of `PersistentDiskPtrInput` via:
//
//          PersistentDiskArgs{...}
//
//  or:
//
//          nil
type PersistentDiskPtrInput interface {
	pulumi.Input

	ToPersistentDiskPtrOutput() PersistentDiskPtrOutput
	ToPersistentDiskPtrOutputWithContext(context.Context) PersistentDiskPtrOutput
}

type persistentDiskPtrType PersistentDiskArgs

func PersistentDiskPtr(v *PersistentDiskArgs) PersistentDiskPtrInput {
	return (*persistentDiskPtrType)(v)
}

func (*persistentDiskPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PersistentDisk)(nil)).Elem()
}

func (i *persistentDiskPtrType) ToPersistentDiskPtrOutput() PersistentDiskPtrOutput {
	return i.ToPersistentDiskPtrOutputWithContext(context.Background())
}

func (i *persistentDiskPtrType) ToPersistentDiskPtrOutputWithContext(ctx context.Context) PersistentDiskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PersistentDiskPtrOutput)
}

// Persistent disk payload
type PersistentDiskOutput struct{ *pulumi.OutputState }

func (PersistentDiskOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PersistentDisk)(nil)).Elem()
}

func (o PersistentDiskOutput) ToPersistentDiskOutput() PersistentDiskOutput {
	return o
}

func (o PersistentDiskOutput) ToPersistentDiskOutputWithContext(ctx context.Context) PersistentDiskOutput {
	return o
}

func (o PersistentDiskOutput) ToPersistentDiskPtrOutput() PersistentDiskPtrOutput {
	return o.ToPersistentDiskPtrOutputWithContext(context.Background())
}

func (o PersistentDiskOutput) ToPersistentDiskPtrOutputWithContext(ctx context.Context) PersistentDiskPtrOutput {
	return o.ApplyT(func(v PersistentDisk) *PersistentDisk {
		return &v
	}).(PersistentDiskPtrOutput)
}

// Mount path of the persistent disk
func (o PersistentDiskOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PersistentDisk) *string { return v.MountPath }).(pulumi.StringPtrOutput)
}

// Size of the persistent disk in GB
func (o PersistentDiskOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v PersistentDisk) *int { return v.SizeInGB }).(pulumi.IntPtrOutput)
}

type PersistentDiskPtrOutput struct{ *pulumi.OutputState }

func (PersistentDiskPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PersistentDisk)(nil)).Elem()
}

func (o PersistentDiskPtrOutput) ToPersistentDiskPtrOutput() PersistentDiskPtrOutput {
	return o
}

func (o PersistentDiskPtrOutput) ToPersistentDiskPtrOutputWithContext(ctx context.Context) PersistentDiskPtrOutput {
	return o
}

func (o PersistentDiskPtrOutput) Elem() PersistentDiskOutput {
	return o.ApplyT(func(v *PersistentDisk) PersistentDisk { return *v }).(PersistentDiskOutput)
}

// Mount path of the persistent disk
func (o PersistentDiskPtrOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PersistentDisk) *string {
		if v == nil {
			return nil
		}
		return v.MountPath
	}).(pulumi.StringPtrOutput)
}

// Size of the persistent disk in GB
func (o PersistentDiskPtrOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *PersistentDisk) *int {
		if v == nil {
			return nil
		}
		return v.SizeInGB
	}).(pulumi.IntPtrOutput)
}

// Persistent disk payload
type PersistentDiskResponse struct {
	// Mount path of the persistent disk
	MountPath *string `pulumi:"mountPath"`
	// Size of the persistent disk in GB
	SizeInGB *int `pulumi:"sizeInGB"`
	// Size of the used persistent disk in GB
	UsedInGB int `pulumi:"usedInGB"`
}

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

	ToPersistentDiskResponseOutput() PersistentDiskResponseOutput
	ToPersistentDiskResponseOutputWithContext(context.Context) PersistentDiskResponseOutput
}

// Persistent disk payload
type PersistentDiskResponseArgs struct {
	// Mount path of the persistent disk
	MountPath pulumi.StringPtrInput `pulumi:"mountPath"`
	// Size of the persistent disk in GB
	SizeInGB pulumi.IntPtrInput `pulumi:"sizeInGB"`
	// Size of the used persistent disk in GB
	UsedInGB pulumi.IntInput `pulumi:"usedInGB"`
}

func (PersistentDiskResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PersistentDiskResponse)(nil)).Elem()
}

func (i PersistentDiskResponseArgs) ToPersistentDiskResponseOutput() PersistentDiskResponseOutput {
	return i.ToPersistentDiskResponseOutputWithContext(context.Background())
}

func (i PersistentDiskResponseArgs) ToPersistentDiskResponseOutputWithContext(ctx context.Context) PersistentDiskResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PersistentDiskResponseOutput)
}

func (i PersistentDiskResponseArgs) ToPersistentDiskResponsePtrOutput() PersistentDiskResponsePtrOutput {
	return i.ToPersistentDiskResponsePtrOutputWithContext(context.Background())
}

func (i PersistentDiskResponseArgs) ToPersistentDiskResponsePtrOutputWithContext(ctx context.Context) PersistentDiskResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PersistentDiskResponseOutput).ToPersistentDiskResponsePtrOutputWithContext(ctx)
}

// PersistentDiskResponsePtrInput is an input type that accepts PersistentDiskResponseArgs, PersistentDiskResponsePtr and PersistentDiskResponsePtrOutput values.
// You can construct a concrete instance of `PersistentDiskResponsePtrInput` via:
//
//          PersistentDiskResponseArgs{...}
//
//  or:
//
//          nil
type PersistentDiskResponsePtrInput interface {
	pulumi.Input

	ToPersistentDiskResponsePtrOutput() PersistentDiskResponsePtrOutput
	ToPersistentDiskResponsePtrOutputWithContext(context.Context) PersistentDiskResponsePtrOutput
}

type persistentDiskResponsePtrType PersistentDiskResponseArgs

func PersistentDiskResponsePtr(v *PersistentDiskResponseArgs) PersistentDiskResponsePtrInput {
	return (*persistentDiskResponsePtrType)(v)
}

func (*persistentDiskResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PersistentDiskResponse)(nil)).Elem()
}

func (i *persistentDiskResponsePtrType) ToPersistentDiskResponsePtrOutput() PersistentDiskResponsePtrOutput {
	return i.ToPersistentDiskResponsePtrOutputWithContext(context.Background())
}

func (i *persistentDiskResponsePtrType) ToPersistentDiskResponsePtrOutputWithContext(ctx context.Context) PersistentDiskResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PersistentDiskResponsePtrOutput)
}

// Persistent disk payload
type PersistentDiskResponseOutput struct{ *pulumi.OutputState }

func (PersistentDiskResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PersistentDiskResponse)(nil)).Elem()
}

func (o PersistentDiskResponseOutput) ToPersistentDiskResponseOutput() PersistentDiskResponseOutput {
	return o
}

func (o PersistentDiskResponseOutput) ToPersistentDiskResponseOutputWithContext(ctx context.Context) PersistentDiskResponseOutput {
	return o
}

func (o PersistentDiskResponseOutput) ToPersistentDiskResponsePtrOutput() PersistentDiskResponsePtrOutput {
	return o.ToPersistentDiskResponsePtrOutputWithContext(context.Background())
}

func (o PersistentDiskResponseOutput) ToPersistentDiskResponsePtrOutputWithContext(ctx context.Context) PersistentDiskResponsePtrOutput {
	return o.ApplyT(func(v PersistentDiskResponse) *PersistentDiskResponse {
		return &v
	}).(PersistentDiskResponsePtrOutput)
}

// Mount path of the persistent disk
func (o PersistentDiskResponseOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PersistentDiskResponse) *string { return v.MountPath }).(pulumi.StringPtrOutput)
}

// Size of the persistent disk in GB
func (o PersistentDiskResponseOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v PersistentDiskResponse) *int { return v.SizeInGB }).(pulumi.IntPtrOutput)
}

// Size of the used persistent disk in GB
func (o PersistentDiskResponseOutput) UsedInGB() pulumi.IntOutput {
	return o.ApplyT(func(v PersistentDiskResponse) int { return v.UsedInGB }).(pulumi.IntOutput)
}

type PersistentDiskResponsePtrOutput struct{ *pulumi.OutputState }

func (PersistentDiskResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PersistentDiskResponse)(nil)).Elem()
}

func (o PersistentDiskResponsePtrOutput) ToPersistentDiskResponsePtrOutput() PersistentDiskResponsePtrOutput {
	return o
}

func (o PersistentDiskResponsePtrOutput) ToPersistentDiskResponsePtrOutputWithContext(ctx context.Context) PersistentDiskResponsePtrOutput {
	return o
}

func (o PersistentDiskResponsePtrOutput) Elem() PersistentDiskResponseOutput {
	return o.ApplyT(func(v *PersistentDiskResponse) PersistentDiskResponse { return *v }).(PersistentDiskResponseOutput)
}

// Mount path of the persistent disk
func (o PersistentDiskResponsePtrOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PersistentDiskResponse) *string {
		if v == nil {
			return nil
		}
		return v.MountPath
	}).(pulumi.StringPtrOutput)
}

// Size of the persistent disk in GB
func (o PersistentDiskResponsePtrOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *PersistentDiskResponse) *int {
		if v == nil {
			return nil
		}
		return v.SizeInGB
	}).(pulumi.IntPtrOutput)
}

// Size of the used persistent disk in GB
func (o PersistentDiskResponsePtrOutput) UsedInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *PersistentDiskResponse) *int {
		if v == nil {
			return nil
		}
		return &v.UsedInGB
	}).(pulumi.IntPtrOutput)
}

// Sku of Azure Spring Cloud
type Sku struct {
	// Current capacity of the target resource
	Capacity *int `pulumi:"capacity"`
	// Name of the Sku
	Name *string `pulumi:"name"`
	// Tier of the Sku
	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 of Azure Spring Cloud
type SkuArgs struct {
	// Current capacity of the target resource
	Capacity pulumi.IntPtrInput `pulumi:"capacity"`
	// Name of the Sku
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Tier of the Sku
	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 of Azure Spring Cloud
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)
}

// Current capacity of the target resource
func (o SkuOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v Sku) *int { return v.Capacity }).(pulumi.IntPtrOutput)
}

// Name of the Sku
func (o SkuOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Sku) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// Tier of the Sku
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)
}

// Current capacity of the target resource
func (o SkuPtrOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *Sku) *int {
		if v == nil {
			return nil
		}
		return v.Capacity
	}).(pulumi.IntPtrOutput)
}

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

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

// Sku of Azure Spring Cloud
type SkuResponse struct {
	// Current capacity of the target resource
	Capacity *int `pulumi:"capacity"`
	// Name of the Sku
	Name *string `pulumi:"name"`
	// Tier of the Sku
	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 of Azure Spring Cloud
type SkuResponseArgs struct {
	// Current capacity of the target resource
	Capacity pulumi.IntPtrInput `pulumi:"capacity"`
	// Name of the Sku
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Tier of the Sku
	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 of Azure Spring Cloud
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)
}

// Current capacity of the target resource
func (o SkuResponseOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v SkuResponse) *int { return v.Capacity }).(pulumi.IntPtrOutput)
}

// Name of the Sku
func (o SkuResponseOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SkuResponse) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// Tier of the Sku
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)
}

// Current capacity of the target resource
func (o SkuResponsePtrOutput) Capacity() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *int {
		if v == nil {
			return nil
		}
		return v.Capacity
	}).(pulumi.IntPtrOutput)
}

// Name of the Sku
func (o SkuResponsePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// Tier of the Sku
func (o SkuResponsePtrOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SkuResponse) *string {
		if v == nil {
			return nil
		}
		return v.Tier
	}).(pulumi.StringPtrOutput)
}

// Temporary disk payload
type TemporaryDisk struct {
	// Mount path of the temporary disk
	MountPath *string `pulumi:"mountPath"`
	// Size of the temporary disk in GB
	SizeInGB *int `pulumi:"sizeInGB"`
}

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

	ToTemporaryDiskOutput() TemporaryDiskOutput
	ToTemporaryDiskOutputWithContext(context.Context) TemporaryDiskOutput
}

// Temporary disk payload
type TemporaryDiskArgs struct {
	// Mount path of the temporary disk
	MountPath pulumi.StringPtrInput `pulumi:"mountPath"`
	// Size of the temporary disk in GB
	SizeInGB pulumi.IntPtrInput `pulumi:"sizeInGB"`
}

func (TemporaryDiskArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*TemporaryDisk)(nil)).Elem()
}

func (i TemporaryDiskArgs) ToTemporaryDiskOutput() TemporaryDiskOutput {
	return i.ToTemporaryDiskOutputWithContext(context.Background())
}

func (i TemporaryDiskArgs) ToTemporaryDiskOutputWithContext(ctx context.Context) TemporaryDiskOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemporaryDiskOutput)
}

func (i TemporaryDiskArgs) ToTemporaryDiskPtrOutput() TemporaryDiskPtrOutput {
	return i.ToTemporaryDiskPtrOutputWithContext(context.Background())
}

func (i TemporaryDiskArgs) ToTemporaryDiskPtrOutputWithContext(ctx context.Context) TemporaryDiskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemporaryDiskOutput).ToTemporaryDiskPtrOutputWithContext(ctx)
}

// TemporaryDiskPtrInput is an input type that accepts TemporaryDiskArgs, TemporaryDiskPtr and TemporaryDiskPtrOutput values.
// You can construct a concrete instance of `TemporaryDiskPtrInput` via:
//
//          TemporaryDiskArgs{...}
//
//  or:
//
//          nil
type TemporaryDiskPtrInput interface {
	pulumi.Input

	ToTemporaryDiskPtrOutput() TemporaryDiskPtrOutput
	ToTemporaryDiskPtrOutputWithContext(context.Context) TemporaryDiskPtrOutput
}

type temporaryDiskPtrType TemporaryDiskArgs

func TemporaryDiskPtr(v *TemporaryDiskArgs) TemporaryDiskPtrInput {
	return (*temporaryDiskPtrType)(v)
}

func (*temporaryDiskPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**TemporaryDisk)(nil)).Elem()
}

func (i *temporaryDiskPtrType) ToTemporaryDiskPtrOutput() TemporaryDiskPtrOutput {
	return i.ToTemporaryDiskPtrOutputWithContext(context.Background())
}

func (i *temporaryDiskPtrType) ToTemporaryDiskPtrOutputWithContext(ctx context.Context) TemporaryDiskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemporaryDiskPtrOutput)
}

// Temporary disk payload
type TemporaryDiskOutput struct{ *pulumi.OutputState }

func (TemporaryDiskOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*TemporaryDisk)(nil)).Elem()
}

func (o TemporaryDiskOutput) ToTemporaryDiskOutput() TemporaryDiskOutput {
	return o
}

func (o TemporaryDiskOutput) ToTemporaryDiskOutputWithContext(ctx context.Context) TemporaryDiskOutput {
	return o
}

func (o TemporaryDiskOutput) ToTemporaryDiskPtrOutput() TemporaryDiskPtrOutput {
	return o.ToTemporaryDiskPtrOutputWithContext(context.Background())
}

func (o TemporaryDiskOutput) ToTemporaryDiskPtrOutputWithContext(ctx context.Context) TemporaryDiskPtrOutput {
	return o.ApplyT(func(v TemporaryDisk) *TemporaryDisk {
		return &v
	}).(TemporaryDiskPtrOutput)
}

// Mount path of the temporary disk
func (o TemporaryDiskOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v TemporaryDisk) *string { return v.MountPath }).(pulumi.StringPtrOutput)
}

// Size of the temporary disk in GB
func (o TemporaryDiskOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v TemporaryDisk) *int { return v.SizeInGB }).(pulumi.IntPtrOutput)
}

type TemporaryDiskPtrOutput struct{ *pulumi.OutputState }

func (TemporaryDiskPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**TemporaryDisk)(nil)).Elem()
}

func (o TemporaryDiskPtrOutput) ToTemporaryDiskPtrOutput() TemporaryDiskPtrOutput {
	return o
}

func (o TemporaryDiskPtrOutput) ToTemporaryDiskPtrOutputWithContext(ctx context.Context) TemporaryDiskPtrOutput {
	return o
}

func (o TemporaryDiskPtrOutput) Elem() TemporaryDiskOutput {
	return o.ApplyT(func(v *TemporaryDisk) TemporaryDisk { return *v }).(TemporaryDiskOutput)
}

// Mount path of the temporary disk
func (o TemporaryDiskPtrOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *TemporaryDisk) *string {
		if v == nil {
			return nil
		}
		return v.MountPath
	}).(pulumi.StringPtrOutput)
}

// Size of the temporary disk in GB
func (o TemporaryDiskPtrOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *TemporaryDisk) *int {
		if v == nil {
			return nil
		}
		return v.SizeInGB
	}).(pulumi.IntPtrOutput)
}

// Temporary disk payload
type TemporaryDiskResponse struct {
	// Mount path of the temporary disk
	MountPath *string `pulumi:"mountPath"`
	// Size of the temporary disk in GB
	SizeInGB *int `pulumi:"sizeInGB"`
}

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

	ToTemporaryDiskResponseOutput() TemporaryDiskResponseOutput
	ToTemporaryDiskResponseOutputWithContext(context.Context) TemporaryDiskResponseOutput
}

// Temporary disk payload
type TemporaryDiskResponseArgs struct {
	// Mount path of the temporary disk
	MountPath pulumi.StringPtrInput `pulumi:"mountPath"`
	// Size of the temporary disk in GB
	SizeInGB pulumi.IntPtrInput `pulumi:"sizeInGB"`
}

func (TemporaryDiskResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*TemporaryDiskResponse)(nil)).Elem()
}

func (i TemporaryDiskResponseArgs) ToTemporaryDiskResponseOutput() TemporaryDiskResponseOutput {
	return i.ToTemporaryDiskResponseOutputWithContext(context.Background())
}

func (i TemporaryDiskResponseArgs) ToTemporaryDiskResponseOutputWithContext(ctx context.Context) TemporaryDiskResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemporaryDiskResponseOutput)
}

func (i TemporaryDiskResponseArgs) ToTemporaryDiskResponsePtrOutput() TemporaryDiskResponsePtrOutput {
	return i.ToTemporaryDiskResponsePtrOutputWithContext(context.Background())
}

func (i TemporaryDiskResponseArgs) ToTemporaryDiskResponsePtrOutputWithContext(ctx context.Context) TemporaryDiskResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemporaryDiskResponseOutput).ToTemporaryDiskResponsePtrOutputWithContext(ctx)
}

// TemporaryDiskResponsePtrInput is an input type that accepts TemporaryDiskResponseArgs, TemporaryDiskResponsePtr and TemporaryDiskResponsePtrOutput values.
// You can construct a concrete instance of `TemporaryDiskResponsePtrInput` via:
//
//          TemporaryDiskResponseArgs{...}
//
//  or:
//
//          nil
type TemporaryDiskResponsePtrInput interface {
	pulumi.Input

	ToTemporaryDiskResponsePtrOutput() TemporaryDiskResponsePtrOutput
	ToTemporaryDiskResponsePtrOutputWithContext(context.Context) TemporaryDiskResponsePtrOutput
}

type temporaryDiskResponsePtrType TemporaryDiskResponseArgs

func TemporaryDiskResponsePtr(v *TemporaryDiskResponseArgs) TemporaryDiskResponsePtrInput {
	return (*temporaryDiskResponsePtrType)(v)
}

func (*temporaryDiskResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**TemporaryDiskResponse)(nil)).Elem()
}

func (i *temporaryDiskResponsePtrType) ToTemporaryDiskResponsePtrOutput() TemporaryDiskResponsePtrOutput {
	return i.ToTemporaryDiskResponsePtrOutputWithContext(context.Background())
}

func (i *temporaryDiskResponsePtrType) ToTemporaryDiskResponsePtrOutputWithContext(ctx context.Context) TemporaryDiskResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TemporaryDiskResponsePtrOutput)
}

// Temporary disk payload
type TemporaryDiskResponseOutput struct{ *pulumi.OutputState }

func (TemporaryDiskResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*TemporaryDiskResponse)(nil)).Elem()
}

func (o TemporaryDiskResponseOutput) ToTemporaryDiskResponseOutput() TemporaryDiskResponseOutput {
	return o
}

func (o TemporaryDiskResponseOutput) ToTemporaryDiskResponseOutputWithContext(ctx context.Context) TemporaryDiskResponseOutput {
	return o
}

func (o TemporaryDiskResponseOutput) ToTemporaryDiskResponsePtrOutput() TemporaryDiskResponsePtrOutput {
	return o.ToTemporaryDiskResponsePtrOutputWithContext(context.Background())
}

func (o TemporaryDiskResponseOutput) ToTemporaryDiskResponsePtrOutputWithContext(ctx context.Context) TemporaryDiskResponsePtrOutput {
	return o.ApplyT(func(v TemporaryDiskResponse) *TemporaryDiskResponse {
		return &v
	}).(TemporaryDiskResponsePtrOutput)
}

// Mount path of the temporary disk
func (o TemporaryDiskResponseOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v TemporaryDiskResponse) *string { return v.MountPath }).(pulumi.StringPtrOutput)
}

// Size of the temporary disk in GB
func (o TemporaryDiskResponseOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v TemporaryDiskResponse) *int { return v.SizeInGB }).(pulumi.IntPtrOutput)
}

type TemporaryDiskResponsePtrOutput struct{ *pulumi.OutputState }

func (TemporaryDiskResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**TemporaryDiskResponse)(nil)).Elem()
}

func (o TemporaryDiskResponsePtrOutput) ToTemporaryDiskResponsePtrOutput() TemporaryDiskResponsePtrOutput {
	return o
}

func (o TemporaryDiskResponsePtrOutput) ToTemporaryDiskResponsePtrOutputWithContext(ctx context.Context) TemporaryDiskResponsePtrOutput {
	return o
}

func (o TemporaryDiskResponsePtrOutput) Elem() TemporaryDiskResponseOutput {
	return o.ApplyT(func(v *TemporaryDiskResponse) TemporaryDiskResponse { return *v }).(TemporaryDiskResponseOutput)
}

// Mount path of the temporary disk
func (o TemporaryDiskResponsePtrOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *TemporaryDiskResponse) *string {
		if v == nil {
			return nil
		}
		return v.MountPath
	}).(pulumi.StringPtrOutput)
}

// Size of the temporary disk in GB
func (o TemporaryDiskResponsePtrOutput) SizeInGB() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *TemporaryDiskResponse) *int {
		if v == nil {
			return nil
		}
		return v.SizeInGB
	}).(pulumi.IntPtrOutput)
}

// Source information for a deployment
type UserSourceInfo struct {
	// Selector for the artifact to be used for the deployment for multi-module projects. This should be
	// the relative path to the target module/project.
	ArtifactSelector *string `pulumi:"artifactSelector"`
	// Relative path of the storage which stores the source
	RelativePath *string `pulumi:"relativePath"`
	// Type of the source uploaded
	Type *string `pulumi:"type"`
	// Version of the source
	Version *string `pulumi:"version"`
}

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

	ToUserSourceInfoOutput() UserSourceInfoOutput
	ToUserSourceInfoOutputWithContext(context.Context) UserSourceInfoOutput
}

// Source information for a deployment
type UserSourceInfoArgs struct {
	// Selector for the artifact to be used for the deployment for multi-module projects. This should be
	// the relative path to the target module/project.
	ArtifactSelector pulumi.StringPtrInput `pulumi:"artifactSelector"`
	// Relative path of the storage which stores the source
	RelativePath pulumi.StringPtrInput `pulumi:"relativePath"`
	// Type of the source uploaded
	Type pulumi.StringPtrInput `pulumi:"type"`
	// Version of the source
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (UserSourceInfoArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*UserSourceInfo)(nil)).Elem()
}

func (i UserSourceInfoArgs) ToUserSourceInfoOutput() UserSourceInfoOutput {
	return i.ToUserSourceInfoOutputWithContext(context.Background())
}

func (i UserSourceInfoArgs) ToUserSourceInfoOutputWithContext(ctx context.Context) UserSourceInfoOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserSourceInfoOutput)
}

func (i UserSourceInfoArgs) ToUserSourceInfoPtrOutput() UserSourceInfoPtrOutput {
	return i.ToUserSourceInfoPtrOutputWithContext(context.Background())
}

func (i UserSourceInfoArgs) ToUserSourceInfoPtrOutputWithContext(ctx context.Context) UserSourceInfoPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserSourceInfoOutput).ToUserSourceInfoPtrOutputWithContext(ctx)
}

// UserSourceInfoPtrInput is an input type that accepts UserSourceInfoArgs, UserSourceInfoPtr and UserSourceInfoPtrOutput values.
// You can construct a concrete instance of `UserSourceInfoPtrInput` via:
//
//          UserSourceInfoArgs{...}
//
//  or:
//
//          nil
type UserSourceInfoPtrInput interface {
	pulumi.Input

	ToUserSourceInfoPtrOutput() UserSourceInfoPtrOutput
	ToUserSourceInfoPtrOutputWithContext(context.Context) UserSourceInfoPtrOutput
}

type userSourceInfoPtrType UserSourceInfoArgs

func UserSourceInfoPtr(v *UserSourceInfoArgs) UserSourceInfoPtrInput {
	return (*userSourceInfoPtrType)(v)
}

func (*userSourceInfoPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**UserSourceInfo)(nil)).Elem()
}

func (i *userSourceInfoPtrType) ToUserSourceInfoPtrOutput() UserSourceInfoPtrOutput {
	return i.ToUserSourceInfoPtrOutputWithContext(context.Background())
}

func (i *userSourceInfoPtrType) ToUserSourceInfoPtrOutputWithContext(ctx context.Context) UserSourceInfoPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserSourceInfoPtrOutput)
}

// Source information for a deployment
type UserSourceInfoOutput struct{ *pulumi.OutputState }

func (UserSourceInfoOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*UserSourceInfo)(nil)).Elem()
}

func (o UserSourceInfoOutput) ToUserSourceInfoOutput() UserSourceInfoOutput {
	return o
}

func (o UserSourceInfoOutput) ToUserSourceInfoOutputWithContext(ctx context.Context) UserSourceInfoOutput {
	return o
}

func (o UserSourceInfoOutput) ToUserSourceInfoPtrOutput() UserSourceInfoPtrOutput {
	return o.ToUserSourceInfoPtrOutputWithContext(context.Background())
}

func (o UserSourceInfoOutput) ToUserSourceInfoPtrOutputWithContext(ctx context.Context) UserSourceInfoPtrOutput {
	return o.ApplyT(func(v UserSourceInfo) *UserSourceInfo {
		return &v
	}).(UserSourceInfoPtrOutput)
}

// Selector for the artifact to be used for the deployment for multi-module projects. This should be
// the relative path to the target module/project.
func (o UserSourceInfoOutput) ArtifactSelector() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfo) *string { return v.ArtifactSelector }).(pulumi.StringPtrOutput)
}

// Relative path of the storage which stores the source
func (o UserSourceInfoOutput) RelativePath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfo) *string { return v.RelativePath }).(pulumi.StringPtrOutput)
}

// Type of the source uploaded
func (o UserSourceInfoOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfo) *string { return v.Type }).(pulumi.StringPtrOutput)
}

// Version of the source
func (o UserSourceInfoOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfo) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type UserSourceInfoPtrOutput struct{ *pulumi.OutputState }

func (UserSourceInfoPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**UserSourceInfo)(nil)).Elem()
}

func (o UserSourceInfoPtrOutput) ToUserSourceInfoPtrOutput() UserSourceInfoPtrOutput {
	return o
}

func (o UserSourceInfoPtrOutput) ToUserSourceInfoPtrOutputWithContext(ctx context.Context) UserSourceInfoPtrOutput {
	return o
}

func (o UserSourceInfoPtrOutput) Elem() UserSourceInfoOutput {
	return o.ApplyT(func(v *UserSourceInfo) UserSourceInfo { return *v }).(UserSourceInfoOutput)
}

// Selector for the artifact to be used for the deployment for multi-module projects. This should be
// the relative path to the target module/project.
func (o UserSourceInfoPtrOutput) ArtifactSelector() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfo) *string {
		if v == nil {
			return nil
		}
		return v.ArtifactSelector
	}).(pulumi.StringPtrOutput)
}

// Relative path of the storage which stores the source
func (o UserSourceInfoPtrOutput) RelativePath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfo) *string {
		if v == nil {
			return nil
		}
		return v.RelativePath
	}).(pulumi.StringPtrOutput)
}

// Type of the source uploaded
func (o UserSourceInfoPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfo) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// Version of the source
func (o UserSourceInfoPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfo) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// Source information for a deployment
type UserSourceInfoResponse struct {
	// Selector for the artifact to be used for the deployment for multi-module projects. This should be
	// the relative path to the target module/project.
	ArtifactSelector *string `pulumi:"artifactSelector"`
	// Relative path of the storage which stores the source
	RelativePath *string `pulumi:"relativePath"`
	// Type of the source uploaded
	Type *string `pulumi:"type"`
	// Version of the source
	Version *string `pulumi:"version"`
}

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

	ToUserSourceInfoResponseOutput() UserSourceInfoResponseOutput
	ToUserSourceInfoResponseOutputWithContext(context.Context) UserSourceInfoResponseOutput
}

// Source information for a deployment
type UserSourceInfoResponseArgs struct {
	// Selector for the artifact to be used for the deployment for multi-module projects. This should be
	// the relative path to the target module/project.
	ArtifactSelector pulumi.StringPtrInput `pulumi:"artifactSelector"`
	// Relative path of the storage which stores the source
	RelativePath pulumi.StringPtrInput `pulumi:"relativePath"`
	// Type of the source uploaded
	Type pulumi.StringPtrInput `pulumi:"type"`
	// Version of the source
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (UserSourceInfoResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*UserSourceInfoResponse)(nil)).Elem()
}

func (i UserSourceInfoResponseArgs) ToUserSourceInfoResponseOutput() UserSourceInfoResponseOutput {
	return i.ToUserSourceInfoResponseOutputWithContext(context.Background())
}

func (i UserSourceInfoResponseArgs) ToUserSourceInfoResponseOutputWithContext(ctx context.Context) UserSourceInfoResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserSourceInfoResponseOutput)
}

func (i UserSourceInfoResponseArgs) ToUserSourceInfoResponsePtrOutput() UserSourceInfoResponsePtrOutput {
	return i.ToUserSourceInfoResponsePtrOutputWithContext(context.Background())
}

func (i UserSourceInfoResponseArgs) ToUserSourceInfoResponsePtrOutputWithContext(ctx context.Context) UserSourceInfoResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserSourceInfoResponseOutput).ToUserSourceInfoResponsePtrOutputWithContext(ctx)
}

// UserSourceInfoResponsePtrInput is an input type that accepts UserSourceInfoResponseArgs, UserSourceInfoResponsePtr and UserSourceInfoResponsePtrOutput values.
// You can construct a concrete instance of `UserSourceInfoResponsePtrInput` via:
//
//          UserSourceInfoResponseArgs{...}
//
//  or:
//
//          nil
type UserSourceInfoResponsePtrInput interface {
	pulumi.Input

	ToUserSourceInfoResponsePtrOutput() UserSourceInfoResponsePtrOutput
	ToUserSourceInfoResponsePtrOutputWithContext(context.Context) UserSourceInfoResponsePtrOutput
}

type userSourceInfoResponsePtrType UserSourceInfoResponseArgs

func UserSourceInfoResponsePtr(v *UserSourceInfoResponseArgs) UserSourceInfoResponsePtrInput {
	return (*userSourceInfoResponsePtrType)(v)
}

func (*userSourceInfoResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**UserSourceInfoResponse)(nil)).Elem()
}

func (i *userSourceInfoResponsePtrType) ToUserSourceInfoResponsePtrOutput() UserSourceInfoResponsePtrOutput {
	return i.ToUserSourceInfoResponsePtrOutputWithContext(context.Background())
}

func (i *userSourceInfoResponsePtrType) ToUserSourceInfoResponsePtrOutputWithContext(ctx context.Context) UserSourceInfoResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserSourceInfoResponsePtrOutput)
}

// Source information for a deployment
type UserSourceInfoResponseOutput struct{ *pulumi.OutputState }

func (UserSourceInfoResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*UserSourceInfoResponse)(nil)).Elem()
}

func (o UserSourceInfoResponseOutput) ToUserSourceInfoResponseOutput() UserSourceInfoResponseOutput {
	return o
}

func (o UserSourceInfoResponseOutput) ToUserSourceInfoResponseOutputWithContext(ctx context.Context) UserSourceInfoResponseOutput {
	return o
}

func (o UserSourceInfoResponseOutput) ToUserSourceInfoResponsePtrOutput() UserSourceInfoResponsePtrOutput {
	return o.ToUserSourceInfoResponsePtrOutputWithContext(context.Background())
}

func (o UserSourceInfoResponseOutput) ToUserSourceInfoResponsePtrOutputWithContext(ctx context.Context) UserSourceInfoResponsePtrOutput {
	return o.ApplyT(func(v UserSourceInfoResponse) *UserSourceInfoResponse {
		return &v
	}).(UserSourceInfoResponsePtrOutput)
}

// Selector for the artifact to be used for the deployment for multi-module projects. This should be
// the relative path to the target module/project.
func (o UserSourceInfoResponseOutput) ArtifactSelector() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfoResponse) *string { return v.ArtifactSelector }).(pulumi.StringPtrOutput)
}

// Relative path of the storage which stores the source
func (o UserSourceInfoResponseOutput) RelativePath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfoResponse) *string { return v.RelativePath }).(pulumi.StringPtrOutput)
}

// Type of the source uploaded
func (o UserSourceInfoResponseOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfoResponse) *string { return v.Type }).(pulumi.StringPtrOutput)
}

// Version of the source
func (o UserSourceInfoResponseOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v UserSourceInfoResponse) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type UserSourceInfoResponsePtrOutput struct{ *pulumi.OutputState }

func (UserSourceInfoResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**UserSourceInfoResponse)(nil)).Elem()
}

func (o UserSourceInfoResponsePtrOutput) ToUserSourceInfoResponsePtrOutput() UserSourceInfoResponsePtrOutput {
	return o
}

func (o UserSourceInfoResponsePtrOutput) ToUserSourceInfoResponsePtrOutputWithContext(ctx context.Context) UserSourceInfoResponsePtrOutput {
	return o
}

func (o UserSourceInfoResponsePtrOutput) Elem() UserSourceInfoResponseOutput {
	return o.ApplyT(func(v *UserSourceInfoResponse) UserSourceInfoResponse { return *v }).(UserSourceInfoResponseOutput)
}

// Selector for the artifact to be used for the deployment for multi-module projects. This should be
// the relative path to the target module/project.
func (o UserSourceInfoResponsePtrOutput) ArtifactSelector() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfoResponse) *string {
		if v == nil {
			return nil
		}
		return v.ArtifactSelector
	}).(pulumi.StringPtrOutput)
}

// Relative path of the storage which stores the source
func (o UserSourceInfoResponsePtrOutput) RelativePath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfoResponse) *string {
		if v == nil {
			return nil
		}
		return v.RelativePath
	}).(pulumi.StringPtrOutput)
}

// Type of the source uploaded
func (o UserSourceInfoResponsePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfoResponse) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// Version of the source
func (o UserSourceInfoResponsePtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserSourceInfoResponse) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterOutputType(AppResourcePropertiesOutput{})
	pulumi.RegisterOutputType(AppResourcePropertiesPtrOutput{})
	pulumi.RegisterOutputType(AppResourcePropertiesResponseOutput{})
	pulumi.RegisterOutputType(AppResourcePropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(BindingResourcePropertiesOutput{})
	pulumi.RegisterOutputType(BindingResourcePropertiesPtrOutput{})
	pulumi.RegisterOutputType(BindingResourcePropertiesResponseOutput{})
	pulumi.RegisterOutputType(BindingResourcePropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(CertificatePropertiesOutput{})
	pulumi.RegisterOutputType(CertificatePropertiesPtrOutput{})
	pulumi.RegisterOutputType(CertificatePropertiesResponseOutput{})
	pulumi.RegisterOutputType(CertificatePropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(ClusterResourcePropertiesOutput{})
	pulumi.RegisterOutputType(ClusterResourcePropertiesPtrOutput{})
	pulumi.RegisterOutputType(ClusterResourcePropertiesResponseOutput{})
	pulumi.RegisterOutputType(ClusterResourcePropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(CustomDomainPropertiesOutput{})
	pulumi.RegisterOutputType(CustomDomainPropertiesPtrOutput{})
	pulumi.RegisterOutputType(CustomDomainPropertiesResponseOutput{})
	pulumi.RegisterOutputType(CustomDomainPropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(DeploymentInstanceResponseOutput{})
	pulumi.RegisterOutputType(DeploymentInstanceResponseArrayOutput{})
	pulumi.RegisterOutputType(DeploymentResourcePropertiesOutput{})
	pulumi.RegisterOutputType(DeploymentResourcePropertiesPtrOutput{})
	pulumi.RegisterOutputType(DeploymentResourcePropertiesResponseOutput{})
	pulumi.RegisterOutputType(DeploymentResourcePropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(DeploymentSettingsOutput{})
	pulumi.RegisterOutputType(DeploymentSettingsPtrOutput{})
	pulumi.RegisterOutputType(DeploymentSettingsResponseOutput{})
	pulumi.RegisterOutputType(DeploymentSettingsResponsePtrOutput{})
	pulumi.RegisterOutputType(ManagedIdentityPropertiesOutput{})
	pulumi.RegisterOutputType(ManagedIdentityPropertiesPtrOutput{})
	pulumi.RegisterOutputType(ManagedIdentityPropertiesResponseOutput{})
	pulumi.RegisterOutputType(ManagedIdentityPropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(NetworkProfileOutput{})
	pulumi.RegisterOutputType(NetworkProfilePtrOutput{})
	pulumi.RegisterOutputType(NetworkProfileResponseOutput{})
	pulumi.RegisterOutputType(NetworkProfileResponsePtrOutput{})
	pulumi.RegisterOutputType(NetworkProfileResponseOutboundIPsOutput{})
	pulumi.RegisterOutputType(NetworkProfileResponseOutboundIPsPtrOutput{})
	pulumi.RegisterOutputType(PersistentDiskOutput{})
	pulumi.RegisterOutputType(PersistentDiskPtrOutput{})
	pulumi.RegisterOutputType(PersistentDiskResponseOutput{})
	pulumi.RegisterOutputType(PersistentDiskResponsePtrOutput{})
	pulumi.RegisterOutputType(SkuOutput{})
	pulumi.RegisterOutputType(SkuPtrOutput{})
	pulumi.RegisterOutputType(SkuResponseOutput{})
	pulumi.RegisterOutputType(SkuResponsePtrOutput{})
	pulumi.RegisterOutputType(TemporaryDiskOutput{})
	pulumi.RegisterOutputType(TemporaryDiskPtrOutput{})
	pulumi.RegisterOutputType(TemporaryDiskResponseOutput{})
	pulumi.RegisterOutputType(TemporaryDiskResponsePtrOutput{})
	pulumi.RegisterOutputType(UserSourceInfoOutput{})
	pulumi.RegisterOutputType(UserSourceInfoPtrOutput{})
	pulumi.RegisterOutputType(UserSourceInfoResponseOutput{})
	pulumi.RegisterOutputType(UserSourceInfoResponsePtrOutput{})
}