nsxt.getProxyConfig

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

const internetProxy = nsxt.getProxyConfig({});
export const proxyStatus = {
    enabled: internetProxy.then(internetProxy => internetProxy.enabled),
    host: internetProxy.then(internetProxy => internetProxy.host),
    port: internetProxy.then(internetProxy => internetProxy.port),
    scheme: internetProxy.then(internetProxy => internetProxy.scheme),
};

import pulumi
import pulumi_nsxt as nsxt

internet_proxy = nsxt.get_proxy_config()
pulumi.export("proxyStatus", {
    "enabled": internet_proxy.enabled,
    "host": internet_proxy.host,
    "port": internet_proxy.port,
    "scheme": internet_proxy.scheme,
})

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		internetProxy, err := nsxt.LookupProxyConfig(ctx, &nsxt.LookupProxyConfigArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("proxyStatus", pulumi.Map{
			"enabled": internetProxy.Enabled,
			"host":    internetProxy.Host,
			"port":    internetProxy.Port,
			"scheme":  internetProxy.Scheme,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var internetProxy = Nsxt.GetProxyConfig.Invoke();

    return new Dictionary<string, object?>
    {
        ["proxyStatus"] = 
        {
            { "enabled", internetProxy.Apply(getProxyConfigResult => getProxyConfigResult.Enabled) },
            { "host", internetProxy.Apply(getProxyConfigResult => getProxyConfigResult.Host) },
            { "port", internetProxy.Apply(getProxyConfigResult => getProxyConfigResult.Port) },
            { "scheme", internetProxy.Apply(getProxyConfigResult => getProxyConfigResult.Scheme) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nsxt.NsxtFunctions;
import com.pulumi.nsxt.inputs.GetProxyConfigArgs;
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 internetProxy = NsxtFunctions.getProxyConfig(GetProxyConfigArgs.builder()
            .build());

        ctx.export("proxyStatus", Map.ofEntries(
            Map.entry("enabled", internetProxy.enabled()),
            Map.entry("host", internetProxy.host()),
            Map.entry("port", internetProxy.port()),
            Map.entry("scheme", internetProxy.scheme())
        ));
    }
}

variables:
  internetProxy:
    fn::invoke:
      function: nsxt:getProxyConfig
      arguments: {}
outputs:
  proxyStatus:
    enabled: ${internetProxy.enabled}
    host: ${internetProxy.host}
    port: ${internetProxy.port}
    scheme: ${internetProxy.scheme}

function getProxyConfig(args: GetProxyConfigArgs, opts?: InvokeOptions): Promise<GetProxyConfigResult>
function getProxyConfigOutput(args: GetProxyConfigOutputArgs, opts?: InvokeOptions): Output<GetProxyConfigResult>

def get_proxy_config(description: Optional[str] = None,
                     display_name: Optional[str] = None,
                     id: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetProxyConfigResult
def get_proxy_config_output(description: pulumi.Input[Optional[str]] = None,
                     display_name: pulumi.Input[Optional[str]] = None,
                     id: pulumi.Input[Optional[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetProxyConfigResult]

func LookupProxyConfig(ctx *Context, args *LookupProxyConfigArgs, opts ...InvokeOption) (*LookupProxyConfigResult, error)
func LookupProxyConfigOutput(ctx *Context, args *LookupProxyConfigOutputArgs, opts ...InvokeOption) LookupProxyConfigResultOutput

public static class GetProxyConfig 
{
    public static Task<GetProxyConfigResult> InvokeAsync(GetProxyConfigArgs args, InvokeOptions? opts = null)
    public static Output<GetProxyConfigResult> Invoke(GetProxyConfigInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetProxyConfigResult> getProxyConfig(GetProxyConfigArgs args, InvokeOptions options)
public static Output<GetProxyConfigResult> getProxyConfig(GetProxyConfigArgs args, InvokeOptions options)

fn::invoke:
  function: nsxt:index/getProxyConfig:getProxyConfig
  arguments:
    # arguments dictionary

data "nsxt_getproxyconfig" "name" {
    # arguments
}