scm.getRadiusServerProfile

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

const chapRadiusProfile = new scm.RadiusServerProfile("chap_radius_profile", {
    name: "CHAP_only_rsp_ds_1",
    folder: "All",
    retries: 5,
    timeout: 60,
    protocol: {
        cHAP: {},
    },
    servers: [{
        name: "Chap_Server_Primary",
        ipAddress: "10.1.1.10",
        port: 1812,
        secret: "-AQ==lhyuV6U/j9Trb9JL9L0UoBecg9Y=kTOWntGhZ1KFyLD+etKQ3g==",
    }],
});
const singleProfileById = scm.getRadiusServerProfileOutput({
    id: chapRadiusProfile.id,
});
export const singleRspDump = singleProfileById.apply(singleProfileById => singleProfileById.name);

import pulumi
import pulumi_scm as scm

chap_radius_profile = scm.RadiusServerProfile("chap_radius_profile",
    name="CHAP_only_rsp_ds_1",
    folder="All",
    retries=5,
    timeout=60,
    protocol={
        "c_hap": {},
    },
    servers=[{
        "name": "Chap_Server_Primary",
        "ip_address": "10.1.1.10",
        "port": 1812,
        "secret": "-AQ==lhyuV6U/j9Trb9JL9L0UoBecg9Y=kTOWntGhZ1KFyLD+etKQ3g==",
    }])
single_profile_by_id = scm.get_radius_server_profile_output(id=chap_radius_profile.id)
pulumi.export("singleRspDump", single_profile_by_id.name)

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 {
		chapRadiusProfile, err := scm.NewRadiusServerProfile(ctx, "chap_radius_profile", &scm.RadiusServerProfileArgs{
			Name:    pulumi.String("CHAP_only_rsp_ds_1"),
			Folder:  pulumi.String("All"),
			Retries: pulumi.Int(5),
			Timeout: pulumi.Int(60),
			Protocol: &scm.RadiusServerProfileProtocolArgs{
				CHAP: &scm.RadiusServerProfileProtocolChapArgs{},
			},
			Servers: scm.RadiusServerProfileServerArray{
				&scm.RadiusServerProfileServerArgs{
					Name:      pulumi.String("Chap_Server_Primary"),
					IpAddress: pulumi.String("10.1.1.10"),
					Port:      pulumi.Int(1812),
					Secret:    pulumi.String("-AQ==lhyuV6U/j9Trb9JL9L0UoBecg9Y=kTOWntGhZ1KFyLD+etKQ3g=="),
				},
			},
		})
		if err != nil {
			return err
		}
		singleProfileById := scm.LookupRadiusServerProfileOutput(ctx, scm.GetRadiusServerProfileOutputArgs{
			Id: chapRadiusProfile.ID(),
		}, nil)
		ctx.Export("singleRspDump", singleProfileById.ApplyT(func(singleProfileById scm.GetRadiusServerProfileResult) (*string, error) {
			return &singleProfileById.Name, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var chapRadiusProfile = new Scm.RadiusServerProfile("chap_radius_profile", new()
    {
        Name = "CHAP_only_rsp_ds_1",
        Folder = "All",
        Retries = 5,
        Timeout = 60,
        Protocol = new Scm.Inputs.RadiusServerProfileProtocolArgs
        {
            CHAP = null,
        },
        Servers = new[]
        {
            new Scm.Inputs.RadiusServerProfileServerArgs
            {
                Name = "Chap_Server_Primary",
                IpAddress = "10.1.1.10",
                Port = 1812,
                Secret = "-AQ==lhyuV6U/j9Trb9JL9L0UoBecg9Y=kTOWntGhZ1KFyLD+etKQ3g==",
            },
        },
    });

    var singleProfileById = Scm.GetRadiusServerProfile.Invoke(new()
    {
        Id = chapRadiusProfile.Id,
    });

    return new Dictionary<string, object?>
    {
        ["singleRspDump"] = singleProfileById.Apply(getRadiusServerProfileResult => getRadiusServerProfileResult.Name),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.RadiusServerProfile;
import com.pulumi.scm.RadiusServerProfileArgs;
import com.pulumi.scm.inputs.RadiusServerProfileProtocolArgs;
import com.pulumi.scm.inputs.RadiusServerProfileServerArgs;
import com.pulumi.scm.ScmFunctions;
import com.pulumi.scm.inputs.GetRadiusServerProfileArgs;
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) {
        var chapRadiusProfile = new RadiusServerProfile("chapRadiusProfile", RadiusServerProfileArgs.builder()
            .name("CHAP_only_rsp_ds_1")
            .folder("All")
            .retries(5)
            .timeout(60)
            .protocol(RadiusServerProfileProtocolArgs.builder()
                .cHAP(RadiusServerProfileProtocolChapArgs.builder()
                    .build())
                .build())
            .servers(RadiusServerProfileServerArgs.builder()
                .name("Chap_Server_Primary")
                .ipAddress("10.1.1.10")
                .port(1812)
                .secret("-AQ==lhyuV6U/j9Trb9JL9L0UoBecg9Y=kTOWntGhZ1KFyLD+etKQ3g==")
                .build())
            .build());

        final var singleProfileById = ScmFunctions.getRadiusServerProfile(GetRadiusServerProfileArgs.builder()
            .id(chapRadiusProfile.id())
            .build());

        ctx.export("singleRspDump", singleProfileById.applyValue(_singleProfileById -> _singleProfileById.name()));
    }
}

resources:
  chapRadiusProfile:
    type: scm:RadiusServerProfile
    name: chap_radius_profile
    properties:
      name: CHAP_only_rsp_ds_1
      folder: All
      retries: 5
      timeout: 60
      protocol:
        cHAP: {}
      servers:
        - name: Chap_Server_Primary
          ipAddress: 10.1.1.10
          port: 1812
          secret: -AQ==lhyuV6U/j9Trb9JL9L0UoBecg9Y=kTOWntGhZ1KFyLD+etKQ3g==
variables:
  singleProfileById:
    fn::invoke:
      function: scm:getRadiusServerProfile
      arguments:
        id: ${chapRadiusProfile.id}
outputs:
  singleRspDump: ${singleProfileById.name}

function getRadiusServerProfile(args: GetRadiusServerProfileArgs, opts?: InvokeOptions): Promise<GetRadiusServerProfileResult>
function getRadiusServerProfileOutput(args: GetRadiusServerProfileOutputArgs, opts?: InvokeOptions): Output<GetRadiusServerProfileResult>

def get_radius_server_profile(id: Optional[str] = None,
                              name: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetRadiusServerProfileResult
def get_radius_server_profile_output(id: Optional[pulumi.Input[str]] = None,
                              name: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetRadiusServerProfileResult]

func LookupRadiusServerProfile(ctx *Context, args *LookupRadiusServerProfileArgs, opts ...InvokeOption) (*LookupRadiusServerProfileResult, error)
func LookupRadiusServerProfileOutput(ctx *Context, args *LookupRadiusServerProfileOutputArgs, opts ...InvokeOption) LookupRadiusServerProfileResultOutput

public static class GetRadiusServerProfile 
{
    public static Task<GetRadiusServerProfileResult> InvokeAsync(GetRadiusServerProfileArgs args, InvokeOptions? opts = null)
    public static Output<GetRadiusServerProfileResult> Invoke(GetRadiusServerProfileInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRadiusServerProfileResult> getRadiusServerProfile(GetRadiusServerProfileArgs args, InvokeOptions options)
public static Output<GetRadiusServerProfileResult> getRadiusServerProfile(GetRadiusServerProfileArgs args, InvokeOptions options)

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