scm.getTacacsServerProfile

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

// Look up the multi-tag address object by its ID.
const scmTacacsServerProfile5Ds = scm.getTacacsServerProfile({
    id: "1967a784-402b-4c20-aa48-aab64d73cc06",
});
export const profileDataSourceResults = {
    name: scmTacacsServerProfile5Ds.then(scmTacacsServerProfile5Ds => scmTacacsServerProfile5Ds.name),
    protocol: scmTacacsServerProfile5Ds.then(scmTacacsServerProfile5Ds => scmTacacsServerProfile5Ds.protocol),
    timeout: scmTacacsServerProfile5Ds.then(scmTacacsServerProfile5Ds => scmTacacsServerProfile5Ds.timeout),
    folder: scmTacacsServerProfile5Ds.then(scmTacacsServerProfile5Ds => scmTacacsServerProfile5Ds.folder),
    useSingleConnection: scmTacacsServerProfile5Ds.then(scmTacacsServerProfile5Ds => scmTacacsServerProfile5Ds.useSingleConnection),
};

import pulumi
import pulumi_scm as scm

# Look up the multi-tag address object by its ID.
scm_tacacs_server_profile5_ds = scm.get_tacacs_server_profile(id="1967a784-402b-4c20-aa48-aab64d73cc06")
pulumi.export("profileDataSourceResults", {
    "name": scm_tacacs_server_profile5_ds.name,
    "protocol": scm_tacacs_server_profile5_ds.protocol,
    "timeout": scm_tacacs_server_profile5_ds.timeout,
    "folder": scm_tacacs_server_profile5_ds.folder,
    "useSingleConnection": scm_tacacs_server_profile5_ds.use_single_connection,
})

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up the multi-tag address object by its ID.
		scmTacacsServerProfile5Ds, err := scm.LookupTacacsServerProfile(ctx, &scm.LookupTacacsServerProfileArgs{
			Id: "1967a784-402b-4c20-aa48-aab64d73cc06",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("profileDataSourceResults", pulumi.Map{
			"name":                scmTacacsServerProfile5Ds.Name,
			"protocol":            scmTacacsServerProfile5Ds.Protocol,
			"timeout":             scmTacacsServerProfile5Ds.Timeout,
			"folder":              scmTacacsServerProfile5Ds.Folder,
			"useSingleConnection": scmTacacsServerProfile5Ds.UseSingleConnection,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up the multi-tag address object by its ID.
    var scmTacacsServerProfile5Ds = Scm.GetTacacsServerProfile.Invoke(new()
    {
        Id = "1967a784-402b-4c20-aa48-aab64d73cc06",
    });

    return new Dictionary<string, object?>
    {
        ["profileDataSourceResults"] = 
        {
            { "name", scmTacacsServerProfile5Ds.Apply(getTacacsServerProfileResult => getTacacsServerProfileResult.Name) },
            { "protocol", scmTacacsServerProfile5Ds.Apply(getTacacsServerProfileResult => getTacacsServerProfileResult.Protocol) },
            { "timeout", scmTacacsServerProfile5Ds.Apply(getTacacsServerProfileResult => getTacacsServerProfileResult.Timeout) },
            { "folder", scmTacacsServerProfile5Ds.Apply(getTacacsServerProfileResult => getTacacsServerProfileResult.Folder) },
            { "useSingleConnection", scmTacacsServerProfile5Ds.Apply(getTacacsServerProfileResult => getTacacsServerProfileResult.UseSingleConnection) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.ScmFunctions;
import com.pulumi.scm.inputs.GetTacacsServerProfileArgs;
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) {
        // Look up the multi-tag address object by its ID.
        final var scmTacacsServerProfile5Ds = ScmFunctions.getTacacsServerProfile(GetTacacsServerProfileArgs.builder()
            .id("1967a784-402b-4c20-aa48-aab64d73cc06")
            .build());

        ctx.export("profileDataSourceResults", Map.ofEntries(
            Map.entry("name", scmTacacsServerProfile5Ds.name()),
            Map.entry("protocol", scmTacacsServerProfile5Ds.protocol()),
            Map.entry("timeout", scmTacacsServerProfile5Ds.timeout()),
            Map.entry("folder", scmTacacsServerProfile5Ds.folder()),
            Map.entry("useSingleConnection", scmTacacsServerProfile5Ds.useSingleConnection())
        ));
    }
}

variables:
  # Look up the multi-tag address object by its ID.
  scmTacacsServerProfile5Ds:
    fn::invoke:
      function: scm:getTacacsServerProfile
      arguments:
        id: 1967a784-402b-4c20-aa48-aab64d73cc06
outputs:
  # Output various attributes from the found objects to verify the lookups were successful.
  profileDataSourceResults:
    name: ${scmTacacsServerProfile5Ds.name}
    protocol: ${scmTacacsServerProfile5Ds.protocol}
    timeout: ${scmTacacsServerProfile5Ds.timeout}
    folder: ${scmTacacsServerProfile5Ds.folder}
    useSingleConnection: ${scmTacacsServerProfile5Ds.useSingleConnection}

function getTacacsServerProfile(args: GetTacacsServerProfileArgs, opts?: InvokeOptions): Promise<GetTacacsServerProfileResult>
function getTacacsServerProfileOutput(args: GetTacacsServerProfileOutputArgs, opts?: InvokeOptions): Output<GetTacacsServerProfileResult>

def get_tacacs_server_profile(device: Optional[str] = None,
                              folder: Optional[str] = None,
                              id: Optional[str] = None,
                              name: Optional[str] = None,
                              snippet: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetTacacsServerProfileResult
def get_tacacs_server_profile_output(device: Optional[pulumi.Input[str]] = None,
                              folder: Optional[pulumi.Input[str]] = None,
                              id: Optional[pulumi.Input[str]] = None,
                              name: Optional[pulumi.Input[str]] = None,
                              snippet: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetTacacsServerProfileResult]

func LookupTacacsServerProfile(ctx *Context, args *LookupTacacsServerProfileArgs, opts ...InvokeOption) (*LookupTacacsServerProfileResult, error)
func LookupTacacsServerProfileOutput(ctx *Context, args *LookupTacacsServerProfileOutputArgs, opts ...InvokeOption) LookupTacacsServerProfileResultOutput

public static class GetTacacsServerProfile 
{
    public static Task<GetTacacsServerProfileResult> InvokeAsync(GetTacacsServerProfileArgs args, InvokeOptions? opts = null)
    public static Output<GetTacacsServerProfileResult> Invoke(GetTacacsServerProfileInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTacacsServerProfileResult> getTacacsServerProfile(GetTacacsServerProfileArgs args, InvokeOptions options)
public static Output<GetTacacsServerProfileResult> getTacacsServerProfile(GetTacacsServerProfileArgs args, InvokeOptions options)

fn::invoke:
  function: scm:index/getTacacsServerProfile:getTacacsServerProfile
  arguments:
    # arguments dictionary