pulumiTypes.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package loadbalancer

import (
	"context"
	"reflect"

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

type LoadBalancerLink struct {
	Href  *string  `pulumi:"href"`
	Hrefs []string `pulumi:"hrefs"`
	Rel   string   `pulumi:"rel"`
}

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

	ToLoadBalancerLinkOutput() LoadBalancerLinkOutput
	ToLoadBalancerLinkOutputWithContext(context.Context) LoadBalancerLinkOutput
}

type LoadBalancerLinkArgs struct {
	Href  pulumi.StringPtrInput   `pulumi:"href"`
	Hrefs pulumi.StringArrayInput `pulumi:"hrefs"`
	Rel   pulumi.StringInput      `pulumi:"rel"`
}

func (LoadBalancerLinkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerLink)(nil)).Elem()
}

func (i LoadBalancerLinkArgs) ToLoadBalancerLinkOutput() LoadBalancerLinkOutput {
	return i.ToLoadBalancerLinkOutputWithContext(context.Background())
}

func (i LoadBalancerLinkArgs) ToLoadBalancerLinkOutputWithContext(ctx context.Context) LoadBalancerLinkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerLinkOutput)
}

// LoadBalancerLinkArrayInput is an input type that accepts LoadBalancerLinkArray and LoadBalancerLinkArrayOutput values.
// You can construct a concrete instance of `LoadBalancerLinkArrayInput` via:
//
//	LoadBalancerLinkArray{ LoadBalancerLinkArgs{...} }
type LoadBalancerLinkArrayInput interface {
	pulumi.Input

	ToLoadBalancerLinkArrayOutput() LoadBalancerLinkArrayOutput
	ToLoadBalancerLinkArrayOutputWithContext(context.Context) LoadBalancerLinkArrayOutput
}

type LoadBalancerLinkArray []LoadBalancerLinkInput

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

func (i LoadBalancerLinkArray) ToLoadBalancerLinkArrayOutput() LoadBalancerLinkArrayOutput {
	return i.ToLoadBalancerLinkArrayOutputWithContext(context.Background())
}

func (i LoadBalancerLinkArray) ToLoadBalancerLinkArrayOutputWithContext(ctx context.Context) LoadBalancerLinkArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerLinkArrayOutput)
}

type LoadBalancerLinkOutput struct{ *pulumi.OutputState }

func (LoadBalancerLinkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerLink)(nil)).Elem()
}

func (o LoadBalancerLinkOutput) ToLoadBalancerLinkOutput() LoadBalancerLinkOutput {
	return o
}

func (o LoadBalancerLinkOutput) ToLoadBalancerLinkOutputWithContext(ctx context.Context) LoadBalancerLinkOutput {
	return o
}

func (o LoadBalancerLinkOutput) Href() pulumi.StringPtrOutput {
	return o.ApplyT(func(v LoadBalancerLink) *string { return v.Href }).(pulumi.StringPtrOutput)
}

func (o LoadBalancerLinkOutput) Hrefs() pulumi.StringArrayOutput {
	return o.ApplyT(func(v LoadBalancerLink) []string { return v.Hrefs }).(pulumi.StringArrayOutput)
}

func (o LoadBalancerLinkOutput) Rel() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerLink) string { return v.Rel }).(pulumi.StringOutput)
}

type LoadBalancerLinkArrayOutput struct{ *pulumi.OutputState }

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

func (o LoadBalancerLinkArrayOutput) ToLoadBalancerLinkArrayOutput() LoadBalancerLinkArrayOutput {
	return o
}

func (o LoadBalancerLinkArrayOutput) ToLoadBalancerLinkArrayOutputWithContext(ctx context.Context) LoadBalancerLinkArrayOutput {
	return o
}

func (o LoadBalancerLinkArrayOutput) Index(i pulumi.IntInput) LoadBalancerLinkOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerLink {
		return vs[0].([]LoadBalancerLink)[vs[1].(int)]
	}).(LoadBalancerLinkOutput)
}

type LoadBalancerNic struct {
	Addresses []string `pulumi:"addresses"`
	// Additional custom properties that may be used to extend the machine.
	CustomProperties map[string]interface{} `pulumi:"customProperties"`
	// Describes machine within the scope of your organization and is not propagated to the cloud.
	Description *string `pulumi:"description"`
	DeviceIndex *int    `pulumi:"deviceIndex"`
	// A human-friendly name used as an identifier in APIs that support this option.
	Name             *string  `pulumi:"name"`
	NetworkId        string   `pulumi:"networkId"`
	SecurityGroupIds []string `pulumi:"securityGroupIds"`
}

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

	ToLoadBalancerNicOutput() LoadBalancerNicOutput
	ToLoadBalancerNicOutputWithContext(context.Context) LoadBalancerNicOutput
}

type LoadBalancerNicArgs struct {
	Addresses pulumi.StringArrayInput `pulumi:"addresses"`
	// Additional custom properties that may be used to extend the machine.
	CustomProperties pulumi.MapInput `pulumi:"customProperties"`
	// Describes machine within the scope of your organization and is not propagated to the cloud.
	Description pulumi.StringPtrInput `pulumi:"description"`
	DeviceIndex pulumi.IntPtrInput    `pulumi:"deviceIndex"`
	// A human-friendly name used as an identifier in APIs that support this option.
	Name             pulumi.StringPtrInput   `pulumi:"name"`
	NetworkId        pulumi.StringInput      `pulumi:"networkId"`
	SecurityGroupIds pulumi.StringArrayInput `pulumi:"securityGroupIds"`
}

func (LoadBalancerNicArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerNic)(nil)).Elem()
}

func (i LoadBalancerNicArgs) ToLoadBalancerNicOutput() LoadBalancerNicOutput {
	return i.ToLoadBalancerNicOutputWithContext(context.Background())
}

func (i LoadBalancerNicArgs) ToLoadBalancerNicOutputWithContext(ctx context.Context) LoadBalancerNicOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerNicOutput)
}

// LoadBalancerNicArrayInput is an input type that accepts LoadBalancerNicArray and LoadBalancerNicArrayOutput values.
// You can construct a concrete instance of `LoadBalancerNicArrayInput` via:
//
//	LoadBalancerNicArray{ LoadBalancerNicArgs{...} }
type LoadBalancerNicArrayInput interface {
	pulumi.Input

	ToLoadBalancerNicArrayOutput() LoadBalancerNicArrayOutput
	ToLoadBalancerNicArrayOutputWithContext(context.Context) LoadBalancerNicArrayOutput
}

type LoadBalancerNicArray []LoadBalancerNicInput

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

func (i LoadBalancerNicArray) ToLoadBalancerNicArrayOutput() LoadBalancerNicArrayOutput {
	return i.ToLoadBalancerNicArrayOutputWithContext(context.Background())
}

func (i LoadBalancerNicArray) ToLoadBalancerNicArrayOutputWithContext(ctx context.Context) LoadBalancerNicArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerNicArrayOutput)
}

type LoadBalancerNicOutput struct{ *pulumi.OutputState }

func (LoadBalancerNicOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerNic)(nil)).Elem()
}

func (o LoadBalancerNicOutput) ToLoadBalancerNicOutput() LoadBalancerNicOutput {
	return o
}

func (o LoadBalancerNicOutput) ToLoadBalancerNicOutputWithContext(ctx context.Context) LoadBalancerNicOutput {
	return o
}

func (o LoadBalancerNicOutput) Addresses() pulumi.StringArrayOutput {
	return o.ApplyT(func(v LoadBalancerNic) []string { return v.Addresses }).(pulumi.StringArrayOutput)
}

// Additional custom properties that may be used to extend the machine.
func (o LoadBalancerNicOutput) CustomProperties() pulumi.MapOutput {
	return o.ApplyT(func(v LoadBalancerNic) map[string]interface{} { return v.CustomProperties }).(pulumi.MapOutput)
}

// Describes machine within the scope of your organization and is not propagated to the cloud.
func (o LoadBalancerNicOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v LoadBalancerNic) *string { return v.Description }).(pulumi.StringPtrOutput)
}

func (o LoadBalancerNicOutput) DeviceIndex() pulumi.IntPtrOutput {
	return o.ApplyT(func(v LoadBalancerNic) *int { return v.DeviceIndex }).(pulumi.IntPtrOutput)
}

// A human-friendly name used as an identifier in APIs that support this option.
func (o LoadBalancerNicOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v LoadBalancerNic) *string { return v.Name }).(pulumi.StringPtrOutput)
}

func (o LoadBalancerNicOutput) NetworkId() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerNic) string { return v.NetworkId }).(pulumi.StringOutput)
}

func (o LoadBalancerNicOutput) SecurityGroupIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v LoadBalancerNic) []string { return v.SecurityGroupIds }).(pulumi.StringArrayOutput)
}

type LoadBalancerNicArrayOutput struct{ *pulumi.OutputState }

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

func (o LoadBalancerNicArrayOutput) ToLoadBalancerNicArrayOutput() LoadBalancerNicArrayOutput {
	return o
}

func (o LoadBalancerNicArrayOutput) ToLoadBalancerNicArrayOutputWithContext(ctx context.Context) LoadBalancerNicArrayOutput {
	return o
}

func (o LoadBalancerNicArrayOutput) Index(i pulumi.IntInput) LoadBalancerNicOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerNic {
		return vs[0].([]LoadBalancerNic)[vs[1].(int)]
	}).(LoadBalancerNicOutput)
}

type LoadBalancerRoute struct {
	// Load balancer health check configuration.
	HealthCheckConfigurations []LoadBalancerRouteHealthCheckConfiguration `pulumi:"healthCheckConfigurations"`
	// Member port where the traffic is routed to.
	MemberPort string `pulumi:"memberPort"`
	// The protocol of the member traffic.
	MemberProtocol string `pulumi:"memberProtocol"`
	// Port which the load balancer is listening to.
	Port string `pulumi:"port"`
	// The protocol of the incoming load balancer requests.
	Protocol string `pulumi:"protocol"`
}

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

	ToLoadBalancerRouteOutput() LoadBalancerRouteOutput
	ToLoadBalancerRouteOutputWithContext(context.Context) LoadBalancerRouteOutput
}

type LoadBalancerRouteArgs struct {
	// Load balancer health check configuration.
	HealthCheckConfigurations LoadBalancerRouteHealthCheckConfigurationArrayInput `pulumi:"healthCheckConfigurations"`
	// Member port where the traffic is routed to.
	MemberPort pulumi.StringInput `pulumi:"memberPort"`
	// The protocol of the member traffic.
	MemberProtocol pulumi.StringInput `pulumi:"memberProtocol"`
	// Port which the load balancer is listening to.
	Port pulumi.StringInput `pulumi:"port"`
	// The protocol of the incoming load balancer requests.
	Protocol pulumi.StringInput `pulumi:"protocol"`
}

func (LoadBalancerRouteArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerRoute)(nil)).Elem()
}

func (i LoadBalancerRouteArgs) ToLoadBalancerRouteOutput() LoadBalancerRouteOutput {
	return i.ToLoadBalancerRouteOutputWithContext(context.Background())
}

func (i LoadBalancerRouteArgs) ToLoadBalancerRouteOutputWithContext(ctx context.Context) LoadBalancerRouteOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerRouteOutput)
}

// LoadBalancerRouteArrayInput is an input type that accepts LoadBalancerRouteArray and LoadBalancerRouteArrayOutput values.
// You can construct a concrete instance of `LoadBalancerRouteArrayInput` via:
//
//	LoadBalancerRouteArray{ LoadBalancerRouteArgs{...} }
type LoadBalancerRouteArrayInput interface {
	pulumi.Input

	ToLoadBalancerRouteArrayOutput() LoadBalancerRouteArrayOutput
	ToLoadBalancerRouteArrayOutputWithContext(context.Context) LoadBalancerRouteArrayOutput
}

type LoadBalancerRouteArray []LoadBalancerRouteInput

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

func (i LoadBalancerRouteArray) ToLoadBalancerRouteArrayOutput() LoadBalancerRouteArrayOutput {
	return i.ToLoadBalancerRouteArrayOutputWithContext(context.Background())
}

func (i LoadBalancerRouteArray) ToLoadBalancerRouteArrayOutputWithContext(ctx context.Context) LoadBalancerRouteArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerRouteArrayOutput)
}

type LoadBalancerRouteOutput struct{ *pulumi.OutputState }

func (LoadBalancerRouteOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerRoute)(nil)).Elem()
}

func (o LoadBalancerRouteOutput) ToLoadBalancerRouteOutput() LoadBalancerRouteOutput {
	return o
}

func (o LoadBalancerRouteOutput) ToLoadBalancerRouteOutputWithContext(ctx context.Context) LoadBalancerRouteOutput {
	return o
}

// Load balancer health check configuration.
func (o LoadBalancerRouteOutput) HealthCheckConfigurations() LoadBalancerRouteHealthCheckConfigurationArrayOutput {
	return o.ApplyT(func(v LoadBalancerRoute) []LoadBalancerRouteHealthCheckConfiguration {
		return v.HealthCheckConfigurations
	}).(LoadBalancerRouteHealthCheckConfigurationArrayOutput)
}

// Member port where the traffic is routed to.
func (o LoadBalancerRouteOutput) MemberPort() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerRoute) string { return v.MemberPort }).(pulumi.StringOutput)
}

// The protocol of the member traffic.
func (o LoadBalancerRouteOutput) MemberProtocol() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerRoute) string { return v.MemberProtocol }).(pulumi.StringOutput)
}

// Port which the load balancer is listening to.
func (o LoadBalancerRouteOutput) Port() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerRoute) string { return v.Port }).(pulumi.StringOutput)
}

// The protocol of the incoming load balancer requests.
func (o LoadBalancerRouteOutput) Protocol() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerRoute) string { return v.Protocol }).(pulumi.StringOutput)
}

type LoadBalancerRouteArrayOutput struct{ *pulumi.OutputState }

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

func (o LoadBalancerRouteArrayOutput) ToLoadBalancerRouteArrayOutput() LoadBalancerRouteArrayOutput {
	return o
}

func (o LoadBalancerRouteArrayOutput) ToLoadBalancerRouteArrayOutputWithContext(ctx context.Context) LoadBalancerRouteArrayOutput {
	return o
}

func (o LoadBalancerRouteArrayOutput) Index(i pulumi.IntInput) LoadBalancerRouteOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerRoute {
		return vs[0].([]LoadBalancerRoute)[vs[1].(int)]
	}).(LoadBalancerRouteOutput)
}

type LoadBalancerRouteHealthCheckConfiguration struct {
	// Number of consecutive successful checks before considering a particular back-end instance as healthy.
	HealthyThreshold *int `pulumi:"healthyThreshold"`
	// Interval (in seconds) at which the health checks will be performed.
	IntervalSeconds *int `pulumi:"intervalSeconds"`
	// Port which the load balancer is listening to.
	Port string `pulumi:"port"`
	// The protocol of the incoming load balancer requests.
	Protocol string `pulumi:"protocol"`
	// Timeout (in seconds) to wait for a response from the back-end instance.
	TimeoutSeconds     *int    `pulumi:"timeoutSeconds"`
	UnhealthyThreshold *int    `pulumi:"unhealthyThreshold"`
	UrlPath            *string `pulumi:"urlPath"`
}

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

	ToLoadBalancerRouteHealthCheckConfigurationOutput() LoadBalancerRouteHealthCheckConfigurationOutput
	ToLoadBalancerRouteHealthCheckConfigurationOutputWithContext(context.Context) LoadBalancerRouteHealthCheckConfigurationOutput
}

type LoadBalancerRouteHealthCheckConfigurationArgs struct {
	// Number of consecutive successful checks before considering a particular back-end instance as healthy.
	HealthyThreshold pulumi.IntPtrInput `pulumi:"healthyThreshold"`
	// Interval (in seconds) at which the health checks will be performed.
	IntervalSeconds pulumi.IntPtrInput `pulumi:"intervalSeconds"`
	// Port which the load balancer is listening to.
	Port pulumi.StringInput `pulumi:"port"`
	// The protocol of the incoming load balancer requests.
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// Timeout (in seconds) to wait for a response from the back-end instance.
	TimeoutSeconds     pulumi.IntPtrInput    `pulumi:"timeoutSeconds"`
	UnhealthyThreshold pulumi.IntPtrInput    `pulumi:"unhealthyThreshold"`
	UrlPath            pulumi.StringPtrInput `pulumi:"urlPath"`
}

func (LoadBalancerRouteHealthCheckConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerRouteHealthCheckConfiguration)(nil)).Elem()
}

func (i LoadBalancerRouteHealthCheckConfigurationArgs) ToLoadBalancerRouteHealthCheckConfigurationOutput() LoadBalancerRouteHealthCheckConfigurationOutput {
	return i.ToLoadBalancerRouteHealthCheckConfigurationOutputWithContext(context.Background())
}

func (i LoadBalancerRouteHealthCheckConfigurationArgs) ToLoadBalancerRouteHealthCheckConfigurationOutputWithContext(ctx context.Context) LoadBalancerRouteHealthCheckConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerRouteHealthCheckConfigurationOutput)
}

// LoadBalancerRouteHealthCheckConfigurationArrayInput is an input type that accepts LoadBalancerRouteHealthCheckConfigurationArray and LoadBalancerRouteHealthCheckConfigurationArrayOutput values.
// You can construct a concrete instance of `LoadBalancerRouteHealthCheckConfigurationArrayInput` via:
//
//	LoadBalancerRouteHealthCheckConfigurationArray{ LoadBalancerRouteHealthCheckConfigurationArgs{...} }
type LoadBalancerRouteHealthCheckConfigurationArrayInput interface {
	pulumi.Input

	ToLoadBalancerRouteHealthCheckConfigurationArrayOutput() LoadBalancerRouteHealthCheckConfigurationArrayOutput
	ToLoadBalancerRouteHealthCheckConfigurationArrayOutputWithContext(context.Context) LoadBalancerRouteHealthCheckConfigurationArrayOutput
}

type LoadBalancerRouteHealthCheckConfigurationArray []LoadBalancerRouteHealthCheckConfigurationInput

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

func (i LoadBalancerRouteHealthCheckConfigurationArray) ToLoadBalancerRouteHealthCheckConfigurationArrayOutput() LoadBalancerRouteHealthCheckConfigurationArrayOutput {
	return i.ToLoadBalancerRouteHealthCheckConfigurationArrayOutputWithContext(context.Background())
}

func (i LoadBalancerRouteHealthCheckConfigurationArray) ToLoadBalancerRouteHealthCheckConfigurationArrayOutputWithContext(ctx context.Context) LoadBalancerRouteHealthCheckConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerRouteHealthCheckConfigurationArrayOutput)
}

type LoadBalancerRouteHealthCheckConfigurationOutput struct{ *pulumi.OutputState }

func (LoadBalancerRouteHealthCheckConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerRouteHealthCheckConfiguration)(nil)).Elem()
}

func (o LoadBalancerRouteHealthCheckConfigurationOutput) ToLoadBalancerRouteHealthCheckConfigurationOutput() LoadBalancerRouteHealthCheckConfigurationOutput {
	return o
}

func (o LoadBalancerRouteHealthCheckConfigurationOutput) ToLoadBalancerRouteHealthCheckConfigurationOutputWithContext(ctx context.Context) LoadBalancerRouteHealthCheckConfigurationOutput {
	return o
}

// Number of consecutive successful checks before considering a particular back-end instance as healthy.
func (o LoadBalancerRouteHealthCheckConfigurationOutput) HealthyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) *int { return v.HealthyThreshold }).(pulumi.IntPtrOutput)
}

// Interval (in seconds) at which the health checks will be performed.
func (o LoadBalancerRouteHealthCheckConfigurationOutput) IntervalSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) *int { return v.IntervalSeconds }).(pulumi.IntPtrOutput)
}

// Port which the load balancer is listening to.
func (o LoadBalancerRouteHealthCheckConfigurationOutput) Port() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) string { return v.Port }).(pulumi.StringOutput)
}

// The protocol of the incoming load balancer requests.
func (o LoadBalancerRouteHealthCheckConfigurationOutput) Protocol() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) string { return v.Protocol }).(pulumi.StringOutput)
}

// Timeout (in seconds) to wait for a response from the back-end instance.
func (o LoadBalancerRouteHealthCheckConfigurationOutput) TimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) *int { return v.TimeoutSeconds }).(pulumi.IntPtrOutput)
}

func (o LoadBalancerRouteHealthCheckConfigurationOutput) UnhealthyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) *int { return v.UnhealthyThreshold }).(pulumi.IntPtrOutput)
}

func (o LoadBalancerRouteHealthCheckConfigurationOutput) UrlPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v LoadBalancerRouteHealthCheckConfiguration) *string { return v.UrlPath }).(pulumi.StringPtrOutput)
}

type LoadBalancerRouteHealthCheckConfigurationArrayOutput struct{ *pulumi.OutputState }

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

func (o LoadBalancerRouteHealthCheckConfigurationArrayOutput) ToLoadBalancerRouteHealthCheckConfigurationArrayOutput() LoadBalancerRouteHealthCheckConfigurationArrayOutput {
	return o
}

func (o LoadBalancerRouteHealthCheckConfigurationArrayOutput) ToLoadBalancerRouteHealthCheckConfigurationArrayOutputWithContext(ctx context.Context) LoadBalancerRouteHealthCheckConfigurationArrayOutput {
	return o
}

func (o LoadBalancerRouteHealthCheckConfigurationArrayOutput) Index(i pulumi.IntInput) LoadBalancerRouteHealthCheckConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerRouteHealthCheckConfiguration {
		return vs[0].([]LoadBalancerRouteHealthCheckConfiguration)[vs[1].(int)]
	}).(LoadBalancerRouteHealthCheckConfigurationOutput)
}

type LoadBalancerTag struct {
	// Tag’s key.
	Key string `pulumi:"key"`
	// Tag’s value.
	Value string `pulumi:"value"`
}

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

	ToLoadBalancerTagOutput() LoadBalancerTagOutput
	ToLoadBalancerTagOutputWithContext(context.Context) LoadBalancerTagOutput
}

type LoadBalancerTagArgs struct {
	// Tag’s key.
	Key pulumi.StringInput `pulumi:"key"`
	// Tag’s value.
	Value pulumi.StringInput `pulumi:"value"`
}

func (LoadBalancerTagArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerTag)(nil)).Elem()
}

func (i LoadBalancerTagArgs) ToLoadBalancerTagOutput() LoadBalancerTagOutput {
	return i.ToLoadBalancerTagOutputWithContext(context.Background())
}

func (i LoadBalancerTagArgs) ToLoadBalancerTagOutputWithContext(ctx context.Context) LoadBalancerTagOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerTagOutput)
}

// LoadBalancerTagArrayInput is an input type that accepts LoadBalancerTagArray and LoadBalancerTagArrayOutput values.
// You can construct a concrete instance of `LoadBalancerTagArrayInput` via:
//
//	LoadBalancerTagArray{ LoadBalancerTagArgs{...} }
type LoadBalancerTagArrayInput interface {
	pulumi.Input

	ToLoadBalancerTagArrayOutput() LoadBalancerTagArrayOutput
	ToLoadBalancerTagArrayOutputWithContext(context.Context) LoadBalancerTagArrayOutput
}

type LoadBalancerTagArray []LoadBalancerTagInput

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

func (i LoadBalancerTagArray) ToLoadBalancerTagArrayOutput() LoadBalancerTagArrayOutput {
	return i.ToLoadBalancerTagArrayOutputWithContext(context.Background())
}

func (i LoadBalancerTagArray) ToLoadBalancerTagArrayOutputWithContext(ctx context.Context) LoadBalancerTagArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerTagArrayOutput)
}

type LoadBalancerTagOutput struct{ *pulumi.OutputState }

func (LoadBalancerTagOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerTag)(nil)).Elem()
}

func (o LoadBalancerTagOutput) ToLoadBalancerTagOutput() LoadBalancerTagOutput {
	return o
}

func (o LoadBalancerTagOutput) ToLoadBalancerTagOutputWithContext(ctx context.Context) LoadBalancerTagOutput {
	return o
}

// Tag’s key.
func (o LoadBalancerTagOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerTag) string { return v.Key }).(pulumi.StringOutput)
}

// Tag’s value.
func (o LoadBalancerTagOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerTag) string { return v.Value }).(pulumi.StringOutput)
}

type LoadBalancerTagArrayOutput struct{ *pulumi.OutputState }

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

func (o LoadBalancerTagArrayOutput) ToLoadBalancerTagArrayOutput() LoadBalancerTagArrayOutput {
	return o
}

func (o LoadBalancerTagArrayOutput) ToLoadBalancerTagArrayOutputWithContext(ctx context.Context) LoadBalancerTagArrayOutput {
	return o
}

func (o LoadBalancerTagArrayOutput) Index(i pulumi.IntInput) LoadBalancerTagOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerTag {
		return vs[0].([]LoadBalancerTag)[vs[1].(int)]
	}).(LoadBalancerTagOutput)
}

type LoadBalancerTarget struct {
	MachineId          string  `pulumi:"machineId"`
	NetworkInterfaceId *string `pulumi:"networkInterfaceId"`
}

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

	ToLoadBalancerTargetOutput() LoadBalancerTargetOutput
	ToLoadBalancerTargetOutputWithContext(context.Context) LoadBalancerTargetOutput
}

type LoadBalancerTargetArgs struct {
	MachineId          pulumi.StringInput    `pulumi:"machineId"`
	NetworkInterfaceId pulumi.StringPtrInput `pulumi:"networkInterfaceId"`
}

func (LoadBalancerTargetArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerTarget)(nil)).Elem()
}

func (i LoadBalancerTargetArgs) ToLoadBalancerTargetOutput() LoadBalancerTargetOutput {
	return i.ToLoadBalancerTargetOutputWithContext(context.Background())
}

func (i LoadBalancerTargetArgs) ToLoadBalancerTargetOutputWithContext(ctx context.Context) LoadBalancerTargetOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerTargetOutput)
}

// LoadBalancerTargetArrayInput is an input type that accepts LoadBalancerTargetArray and LoadBalancerTargetArrayOutput values.
// You can construct a concrete instance of `LoadBalancerTargetArrayInput` via:
//
//	LoadBalancerTargetArray{ LoadBalancerTargetArgs{...} }
type LoadBalancerTargetArrayInput interface {
	pulumi.Input

	ToLoadBalancerTargetArrayOutput() LoadBalancerTargetArrayOutput
	ToLoadBalancerTargetArrayOutputWithContext(context.Context) LoadBalancerTargetArrayOutput
}

type LoadBalancerTargetArray []LoadBalancerTargetInput

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

func (i LoadBalancerTargetArray) ToLoadBalancerTargetArrayOutput() LoadBalancerTargetArrayOutput {
	return i.ToLoadBalancerTargetArrayOutputWithContext(context.Background())
}

func (i LoadBalancerTargetArray) ToLoadBalancerTargetArrayOutputWithContext(ctx context.Context) LoadBalancerTargetArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(LoadBalancerTargetArrayOutput)
}

type LoadBalancerTargetOutput struct{ *pulumi.OutputState }

func (LoadBalancerTargetOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*LoadBalancerTarget)(nil)).Elem()
}

func (o LoadBalancerTargetOutput) ToLoadBalancerTargetOutput() LoadBalancerTargetOutput {
	return o
}

func (o LoadBalancerTargetOutput) ToLoadBalancerTargetOutputWithContext(ctx context.Context) LoadBalancerTargetOutput {
	return o
}

func (o LoadBalancerTargetOutput) MachineId() pulumi.StringOutput {
	return o.ApplyT(func(v LoadBalancerTarget) string { return v.MachineId }).(pulumi.StringOutput)
}

func (o LoadBalancerTargetOutput) NetworkInterfaceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v LoadBalancerTarget) *string { return v.NetworkInterfaceId }).(pulumi.StringPtrOutput)
}

type LoadBalancerTargetArrayOutput struct{ *pulumi.OutputState }

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

func (o LoadBalancerTargetArrayOutput) ToLoadBalancerTargetArrayOutput() LoadBalancerTargetArrayOutput {
	return o
}

func (o LoadBalancerTargetArrayOutput) ToLoadBalancerTargetArrayOutputWithContext(ctx context.Context) LoadBalancerTargetArrayOutput {
	return o
}

func (o LoadBalancerTargetArrayOutput) Index(i pulumi.IntInput) LoadBalancerTargetOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadBalancerTarget {
		return vs[0].([]LoadBalancerTarget)[vs[1].(int)]
	}).(LoadBalancerTargetOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerLinkInput)(nil)).Elem(), LoadBalancerLinkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerLinkArrayInput)(nil)).Elem(), LoadBalancerLinkArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerNicInput)(nil)).Elem(), LoadBalancerNicArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerNicArrayInput)(nil)).Elem(), LoadBalancerNicArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerRouteInput)(nil)).Elem(), LoadBalancerRouteArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerRouteArrayInput)(nil)).Elem(), LoadBalancerRouteArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerRouteHealthCheckConfigurationInput)(nil)).Elem(), LoadBalancerRouteHealthCheckConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerRouteHealthCheckConfigurationArrayInput)(nil)).Elem(), LoadBalancerRouteHealthCheckConfigurationArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerTagInput)(nil)).Elem(), LoadBalancerTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerTagArrayInput)(nil)).Elem(), LoadBalancerTagArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerTargetInput)(nil)).Elem(), LoadBalancerTargetArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*LoadBalancerTargetArrayInput)(nil)).Elem(), LoadBalancerTargetArray{})
	pulumi.RegisterOutputType(LoadBalancerLinkOutput{})
	pulumi.RegisterOutputType(LoadBalancerLinkArrayOutput{})
	pulumi.RegisterOutputType(LoadBalancerNicOutput{})
	pulumi.RegisterOutputType(LoadBalancerNicArrayOutput{})
	pulumi.RegisterOutputType(LoadBalancerRouteOutput{})
	pulumi.RegisterOutputType(LoadBalancerRouteArrayOutput{})
	pulumi.RegisterOutputType(LoadBalancerRouteHealthCheckConfigurationOutput{})
	pulumi.RegisterOutputType(LoadBalancerRouteHealthCheckConfigurationArrayOutput{})
	pulumi.RegisterOutputType(LoadBalancerTagOutput{})
	pulumi.RegisterOutputType(LoadBalancerTagArrayOutput{})
	pulumi.RegisterOutputType(LoadBalancerTargetOutput{})
	pulumi.RegisterOutputType(LoadBalancerTargetArrayOutput{})
}