// Code generated by pulumi-language-go DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package incus

import (
	"context"
	"reflect"

	"errors"
	"git.kalinow.ski/kiterun/pulumi-incus/sdk/go/incus/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

type NetworkLoadBalancer struct {
	pulumi.CustomResourceState

	// Network load balancer backend
	Backends      NetworkLoadBalancerBackendArrayOutput `pulumi:"backends"`
	Config        pulumi.StringMapOutput                `pulumi:"config"`
	Description   pulumi.StringOutput                   `pulumi:"description"`
	ListenAddress pulumi.StringOutput                   `pulumi:"listenAddress"`
	Network       pulumi.StringOutput                   `pulumi:"network"`
	// Network load balancer port
	Ports   NetworkLoadBalancerPortArrayOutput `pulumi:"ports"`
	Project pulumi.StringPtrOutput             `pulumi:"project"`
	Remote  pulumi.StringPtrOutput             `pulumi:"remote"`
}

// NewNetworkLoadBalancer registers a new resource with the given unique name, arguments, and options.
func NewNetworkLoadBalancer(ctx *pulumi.Context,
	name string, args *NetworkLoadBalancerArgs, opts ...pulumi.ResourceOption) (*NetworkLoadBalancer, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.ListenAddress == nil {
		return nil, errors.New("invalid value for required argument 'ListenAddress'")
	}
	if args.Network == nil {
		return nil, errors.New("invalid value for required argument 'Network'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource NetworkLoadBalancer
	err := ctx.RegisterResource("incus:index/networkLoadBalancer:NetworkLoadBalancer", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetNetworkLoadBalancer gets an existing NetworkLoadBalancer resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetNetworkLoadBalancer(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NetworkLoadBalancerState, opts ...pulumi.ResourceOption) (*NetworkLoadBalancer, error) {
	var resource NetworkLoadBalancer
	err := ctx.ReadResource("incus:index/networkLoadBalancer:NetworkLoadBalancer", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering NetworkLoadBalancer resources.
type networkLoadBalancerState struct {
	// Network load balancer backend
	Backends      []NetworkLoadBalancerBackend `pulumi:"backends"`
	Config        map[string]string            `pulumi:"config"`
	Description   *string                      `pulumi:"description"`
	ListenAddress *string                      `pulumi:"listenAddress"`
	Network       *string                      `pulumi:"network"`
	// Network load balancer port
	Ports   []NetworkLoadBalancerPort `pulumi:"ports"`
	Project *string                   `pulumi:"project"`
	Remote  *string                   `pulumi:"remote"`
}

type NetworkLoadBalancerState struct {
	// Network load balancer backend
	Backends      NetworkLoadBalancerBackendArrayInput
	Config        pulumi.StringMapInput
	Description   pulumi.StringPtrInput
	ListenAddress pulumi.StringPtrInput
	Network       pulumi.StringPtrInput
	// Network load balancer port
	Ports   NetworkLoadBalancerPortArrayInput
	Project pulumi.StringPtrInput
	Remote  pulumi.StringPtrInput
}

func (NetworkLoadBalancerState) ElementType() reflect.Type {
	return reflect.TypeOf((*networkLoadBalancerState)(nil)).Elem()
}

type networkLoadBalancerArgs struct {
	// Network load balancer backend
	Backends      []NetworkLoadBalancerBackend `pulumi:"backends"`
	Config        map[string]string            `pulumi:"config"`
	Description   *string                      `pulumi:"description"`
	ListenAddress string                       `pulumi:"listenAddress"`
	Network       string                       `pulumi:"network"`
	// Network load balancer port
	Ports   []NetworkLoadBalancerPort `pulumi:"ports"`
	Project *string                   `pulumi:"project"`
	Remote  *string                   `pulumi:"remote"`
}

// The set of arguments for constructing a NetworkLoadBalancer resource.
type NetworkLoadBalancerArgs struct {
	// Network load balancer backend
	Backends      NetworkLoadBalancerBackendArrayInput
	Config        pulumi.StringMapInput
	Description   pulumi.StringPtrInput
	ListenAddress pulumi.StringInput
	Network       pulumi.StringInput
	// Network load balancer port
	Ports   NetworkLoadBalancerPortArrayInput
	Project pulumi.StringPtrInput
	Remote  pulumi.StringPtrInput
}

func (NetworkLoadBalancerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*networkLoadBalancerArgs)(nil)).Elem()
}

type NetworkLoadBalancerInput interface {
	pulumi.Input

	ToNetworkLoadBalancerOutput() NetworkLoadBalancerOutput
	ToNetworkLoadBalancerOutputWithContext(ctx context.Context) NetworkLoadBalancerOutput
}

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

func (i *NetworkLoadBalancer) ToNetworkLoadBalancerOutput() NetworkLoadBalancerOutput {
	return i.ToNetworkLoadBalancerOutputWithContext(context.Background())
}

func (i *NetworkLoadBalancer) ToNetworkLoadBalancerOutputWithContext(ctx context.Context) NetworkLoadBalancerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkLoadBalancerOutput)
}

// NetworkLoadBalancerArrayInput is an input type that accepts NetworkLoadBalancerArray and NetworkLoadBalancerArrayOutput values.
// You can construct a concrete instance of `NetworkLoadBalancerArrayInput` via:
//
//	NetworkLoadBalancerArray{ NetworkLoadBalancerArgs{...} }
type NetworkLoadBalancerArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancerArrayOutput() NetworkLoadBalancerArrayOutput
	ToNetworkLoadBalancerArrayOutputWithContext(context.Context) NetworkLoadBalancerArrayOutput
}

type NetworkLoadBalancerArray []NetworkLoadBalancerInput

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

func (i NetworkLoadBalancerArray) ToNetworkLoadBalancerArrayOutput() NetworkLoadBalancerArrayOutput {
	return i.ToNetworkLoadBalancerArrayOutputWithContext(context.Background())
}

func (i NetworkLoadBalancerArray) ToNetworkLoadBalancerArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkLoadBalancerArrayOutput)
}

// NetworkLoadBalancerMapInput is an input type that accepts NetworkLoadBalancerMap and NetworkLoadBalancerMapOutput values.
// You can construct a concrete instance of `NetworkLoadBalancerMapInput` via:
//
//	NetworkLoadBalancerMap{ "key": NetworkLoadBalancerArgs{...} }
type NetworkLoadBalancerMapInput interface {
	pulumi.Input

	ToNetworkLoadBalancerMapOutput() NetworkLoadBalancerMapOutput
	ToNetworkLoadBalancerMapOutputWithContext(context.Context) NetworkLoadBalancerMapOutput
}

type NetworkLoadBalancerMap map[string]NetworkLoadBalancerInput

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

func (i NetworkLoadBalancerMap) ToNetworkLoadBalancerMapOutput() NetworkLoadBalancerMapOutput {
	return i.ToNetworkLoadBalancerMapOutputWithContext(context.Background())
}

func (i NetworkLoadBalancerMap) ToNetworkLoadBalancerMapOutputWithContext(ctx context.Context) NetworkLoadBalancerMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(NetworkLoadBalancerMapOutput)
}

type NetworkLoadBalancerOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**NetworkLoadBalancer)(nil)).Elem()
}

func (o NetworkLoadBalancerOutput) ToNetworkLoadBalancerOutput() NetworkLoadBalancerOutput {
	return o
}

func (o NetworkLoadBalancerOutput) ToNetworkLoadBalancerOutputWithContext(ctx context.Context) NetworkLoadBalancerOutput {
	return o
}

// Network load balancer backend
func (o NetworkLoadBalancerOutput) Backends() NetworkLoadBalancerBackendArrayOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) NetworkLoadBalancerBackendArrayOutput { return v.Backends }).(NetworkLoadBalancerBackendArrayOutput)
}

func (o NetworkLoadBalancerOutput) Config() pulumi.StringMapOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) pulumi.StringMapOutput { return v.Config }).(pulumi.StringMapOutput)
}

func (o NetworkLoadBalancerOutput) Description() pulumi.StringOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput)
}

func (o NetworkLoadBalancerOutput) ListenAddress() pulumi.StringOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) pulumi.StringOutput { return v.ListenAddress }).(pulumi.StringOutput)
}

func (o NetworkLoadBalancerOutput) Network() pulumi.StringOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) pulumi.StringOutput { return v.Network }).(pulumi.StringOutput)
}

// Network load balancer port
func (o NetworkLoadBalancerOutput) Ports() NetworkLoadBalancerPortArrayOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) NetworkLoadBalancerPortArrayOutput { return v.Ports }).(NetworkLoadBalancerPortArrayOutput)
}

func (o NetworkLoadBalancerOutput) Project() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) pulumi.StringPtrOutput { return v.Project }).(pulumi.StringPtrOutput)
}

func (o NetworkLoadBalancerOutput) Remote() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *NetworkLoadBalancer) pulumi.StringPtrOutput { return v.Remote }).(pulumi.StringPtrOutput)
}

type NetworkLoadBalancerArrayOutput struct{ *pulumi.OutputState }

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

func (o NetworkLoadBalancerArrayOutput) ToNetworkLoadBalancerArrayOutput() NetworkLoadBalancerArrayOutput {
	return o
}

func (o NetworkLoadBalancerArrayOutput) ToNetworkLoadBalancerArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerArrayOutput {
	return o
}

func (o NetworkLoadBalancerArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkLoadBalancer {
		return vs[0].([]*NetworkLoadBalancer)[vs[1].(int)]
	}).(NetworkLoadBalancerOutput)
}

type NetworkLoadBalancerMapOutput struct{ *pulumi.OutputState }

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

func (o NetworkLoadBalancerMapOutput) ToNetworkLoadBalancerMapOutput() NetworkLoadBalancerMapOutput {
	return o
}

func (o NetworkLoadBalancerMapOutput) ToNetworkLoadBalancerMapOutputWithContext(ctx context.Context) NetworkLoadBalancerMapOutput {
	return o
}

func (o NetworkLoadBalancerMapOutput) MapIndex(k pulumi.StringInput) NetworkLoadBalancerOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkLoadBalancer {
		return vs[0].(map[string]*NetworkLoadBalancer)[vs[1].(string)]
	}).(NetworkLoadBalancerOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*NetworkLoadBalancerInput)(nil)).Elem(), &NetworkLoadBalancer{})
	pulumi.RegisterInputType(reflect.TypeOf((*NetworkLoadBalancerArrayInput)(nil)).Elem(), NetworkLoadBalancerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*NetworkLoadBalancerMapInput)(nil)).Elem(), NetworkLoadBalancerMap{})
	pulumi.RegisterOutputType(NetworkLoadBalancerOutput{})
	pulumi.RegisterOutputType(NetworkLoadBalancerArrayOutput{})
	pulumi.RegisterOutputType(NetworkLoadBalancerMapOutput{})
}