upcloud.LoadbalancerFrontendRule

import * as pulumi from "@pulumi/pulumi";
import * as upcloud from "@upcloud/pulumi-upcloud";

const config = new pulumi.Config();
const lbZone = config.get("lbZone") || "fi-hel2";
const lbNetwork = new upcloud.Network("lb_network", {
    name: "lb-test-net",
    zone: lbZone,
    ipNetwork: {
        address: "10.0.0.0/24",
        dhcp: true,
        family: "IPv4",
    },
});
const lbFe1R1 = new upcloud.LoadbalancerFrontendRule("lb_fe_1_r1", {
    frontend: upcloudLoadbalancerFrontend.lbFe1.id,
    name: "lb-fe-1-r1-test",
    priority: 10,
    matchers: {
        srcIps: [{
            value: "192.168.0.0/24",
        }],
    },
    actions: {
        useBackends: [{
            backendName: upcloudLoadbalancerBackend.lbBe1.name,
        }],
    },
});
const lbFe1 = new upcloud.LoadbalancerFrontend("lb_fe_1", {
    loadbalancer: upcloudLoadbalancer.lb.id,
    name: "lb-fe-1-test",
    mode: "http",
    port: 8080,
    defaultBackendName: upcloudLoadbalancerBackend.lbBe1.name,
});
const lb = new upcloud.Loadbalancer("lb", {
    configuredStatus: "started",
    name: "lb-test",
    plan: "development",
    zone: lbZone,
    networks: [
        {
            type: "public",
            family: "IPv4",
            name: "public",
        },
        {
            type: "private",
            family: "IPv4",
            name: "private",
            network: upcloudNetwork.lbNetwork.id,
        },
    ],
});
const lbBe1 = new upcloud.LoadbalancerBackend("lb_be_1", {
    loadbalancer: upcloudLoadbalancer.lb.id,
    name: "lb-be-1-test",
});

import pulumi
import pulumi_upcloud as upcloud

config = pulumi.Config()
lb_zone = config.get("lbZone")
if lb_zone is None:
    lb_zone = "fi-hel2"
lb_network = upcloud.Network("lb_network",
    name="lb-test-net",
    zone=lb_zone,
    ip_network={
        "address": "10.0.0.0/24",
        "dhcp": True,
        "family": "IPv4",
    })
lb_fe1_r1 = upcloud.LoadbalancerFrontendRule("lb_fe_1_r1",
    frontend=upcloud_loadbalancer_frontend["lbFe1"]["id"],
    name="lb-fe-1-r1-test",
    priority=10,
    matchers={
        "src_ips": [{
            "value": "192.168.0.0/24",
        }],
    },
    actions={
        "use_backends": [{
            "backend_name": upcloud_loadbalancer_backend["lbBe1"]["name"],
        }],
    })
lb_fe1 = upcloud.LoadbalancerFrontend("lb_fe_1",
    loadbalancer=upcloud_loadbalancer["lb"]["id"],
    name="lb-fe-1-test",
    mode="http",
    port=8080,
    default_backend_name=upcloud_loadbalancer_backend["lbBe1"]["name"])
lb = upcloud.Loadbalancer("lb",
    configured_status="started",
    name="lb-test",
    plan="development",
    zone=lb_zone,
    networks=[
        {
            "type": "public",
            "family": "IPv4",
            "name": "public",
        },
        {
            "type": "private",
            "family": "IPv4",
            "name": "private",
            "network": upcloud_network["lbNetwork"]["id"],
        },
    ])
lb_be1 = upcloud.LoadbalancerBackend("lb_be_1",
    loadbalancer=upcloud_loadbalancer["lb"]["id"],
    name="lb-be-1-test")

package main

import (
	"github.com/UpCloudLtd/pulumi-upcloud/sdk/go/upcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		lbZone := "fi-hel2"
		if param := cfg.Get("lbZone"); param != "" {
			lbZone = param
		}
		_, err := upcloud.NewNetwork(ctx, "lb_network", &upcloud.NetworkArgs{
			Name: pulumi.String("lb-test-net"),
			Zone: pulumi.String(lbZone),
			IpNetwork: &upcloud.NetworkIpNetworkArgs{
				Address: pulumi.String("10.0.0.0/24"),
				Dhcp:    pulumi.Bool(true),
				Family:  pulumi.String("IPv4"),
			},
		})
		if err != nil {
			return err
		}
		_, err = upcloud.NewLoadbalancerFrontendRule(ctx, "lb_fe_1_r1", &upcloud.LoadbalancerFrontendRuleArgs{
			Frontend: pulumi.Any(upcloudLoadbalancerFrontend.LbFe1.Id),
			Name:     pulumi.String("lb-fe-1-r1-test"),
			Priority: pulumi.Int(10),
			Matchers: &upcloud.LoadbalancerFrontendRuleMatchersArgs{
				SrcIps: upcloud.LoadbalancerFrontendRuleMatchersSrcIpArray{
					&upcloud.LoadbalancerFrontendRuleMatchersSrcIpArgs{
						Value: pulumi.String("192.168.0.0/24"),
					},
				},
			},
			Actions: &upcloud.LoadbalancerFrontendRuleActionsArgs{
				UseBackends: upcloud.LoadbalancerFrontendRuleActionsUseBackendArray{
					&upcloud.LoadbalancerFrontendRuleActionsUseBackendArgs{
						BackendName: pulumi.Any(upcloudLoadbalancerBackend.LbBe1.Name),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = upcloud.NewLoadbalancerFrontend(ctx, "lb_fe_1", &upcloud.LoadbalancerFrontendArgs{
			Loadbalancer:       pulumi.Any(upcloudLoadbalancer.Lb.Id),
			Name:               pulumi.String("lb-fe-1-test"),
			Mode:               pulumi.String("http"),
			Port:               pulumi.Int(8080),
			DefaultBackendName: pulumi.Any(upcloudLoadbalancerBackend.LbBe1.Name),
		})
		if err != nil {
			return err
		}
		_, err = upcloud.NewLoadbalancer(ctx, "lb", &upcloud.LoadbalancerArgs{
			ConfiguredStatus: pulumi.String("started"),
			Name:             pulumi.String("lb-test"),
			Plan:             pulumi.String("development"),
			Zone:             pulumi.String(lbZone),
			Networks: upcloud.LoadbalancerNetworkArray{
				&upcloud.LoadbalancerNetworkArgs{
					Type:   pulumi.String("public"),
					Family: pulumi.String("IPv4"),
					Name:   pulumi.String("public"),
				},
				&upcloud.LoadbalancerNetworkArgs{
					Type:    pulumi.String("private"),
					Family:  pulumi.String("IPv4"),
					Name:    pulumi.String("private"),
					Network: pulumi.Any(upcloudNetwork.LbNetwork.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = upcloud.NewLoadbalancerBackend(ctx, "lb_be_1", &upcloud.LoadbalancerBackendArgs{
			Loadbalancer: pulumi.Any(upcloudLoadbalancer.Lb.Id),
			Name:         pulumi.String("lb-be-1-test"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using UpCloud = UpCloud.Pulumi.UpCloud;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var lbZone = config.Get("lbZone") ?? "fi-hel2";
    var lbNetwork = new UpCloud.Network("lb_network", new()
    {
        Name = "lb-test-net",
        Zone = lbZone,
        IpNetwork = new UpCloud.Inputs.NetworkIpNetworkArgs
        {
            Address = "10.0.0.0/24",
            Dhcp = true,
            Family = "IPv4",
        },
    });

    var lbFe1R1 = new UpCloud.LoadbalancerFrontendRule("lb_fe_1_r1", new()
    {
        Frontend = upcloudLoadbalancerFrontend.LbFe1.Id,
        Name = "lb-fe-1-r1-test",
        Priority = 10,
        Matchers = new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersArgs
        {
            SrcIps = new[]
            {
                new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersSrcIpArgs
                {
                    Value = "192.168.0.0/24",
                },
            },
        },
        Actions = new UpCloud.Inputs.LoadbalancerFrontendRuleActionsArgs
        {
            UseBackends = new[]
            {
                new UpCloud.Inputs.LoadbalancerFrontendRuleActionsUseBackendArgs
                {
                    BackendName = upcloudLoadbalancerBackend.LbBe1.Name,
                },
            },
        },
    });

    var lbFe1 = new UpCloud.LoadbalancerFrontend("lb_fe_1", new()
    {
        Loadbalancer = upcloudLoadbalancer.Lb.Id,
        Name = "lb-fe-1-test",
        Mode = "http",
        Port = 8080,
        DefaultBackendName = upcloudLoadbalancerBackend.LbBe1.Name,
    });

    var lb = new UpCloud.Loadbalancer("lb", new()
    {
        ConfiguredStatus = "started",
        Name = "lb-test",
        Plan = "development",
        Zone = lbZone,
        Networks = new[]
        {
            new UpCloud.Inputs.LoadbalancerNetworkArgs
            {
                Type = "public",
                Family = "IPv4",
                Name = "public",
            },
            new UpCloud.Inputs.LoadbalancerNetworkArgs
            {
                Type = "private",
                Family = "IPv4",
                Name = "private",
                Network = upcloudNetwork.LbNetwork.Id,
            },
        },
    });

    var lbBe1 = new UpCloud.LoadbalancerBackend("lb_be_1", new()
    {
        Loadbalancer = upcloudLoadbalancer.Lb.Id,
        Name = "lb-be-1-test",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.Network;
import com.pulumi.upcloud.NetworkArgs;
import com.pulumi.upcloud.inputs.NetworkIpNetworkArgs;
import com.pulumi.upcloud.LoadbalancerFrontendRule;
import com.pulumi.upcloud.LoadbalancerFrontendRuleArgs;
import com.pulumi.upcloud.inputs.LoadbalancerFrontendRuleMatchersArgs;
import com.pulumi.upcloud.inputs.LoadbalancerFrontendRuleActionsArgs;
import com.pulumi.upcloud.LoadbalancerFrontend;
import com.pulumi.upcloud.LoadbalancerFrontendArgs;
import com.pulumi.upcloud.Loadbalancer;
import com.pulumi.upcloud.LoadbalancerArgs;
import com.pulumi.upcloud.inputs.LoadbalancerNetworkArgs;
import com.pulumi.upcloud.LoadbalancerBackend;
import com.pulumi.upcloud.LoadbalancerBackendArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var lbZone = config.get("lbZone").orElse("fi-hel2");
        var lbNetwork = new Network("lbNetwork", NetworkArgs.builder()
            .name("lb-test-net")
            .zone(lbZone)
            .ipNetwork(NetworkIpNetworkArgs.builder()
                .address("10.0.0.0/24")
                .dhcp(true)
                .family("IPv4")
                .build())
            .build());

        var lbFe1R1 = new LoadbalancerFrontendRule("lbFe1R1", LoadbalancerFrontendRuleArgs.builder()
            .frontend(upcloudLoadbalancerFrontend.lbFe1().id())
            .name("lb-fe-1-r1-test")
            .priority(10)
            .matchers(LoadbalancerFrontendRuleMatchersArgs.builder()
                .srcIps(LoadbalancerFrontendRuleMatchersSrcIpArgs.builder()
                    .value("192.168.0.0/24")
                    .build())
                .build())
            .actions(LoadbalancerFrontendRuleActionsArgs.builder()
                .useBackends(LoadbalancerFrontendRuleActionsUseBackendArgs.builder()
                    .backendName(upcloudLoadbalancerBackend.lbBe1().name())
                    .build())
                .build())
            .build());

        var lbFe1 = new LoadbalancerFrontend("lbFe1", LoadbalancerFrontendArgs.builder()
            .loadbalancer(upcloudLoadbalancer.lb().id())
            .name("lb-fe-1-test")
            .mode("http")
            .port(8080)
            .defaultBackendName(upcloudLoadbalancerBackend.lbBe1().name())
            .build());

        var lb = new Loadbalancer("lb", LoadbalancerArgs.builder()
            .configuredStatus("started")
            .name("lb-test")
            .plan("development")
            .zone(lbZone)
            .networks(            
                LoadbalancerNetworkArgs.builder()
                    .type("public")
                    .family("IPv4")
                    .name("public")
                    .build(),
                LoadbalancerNetworkArgs.builder()
                    .type("private")
                    .family("IPv4")
                    .name("private")
                    .network(upcloudNetwork.lbNetwork().id())
                    .build())
            .build());

        var lbBe1 = new LoadbalancerBackend("lbBe1", LoadbalancerBackendArgs.builder()
            .loadbalancer(upcloudLoadbalancer.lb().id())
            .name("lb-be-1-test")
            .build());

    }
}

configuration:
  lbZone:
    type: string
    default: fi-hel2
resources:
  lbNetwork:
    type: upcloud:Network
    name: lb_network
    properties:
      name: lb-test-net
      zone: ${lbZone}
      ipNetwork:
        address: 10.0.0.0/24
        dhcp: true
        family: IPv4
  lbFe1R1:
    type: upcloud:LoadbalancerFrontendRule
    name: lb_fe_1_r1
    properties:
      frontend: ${upcloudLoadbalancerFrontend.lbFe1.id}
      name: lb-fe-1-r1-test
      priority: 10
      matchers:
        srcIps:
          - value: 192.168.0.0/24
      actions:
        useBackends:
          - backendName: ${upcloudLoadbalancerBackend.lbBe1.name}
  lbFe1:
    type: upcloud:LoadbalancerFrontend
    name: lb_fe_1
    properties:
      loadbalancer: ${upcloudLoadbalancer.lb.id}
      name: lb-fe-1-test
      mode: http
      port: 8080
      defaultBackendName: ${upcloudLoadbalancerBackend.lbBe1.name}
  lb:
    type: upcloud:Loadbalancer
    properties:
      configuredStatus: started
      name: lb-test
      plan: development
      zone: ${lbZone}
      networks:
        - type: public
          family: IPv4
          name: public
        - type: private
          family: IPv4
          name: private
          network: ${upcloudNetwork.lbNetwork.id}
  lbBe1:
    type: upcloud:LoadbalancerBackend
    name: lb_be_1
    properties:
      loadbalancer: ${upcloudLoadbalancer.lb.id}
      name: lb-be-1-test

var loadbalancerFrontendRuleResource = new UpCloud.LoadbalancerFrontendRule("loadbalancerFrontendRuleResource", new()
{
    Frontend = "string",
    Priority = 0,
    Actions = new UpCloud.Inputs.LoadbalancerFrontendRuleActionsArgs
    {
        HttpRedirects = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsHttpRedirectArgs
            {
                Location = "string",
                Scheme = "string",
                Status = 0,
            },
        },
        HttpReturns = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsHttpReturnArgs
            {
                ContentType = "string",
                Payload = "string",
                Status = 0,
            },
        },
        SetForwardedHeaders = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsSetForwardedHeaderArgs
            {
                Active = false,
            },
        },
        SetRequestHeaders = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsSetRequestHeaderArgs
            {
                Header = "string",
                Value = "string",
            },
        },
        SetResponseHeaders = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsSetResponseHeaderArgs
            {
                Header = "string",
                Value = "string",
            },
        },
        TcpRejects = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsTcpRejectArgs
            {
                Active = false,
            },
        },
        UseBackends = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleActionsUseBackendArgs
            {
                BackendName = "string",
            },
        },
    },
    Matchers = new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersArgs
    {
        BodySizeRanges = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersBodySizeRangeArgs
            {
                RangeEnd = 0,
                RangeStart = 0,
                Inverse = false,
            },
        },
        BodySizes = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersBodySizeArgs
            {
                Method = "string",
                Value = 0,
                Inverse = false,
            },
        },
        Cookies = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersCookieArgs
            {
                Method = "string",
                Name = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
        Hosts = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersHostArgs
            {
                Value = "string",
                Inverse = false,
            },
        },
        HttpMethods = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersHttpMethodArgs
            {
                Value = "string",
                Inverse = false,
            },
        },
        HttpStatusRanges = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersHttpStatusRangeArgs
            {
                RangeEnd = 0,
                RangeStart = 0,
                Inverse = false,
            },
        },
        HttpStatuses = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersHttpStatusArgs
            {
                Method = "string",
                Value = 0,
                Inverse = false,
            },
        },
        NumMembersUps = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersNumMembersUpArgs
            {
                BackendName = "string",
                Method = "string",
                Value = 0,
                Inverse = false,
            },
        },
        Paths = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersPathArgs
            {
                Method = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
        RequestHeaders = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersRequestHeaderArgs
            {
                Method = "string",
                Name = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
        ResponseHeaders = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersResponseHeaderArgs
            {
                Method = "string",
                Name = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
        SrcIps = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersSrcIpArgs
            {
                Value = "string",
                Inverse = false,
            },
        },
        SrcPortRanges = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersSrcPortRangeArgs
            {
                RangeEnd = 0,
                RangeStart = 0,
                Inverse = false,
            },
        },
        SrcPorts = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersSrcPortArgs
            {
                Method = "string",
                Value = 0,
                Inverse = false,
            },
        },
        UrlParams = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersUrlParamArgs
            {
                Method = "string",
                Name = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
        UrlQueries = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersUrlQueryArgs
            {
                Method = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
        Urls = new[]
        {
            new UpCloud.Inputs.LoadbalancerFrontendRuleMatchersUrlArgs
            {
                Method = "string",
                IgnoreCase = false,
                Inverse = false,
                Value = "string",
            },
        },
    },
    MatchingCondition = "string",
    Name = "string",
});

example, err := upcloud.NewLoadbalancerFrontendRule(ctx, "loadbalancerFrontendRuleResource", &upcloud.LoadbalancerFrontendRuleArgs{
	Frontend: pulumi.String("string"),
	Priority: pulumi.Int(0),
	Actions: &upcloud.LoadbalancerFrontendRuleActionsArgs{
		HttpRedirects: upcloud.LoadbalancerFrontendRuleActionsHttpRedirectArray{
			&upcloud.LoadbalancerFrontendRuleActionsHttpRedirectArgs{
				Location: pulumi.String("string"),
				Scheme:   pulumi.String("string"),
				Status:   pulumi.Int(0),
			},
		},
		HttpReturns: upcloud.LoadbalancerFrontendRuleActionsHttpReturnArray{
			&upcloud.LoadbalancerFrontendRuleActionsHttpReturnArgs{
				ContentType: pulumi.String("string"),
				Payload:     pulumi.String("string"),
				Status:      pulumi.Int(0),
			},
		},
		SetForwardedHeaders: upcloud.LoadbalancerFrontendRuleActionsSetForwardedHeaderArray{
			&upcloud.LoadbalancerFrontendRuleActionsSetForwardedHeaderArgs{
				Active: pulumi.Bool(false),
			},
		},
		SetRequestHeaders: upcloud.LoadbalancerFrontendRuleActionsSetRequestHeaderArray{
			&upcloud.LoadbalancerFrontendRuleActionsSetRequestHeaderArgs{
				Header: pulumi.String("string"),
				Value:  pulumi.String("string"),
			},
		},
		SetResponseHeaders: upcloud.LoadbalancerFrontendRuleActionsSetResponseHeaderArray{
			&upcloud.LoadbalancerFrontendRuleActionsSetResponseHeaderArgs{
				Header: pulumi.String("string"),
				Value:  pulumi.String("string"),
			},
		},
		TcpRejects: upcloud.LoadbalancerFrontendRuleActionsTcpRejectArray{
			&upcloud.LoadbalancerFrontendRuleActionsTcpRejectArgs{
				Active: pulumi.Bool(false),
			},
		},
		UseBackends: upcloud.LoadbalancerFrontendRuleActionsUseBackendArray{
			&upcloud.LoadbalancerFrontendRuleActionsUseBackendArgs{
				BackendName: pulumi.String("string"),
			},
		},
	},
	Matchers: &upcloud.LoadbalancerFrontendRuleMatchersArgs{
		BodySizeRanges: upcloud.LoadbalancerFrontendRuleMatchersBodySizeRangeArray{
			&upcloud.LoadbalancerFrontendRuleMatchersBodySizeRangeArgs{
				RangeEnd:   pulumi.Int(0),
				RangeStart: pulumi.Int(0),
				Inverse:    pulumi.Bool(false),
			},
		},
		BodySizes: upcloud.LoadbalancerFrontendRuleMatchersBodySizeArray{
			&upcloud.LoadbalancerFrontendRuleMatchersBodySizeArgs{
				Method:  pulumi.String("string"),
				Value:   pulumi.Int(0),
				Inverse: pulumi.Bool(false),
			},
		},
		Cookies: upcloud.LoadbalancerFrontendRuleMatchersCookieArray{
			&upcloud.LoadbalancerFrontendRuleMatchersCookieArgs{
				Method:     pulumi.String("string"),
				Name:       pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
		Hosts: upcloud.LoadbalancerFrontendRuleMatchersHostArray{
			&upcloud.LoadbalancerFrontendRuleMatchersHostArgs{
				Value:   pulumi.String("string"),
				Inverse: pulumi.Bool(false),
			},
		},
		HttpMethods: upcloud.LoadbalancerFrontendRuleMatchersHttpMethodArray{
			&upcloud.LoadbalancerFrontendRuleMatchersHttpMethodArgs{
				Value:   pulumi.String("string"),
				Inverse: pulumi.Bool(false),
			},
		},
		HttpStatusRanges: upcloud.LoadbalancerFrontendRuleMatchersHttpStatusRangeArray{
			&upcloud.LoadbalancerFrontendRuleMatchersHttpStatusRangeArgs{
				RangeEnd:   pulumi.Int(0),
				RangeStart: pulumi.Int(0),
				Inverse:    pulumi.Bool(false),
			},
		},
		HttpStatuses: upcloud.LoadbalancerFrontendRuleMatchersHttpStatusArray{
			&upcloud.LoadbalancerFrontendRuleMatchersHttpStatusArgs{
				Method:  pulumi.String("string"),
				Value:   pulumi.Int(0),
				Inverse: pulumi.Bool(false),
			},
		},
		NumMembersUps: upcloud.LoadbalancerFrontendRuleMatchersNumMembersUpArray{
			&upcloud.LoadbalancerFrontendRuleMatchersNumMembersUpArgs{
				BackendName: pulumi.String("string"),
				Method:      pulumi.String("string"),
				Value:       pulumi.Int(0),
				Inverse:     pulumi.Bool(false),
			},
		},
		Paths: upcloud.LoadbalancerFrontendRuleMatchersPathArray{
			&upcloud.LoadbalancerFrontendRuleMatchersPathArgs{
				Method:     pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
		RequestHeaders: upcloud.LoadbalancerFrontendRuleMatchersRequestHeaderArray{
			&upcloud.LoadbalancerFrontendRuleMatchersRequestHeaderArgs{
				Method:     pulumi.String("string"),
				Name:       pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
		ResponseHeaders: upcloud.LoadbalancerFrontendRuleMatchersResponseHeaderArray{
			&upcloud.LoadbalancerFrontendRuleMatchersResponseHeaderArgs{
				Method:     pulumi.String("string"),
				Name:       pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
		SrcIps: upcloud.LoadbalancerFrontendRuleMatchersSrcIpArray{
			&upcloud.LoadbalancerFrontendRuleMatchersSrcIpArgs{
				Value:   pulumi.String("string"),
				Inverse: pulumi.Bool(false),
			},
		},
		SrcPortRanges: upcloud.LoadbalancerFrontendRuleMatchersSrcPortRangeArray{
			&upcloud.LoadbalancerFrontendRuleMatchersSrcPortRangeArgs{
				RangeEnd:   pulumi.Int(0),
				RangeStart: pulumi.Int(0),
				Inverse:    pulumi.Bool(false),
			},
		},
		SrcPorts: upcloud.LoadbalancerFrontendRuleMatchersSrcPortArray{
			&upcloud.LoadbalancerFrontendRuleMatchersSrcPortArgs{
				Method:  pulumi.String("string"),
				Value:   pulumi.Int(0),
				Inverse: pulumi.Bool(false),
			},
		},
		UrlParams: upcloud.LoadbalancerFrontendRuleMatchersUrlParamArray{
			&upcloud.LoadbalancerFrontendRuleMatchersUrlParamArgs{
				Method:     pulumi.String("string"),
				Name:       pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
		UrlQueries: upcloud.LoadbalancerFrontendRuleMatchersUrlQueryArray{
			&upcloud.LoadbalancerFrontendRuleMatchersUrlQueryArgs{
				Method:     pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
		Urls: upcloud.LoadbalancerFrontendRuleMatchersUrlArray{
			&upcloud.LoadbalancerFrontendRuleMatchersUrlArgs{
				Method:     pulumi.String("string"),
				IgnoreCase: pulumi.Bool(false),
				Inverse:    pulumi.Bool(false),
				Value:      pulumi.String("string"),
			},
		},
	},
	MatchingCondition: pulumi.String("string"),
	Name:              pulumi.String("string"),
})

var loadbalancerFrontendRuleResource = new LoadbalancerFrontendRule("loadbalancerFrontendRuleResource", LoadbalancerFrontendRuleArgs.builder()
    .frontend("string")
    .priority(0)
    .actions(LoadbalancerFrontendRuleActionsArgs.builder()
        .httpRedirects(LoadbalancerFrontendRuleActionsHttpRedirectArgs.builder()
            .location("string")
            .scheme("string")
            .status(0)
            .build())
        .httpReturns(LoadbalancerFrontendRuleActionsHttpReturnArgs.builder()
            .contentType("string")
            .payload("string")
            .status(0)
            .build())
        .setForwardedHeaders(LoadbalancerFrontendRuleActionsSetForwardedHeaderArgs.builder()
            .active(false)
            .build())
        .setRequestHeaders(LoadbalancerFrontendRuleActionsSetRequestHeaderArgs.builder()
            .header("string")
            .value("string")
            .build())
        .setResponseHeaders(LoadbalancerFrontendRuleActionsSetResponseHeaderArgs.builder()
            .header("string")
            .value("string")
            .build())
        .tcpRejects(LoadbalancerFrontendRuleActionsTcpRejectArgs.builder()
            .active(false)
            .build())
        .useBackends(LoadbalancerFrontendRuleActionsUseBackendArgs.builder()
            .backendName("string")
            .build())
        .build())
    .matchers(LoadbalancerFrontendRuleMatchersArgs.builder()
        .bodySizeRanges(LoadbalancerFrontendRuleMatchersBodySizeRangeArgs.builder()
            .rangeEnd(0)
            .rangeStart(0)
            .inverse(false)
            .build())
        .bodySizes(LoadbalancerFrontendRuleMatchersBodySizeArgs.builder()
            .method("string")
            .value(0)
            .inverse(false)
            .build())
        .cookies(LoadbalancerFrontendRuleMatchersCookieArgs.builder()
            .method("string")
            .name("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .hosts(LoadbalancerFrontendRuleMatchersHostArgs.builder()
            .value("string")
            .inverse(false)
            .build())
        .httpMethods(LoadbalancerFrontendRuleMatchersHttpMethodArgs.builder()
            .value("string")
            .inverse(false)
            .build())
        .httpStatusRanges(LoadbalancerFrontendRuleMatchersHttpStatusRangeArgs.builder()
            .rangeEnd(0)
            .rangeStart(0)
            .inverse(false)
            .build())
        .httpStatuses(LoadbalancerFrontendRuleMatchersHttpStatusArgs.builder()
            .method("string")
            .value(0)
            .inverse(false)
            .build())
        .numMembersUps(LoadbalancerFrontendRuleMatchersNumMembersUpArgs.builder()
            .backendName("string")
            .method("string")
            .value(0)
            .inverse(false)
            .build())
        .paths(LoadbalancerFrontendRuleMatchersPathArgs.builder()
            .method("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .requestHeaders(LoadbalancerFrontendRuleMatchersRequestHeaderArgs.builder()
            .method("string")
            .name("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .responseHeaders(LoadbalancerFrontendRuleMatchersResponseHeaderArgs.builder()
            .method("string")
            .name("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .srcIps(LoadbalancerFrontendRuleMatchersSrcIpArgs.builder()
            .value("string")
            .inverse(false)
            .build())
        .srcPortRanges(LoadbalancerFrontendRuleMatchersSrcPortRangeArgs.builder()
            .rangeEnd(0)
            .rangeStart(0)
            .inverse(false)
            .build())
        .srcPorts(LoadbalancerFrontendRuleMatchersSrcPortArgs.builder()
            .method("string")
            .value(0)
            .inverse(false)
            .build())
        .urlParams(LoadbalancerFrontendRuleMatchersUrlParamArgs.builder()
            .method("string")
            .name("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .urlQueries(LoadbalancerFrontendRuleMatchersUrlQueryArgs.builder()
            .method("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .urls(LoadbalancerFrontendRuleMatchersUrlArgs.builder()
            .method("string")
            .ignoreCase(false)
            .inverse(false)
            .value("string")
            .build())
        .build())
    .matchingCondition("string")
    .name("string")
    .build());

loadbalancer_frontend_rule_resource = upcloud.LoadbalancerFrontendRule("loadbalancerFrontendRuleResource",
    frontend="string",
    priority=0,
    actions={
        "http_redirects": [{
            "location": "string",
            "scheme": "string",
            "status": 0,
        }],
        "http_returns": [{
            "content_type": "string",
            "payload": "string",
            "status": 0,
        }],
        "set_forwarded_headers": [{
            "active": False,
        }],
        "set_request_headers": [{
            "header": "string",
            "value": "string",
        }],
        "set_response_headers": [{
            "header": "string",
            "value": "string",
        }],
        "tcp_rejects": [{
            "active": False,
        }],
        "use_backends": [{
            "backend_name": "string",
        }],
    },
    matchers={
        "body_size_ranges": [{
            "range_end": 0,
            "range_start": 0,
            "inverse": False,
        }],
        "body_sizes": [{
            "method": "string",
            "value": 0,
            "inverse": False,
        }],
        "cookies": [{
            "method": "string",
            "name": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
        "hosts": [{
            "value": "string",
            "inverse": False,
        }],
        "http_methods": [{
            "value": "string",
            "inverse": False,
        }],
        "http_status_ranges": [{
            "range_end": 0,
            "range_start": 0,
            "inverse": False,
        }],
        "http_statuses": [{
            "method": "string",
            "value": 0,
            "inverse": False,
        }],
        "num_members_ups": [{
            "backend_name": "string",
            "method": "string",
            "value": 0,
            "inverse": False,
        }],
        "paths": [{
            "method": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
        "request_headers": [{
            "method": "string",
            "name": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
        "response_headers": [{
            "method": "string",
            "name": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
        "src_ips": [{
            "value": "string",
            "inverse": False,
        }],
        "src_port_ranges": [{
            "range_end": 0,
            "range_start": 0,
            "inverse": False,
        }],
        "src_ports": [{
            "method": "string",
            "value": 0,
            "inverse": False,
        }],
        "url_params": [{
            "method": "string",
            "name": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
        "url_queries": [{
            "method": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
        "urls": [{
            "method": "string",
            "ignore_case": False,
            "inverse": False,
            "value": "string",
        }],
    },
    matching_condition="string",
    name="string")

const loadbalancerFrontendRuleResource = new upcloud.LoadbalancerFrontendRule("loadbalancerFrontendRuleResource", {
    frontend: "string",
    priority: 0,
    actions: {
        httpRedirects: [{
            location: "string",
            scheme: "string",
            status: 0,
        }],
        httpReturns: [{
            contentType: "string",
            payload: "string",
            status: 0,
        }],
        setForwardedHeaders: [{
            active: false,
        }],
        setRequestHeaders: [{
            header: "string",
            value: "string",
        }],
        setResponseHeaders: [{
            header: "string",
            value: "string",
        }],
        tcpRejects: [{
            active: false,
        }],
        useBackends: [{
            backendName: "string",
        }],
    },
    matchers: {
        bodySizeRanges: [{
            rangeEnd: 0,
            rangeStart: 0,
            inverse: false,
        }],
        bodySizes: [{
            method: "string",
            value: 0,
            inverse: false,
        }],
        cookies: [{
            method: "string",
            name: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
        hosts: [{
            value: "string",
            inverse: false,
        }],
        httpMethods: [{
            value: "string",
            inverse: false,
        }],
        httpStatusRanges: [{
            rangeEnd: 0,
            rangeStart: 0,
            inverse: false,
        }],
        httpStatuses: [{
            method: "string",
            value: 0,
            inverse: false,
        }],
        numMembersUps: [{
            backendName: "string",
            method: "string",
            value: 0,
            inverse: false,
        }],
        paths: [{
            method: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
        requestHeaders: [{
            method: "string",
            name: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
        responseHeaders: [{
            method: "string",
            name: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
        srcIps: [{
            value: "string",
            inverse: false,
        }],
        srcPortRanges: [{
            rangeEnd: 0,
            rangeStart: 0,
            inverse: false,
        }],
        srcPorts: [{
            method: "string",
            value: 0,
            inverse: false,
        }],
        urlParams: [{
            method: "string",
            name: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
        urlQueries: [{
            method: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
        urls: [{
            method: "string",
            ignoreCase: false,
            inverse: false,
            value: "string",
        }],
    },
    matchingCondition: "string",
    name: "string",
});