checkpoint.getManagementRadiusServer

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

const host = new checkpoint.ManagementHost("host", {ipv4Address: "1.2.3.4"});
const radiusServer = new checkpoint.ManagementRadiusServer("radiusServer", {
    server: host.name,
    sharedSecret: "123",
});
const dataRadiusServer = checkpoint.getManagementRadiusServerOutput({
    name: radiusServer.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

host = checkpoint.ManagementHost("host", ipv4_address="1.2.3.4")
radius_server = checkpoint.ManagementRadiusServer("radiusServer",
    server=host.name,
    shared_secret="123")
data_radius_server = checkpoint.get_management_radius_server_output(name=radius_server.name)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		host, err := checkpoint.NewManagementHost(ctx, "host", &checkpoint.ManagementHostArgs{
			Ipv4Address: pulumi.String("1.2.3.4"),
		})
		if err != nil {
			return err
		}
		radiusServer, err := checkpoint.NewManagementRadiusServer(ctx, "radiusServer", &checkpoint.ManagementRadiusServerArgs{
			Server:       host.Name,
			SharedSecret: pulumi.String("123"),
		})
		if err != nil {
			return err
		}
		_ = checkpoint.LookupManagementRadiusServerOutput(ctx, checkpoint.GetManagementRadiusServerOutputArgs{
			Name: radiusServer.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var host = new Checkpoint.ManagementHost("host", new()
    {
        Ipv4Address = "1.2.3.4",
    });

    var radiusServer = new Checkpoint.ManagementRadiusServer("radiusServer", new()
    {
        Server = host.Name,
        SharedSecret = "123",
    });

    var dataRadiusServer = Checkpoint.GetManagementRadiusServer.Invoke(new()
    {
        Name = radiusServer.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementHost;
import com.pulumi.checkpoint.ManagementHostArgs;
import com.pulumi.checkpoint.ManagementRadiusServer;
import com.pulumi.checkpoint.ManagementRadiusServerArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementRadiusServerArgs;
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 host = new ManagementHost("host", ManagementHostArgs.builder()
            .ipv4Address("1.2.3.4")
            .build());

        var radiusServer = new ManagementRadiusServer("radiusServer", ManagementRadiusServerArgs.builder()
            .server(host.name())
            .sharedSecret("123")
            .build());

        final var dataRadiusServer = CheckpointFunctions.getManagementRadiusServer(GetManagementRadiusServerArgs.builder()
            .name(radiusServer.name())
            .build());

    }
}

resources:
  host:
    type: checkpoint:ManagementHost
    properties:
      ipv4Address: 1.2.3.4
  radiusServer:
    type: checkpoint:ManagementRadiusServer
    properties:
      server: ${host.name}
      sharedSecret: '123'
variables:
  dataRadiusServer:
    fn::invoke:
      function: checkpoint:getManagementRadiusServer
      arguments:
        name: ${radiusServer.name}

function getManagementRadiusServer(args: GetManagementRadiusServerArgs, opts?: InvokeOptions): Promise<GetManagementRadiusServerResult>
function getManagementRadiusServerOutput(args: GetManagementRadiusServerOutputArgs, opts?: InvokeOptions): Output<GetManagementRadiusServerResult>

def get_management_radius_server(id: Optional[str] = None,
                                 name: Optional[str] = None,
                                 uid: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetManagementRadiusServerResult
def get_management_radius_server_output(id: Optional[pulumi.Input[str]] = None,
                                 name: Optional[pulumi.Input[str]] = None,
                                 uid: Optional[pulumi.Input[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetManagementRadiusServerResult]

func LookupManagementRadiusServer(ctx *Context, args *LookupManagementRadiusServerArgs, opts ...InvokeOption) (*LookupManagementRadiusServerResult, error)
func LookupManagementRadiusServerOutput(ctx *Context, args *LookupManagementRadiusServerOutputArgs, opts ...InvokeOption) LookupManagementRadiusServerResultOutput

public static class GetManagementRadiusServer 
{
    public static Task<GetManagementRadiusServerResult> InvokeAsync(GetManagementRadiusServerArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementRadiusServerResult> Invoke(GetManagementRadiusServerInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementRadiusServerResult> getManagementRadiusServer(GetManagementRadiusServerArgs args, InvokeOptions options)
public static Output<GetManagementRadiusServerResult> getManagementRadiusServer(GetManagementRadiusServerArgs args, InvokeOptions options)

fn::invoke:
  function: checkpoint:index/getManagementRadiusServer:getManagementRadiusServer
  arguments:
    # arguments dictionary