vcd.getNsxtSegmentSpoofGuardProfile

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

const nsxt = vcd.getNsxtManager({
    name: "nsxManager1",
});
const first = nsxt.then(nsxt => vcd.getNsxtSegmentSpoofGuardProfile({
    name: "spoof-guard-profile-0",
    nsxtManagerId: nsxt.id,
}));

import pulumi
import pulumi_vcd as vcd

nsxt = vcd.get_nsxt_manager(name="nsxManager1")
first = vcd.get_nsxt_segment_spoof_guard_profile(name="spoof-guard-profile-0",
    nsxt_manager_id=nsxt.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		nsxt, err := vcd.GetNsxtManager(ctx, &vcd.GetNsxtManagerArgs{
			Name: "nsxManager1",
		}, nil)
		if err != nil {
			return err
		}
		_, err = vcd.GetNsxtSegmentSpoofGuardProfile(ctx, &vcd.GetNsxtSegmentSpoofGuardProfileArgs{
			Name:          "spoof-guard-profile-0",
			NsxtManagerId: pulumi.StringRef(nsxt.Id),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var nsxt = Vcd.GetNsxtManager.Invoke(new()
    {
        Name = "nsxManager1",
    });

    var first = Vcd.GetNsxtSegmentSpoofGuardProfile.Invoke(new()
    {
        Name = "spoof-guard-profile-0",
        NsxtManagerId = nsxt.Apply(getNsxtManagerResult => getNsxtManagerResult.Id),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.VcdFunctions;
import com.pulumi.vcd.inputs.GetNsxtManagerArgs;
import com.pulumi.vcd.inputs.GetNsxtSegmentSpoofGuardProfileArgs;
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 nsxt = VcdFunctions.getNsxtManager(GetNsxtManagerArgs.builder()
            .name("nsxManager1")
            .build());

        final var first = VcdFunctions.getNsxtSegmentSpoofGuardProfile(GetNsxtSegmentSpoofGuardProfileArgs.builder()
            .name("spoof-guard-profile-0")
            .nsxtManagerId(nsxt.applyValue(getNsxtManagerResult -> getNsxtManagerResult.id()))
            .build());

    }
}

variables:
  nsxt:
    fn::invoke:
      function: vcd:getNsxtManager
      arguments:
        name: nsxManager1
  first:
    fn::invoke:
      function: vcd:getNsxtSegmentSpoofGuardProfile
      arguments:
        name: spoof-guard-profile-0
        nsxtManagerId: ${nsxt.id}

function getNsxtSegmentSpoofGuardProfile(args: GetNsxtSegmentSpoofGuardProfileArgs, opts?: InvokeOptions): Promise<GetNsxtSegmentSpoofGuardProfileResult>
function getNsxtSegmentSpoofGuardProfileOutput(args: GetNsxtSegmentSpoofGuardProfileOutputArgs, opts?: InvokeOptions): Output<GetNsxtSegmentSpoofGuardProfileResult>

def get_nsxt_segment_spoof_guard_profile(id: Optional[str] = None,
                                         name: Optional[str] = None,
                                         nsxt_manager_id: Optional[str] = None,
                                         vdc_group_id: Optional[str] = None,
                                         vdc_id: Optional[str] = None,
                                         opts: Optional[InvokeOptions] = None) -> GetNsxtSegmentSpoofGuardProfileResult
def get_nsxt_segment_spoof_guard_profile_output(id: Optional[pulumi.Input[str]] = None,
                                         name: Optional[pulumi.Input[str]] = None,
                                         nsxt_manager_id: Optional[pulumi.Input[str]] = None,
                                         vdc_group_id: Optional[pulumi.Input[str]] = None,
                                         vdc_id: Optional[pulumi.Input[str]] = None,
                                         opts: Optional[InvokeOptions] = None) -> Output[GetNsxtSegmentSpoofGuardProfileResult]

func GetNsxtSegmentSpoofGuardProfile(ctx *Context, args *GetNsxtSegmentSpoofGuardProfileArgs, opts ...InvokeOption) (*GetNsxtSegmentSpoofGuardProfileResult, error)
func GetNsxtSegmentSpoofGuardProfileOutput(ctx *Context, args *GetNsxtSegmentSpoofGuardProfileOutputArgs, opts ...InvokeOption) GetNsxtSegmentSpoofGuardProfileResultOutput

public static class GetNsxtSegmentSpoofGuardProfile 
{
    public static Task<GetNsxtSegmentSpoofGuardProfileResult> InvokeAsync(GetNsxtSegmentSpoofGuardProfileArgs args, InvokeOptions? opts = null)
    public static Output<GetNsxtSegmentSpoofGuardProfileResult> Invoke(GetNsxtSegmentSpoofGuardProfileInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetNsxtSegmentSpoofGuardProfileResult> getNsxtSegmentSpoofGuardProfile(GetNsxtSegmentSpoofGuardProfileArgs args, InvokeOptions options)
public static Output<GetNsxtSegmentSpoofGuardProfileResult> getNsxtSegmentSpoofGuardProfile(GetNsxtSegmentSpoofGuardProfileArgs args, InvokeOptions options)

fn::invoke:
  function: vcd:index/getNsxtSegmentSpoofGuardProfile:getNsxtSegmentSpoofGuardProfile
  arguments:
    # arguments dictionary