netbox.getRackType

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

// Get rack type by model
const ex1 = netbox.getRackType({
    model: "APC 4-Post Cabinet",
});
// Get rack type by slug
const ex2 = netbox.getRackType({
    slug: "apc-4-post-cabinet",
});

import pulumi
import pulumi_netbox as netbox

# Get rack type by model
ex1 = netbox.get_rack_type(model="APC 4-Post Cabinet")
# Get rack type by slug
ex2 = netbox.get_rack_type(slug="apc-4-post-cabinet")

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netbox/v5/netbox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get rack type by model
		_, err := netbox.LookupRackType(ctx, &netbox.LookupRackTypeArgs{
			Model: pulumi.StringRef("APC 4-Post Cabinet"),
		}, nil)
		if err != nil {
			return err
		}
		// Get rack type by slug
		_, err = netbox.LookupRackType(ctx, &netbox.LookupRackTypeArgs{
			Slug: pulumi.StringRef("apc-4-post-cabinet"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Get rack type by model
    var ex1 = Netbox.GetRackType.Invoke(new()
    {
        Model = "APC 4-Post Cabinet",
    });

    // Get rack type by slug
    var ex2 = Netbox.GetRackType.Invoke(new()
    {
        Slug = "apc-4-post-cabinet",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.netbox.NetboxFunctions;
import com.pulumi.netbox.inputs.GetRackTypeArgs;
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) {
        // Get rack type by model
        final var ex1 = NetboxFunctions.getRackType(GetRackTypeArgs.builder()
            .model("APC 4-Post Cabinet")
            .build());

        // Get rack type by slug
        final var ex2 = NetboxFunctions.getRackType(GetRackTypeArgs.builder()
            .slug("apc-4-post-cabinet")
            .build());

    }
}

variables:
  # Get rack type by model
  ex1:
    fn::invoke:
      function: netbox:getRackType
      arguments:
        model: APC 4-Post Cabinet
  # Get rack type by slug
  ex2:
    fn::invoke:
      function: netbox:getRackType
      arguments:
        slug: apc-4-post-cabinet

function getRackType(args: GetRackTypeArgs, opts?: InvokeOptions): Promise<GetRackTypeResult>
function getRackTypeOutput(args: GetRackTypeOutputArgs, opts?: InvokeOptions): Output<GetRackTypeResult>

def get_rack_type(id: Optional[str] = None,
                  model: Optional[str] = None,
                  slug: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetRackTypeResult
def get_rack_type_output(id: pulumi.Input[Optional[str]] = None,
                  model: pulumi.Input[Optional[str]] = None,
                  slug: pulumi.Input[Optional[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetRackTypeResult]

func LookupRackType(ctx *Context, args *LookupRackTypeArgs, opts ...InvokeOption) (*LookupRackTypeResult, error)
func LookupRackTypeOutput(ctx *Context, args *LookupRackTypeOutputArgs, opts ...InvokeOption) LookupRackTypeResultOutput

public static class GetRackType 
{
    public static Task<GetRackTypeResult> InvokeAsync(GetRackTypeArgs args, InvokeOptions? opts = null)
    public static Output<GetRackTypeResult> Invoke(GetRackTypeInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRackTypeResult> getRackType(GetRackTypeArgs args, InvokeOptions options)
public static Output<GetRackTypeResult> getRackType(GetRackTypeArgs args, InvokeOptions options)

fn::invoke:
  function: netbox:index/getRackType:getRackType
  arguments:
    # arguments dictionary

data "netbox_get_rack_type" "name" {
    # arguments
}