hcloud.getLoadBalancerType

import * as pulumi from "@pulumi/pulumi";
import * as hcloud from "@pulumi/hcloud";

const byId = hcloud.getLoadBalancerType({
    id: 1,
});
const byName = hcloud.getLoadBalancerType({
    name: "lb11",
});
const main = new hcloud.LoadBalancer("main", {
    name: "my-load-balancer",
    loadBalancerType: name,
    location: "fsn1",
});

import pulumi
import pulumi_hcloud as hcloud

by_id = hcloud.get_load_balancer_type(id=1)
by_name = hcloud.get_load_balancer_type(name="lb11")
main = hcloud.LoadBalancer("main",
    name="my-load-balancer",
    load_balancer_type=name,
    location="fsn1")

package main

import (
	"github.com/pulumi/pulumi-hcloud/sdk/go/hcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := hcloud.GetLoadBalancerType(ctx, &hcloud.GetLoadBalancerTypeArgs{
			Id: pulumi.IntRef(1),
		}, nil)
		if err != nil {
			return err
		}
		_, err = hcloud.GetLoadBalancerType(ctx, &hcloud.GetLoadBalancerTypeArgs{
			Name: pulumi.StringRef("lb11"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = hcloud.NewLoadBalancer(ctx, "main", &hcloud.LoadBalancerArgs{
			Name:             pulumi.String("my-load-balancer"),
			LoadBalancerType: pulumi.Any(name),
			Location:         pulumi.String("fsn1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var byId = HCloud.GetLoadBalancerType.Invoke(new()
    {
        Id = 1,
    });

    var byName = HCloud.GetLoadBalancerType.Invoke(new()
    {
        Name = "lb11",
    });

    var main = new HCloud.LoadBalancer("main", new()
    {
        Name = "my-load-balancer",
        LoadBalancerType = name,
        Location = "fsn1",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hcloud.HcloudFunctions;
import com.pulumi.hcloud.inputs.GetLoadBalancerTypeArgs;
import com.pulumi.hcloud.LoadBalancer;
import com.pulumi.hcloud.LoadBalancerArgs;
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 byId = HcloudFunctions.getLoadBalancerType(GetLoadBalancerTypeArgs.builder()
            .id(1)
            .build());

        final var byName = HcloudFunctions.getLoadBalancerType(GetLoadBalancerTypeArgs.builder()
            .name("lb11")
            .build());

        var main = new LoadBalancer("main", LoadBalancerArgs.builder()
            .name("my-load-balancer")
            .loadBalancerType(name)
            .location("fsn1")
            .build());

    }
}

resources:
  main:
    type: hcloud:LoadBalancer
    properties:
      name: my-load-balancer
      loadBalancerType: ${name}
      location: fsn1
variables:
  byId:
    fn::invoke:
      function: hcloud:getLoadBalancerType
      arguments:
        id: 1
  byName:
    fn::invoke:
      function: hcloud:getLoadBalancerType
      arguments:
        name: lb11

function getLoadBalancerType(args: GetLoadBalancerTypeArgs, opts?: InvokeOptions): Promise<GetLoadBalancerTypeResult>
function getLoadBalancerTypeOutput(args: GetLoadBalancerTypeOutputArgs, opts?: InvokeOptions): Output<GetLoadBalancerTypeResult>

def get_load_balancer_type(id: Optional[int] = None,
                           name: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetLoadBalancerTypeResult
def get_load_balancer_type_output(id: Optional[pulumi.Input[int]] = None,
                           name: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetLoadBalancerTypeResult]

func GetLoadBalancerType(ctx *Context, args *GetLoadBalancerTypeArgs, opts ...InvokeOption) (*GetLoadBalancerTypeResult, error)
func GetLoadBalancerTypeOutput(ctx *Context, args *GetLoadBalancerTypeOutputArgs, opts ...InvokeOption) GetLoadBalancerTypeResultOutput

public static class GetLoadBalancerType 
{
    public static Task<GetLoadBalancerTypeResult> InvokeAsync(GetLoadBalancerTypeArgs args, InvokeOptions? opts = null)
    public static Output<GetLoadBalancerTypeResult> Invoke(GetLoadBalancerTypeInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetLoadBalancerTypeResult> getLoadBalancerType(GetLoadBalancerTypeArgs args, InvokeOptions options)
public static Output<GetLoadBalancerTypeResult> getLoadBalancerType(GetLoadBalancerTypeArgs args, InvokeOptions options)

fn::invoke:
  function: hcloud:index/getLoadBalancerType:getLoadBalancerType
  arguments:
    # arguments dictionary