aquasec.getGateways

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

const testgateway = aquasec.getGateways({});
export const gatewayData = testgateway;
export const gatewayName = testgateway.then(testgateway => testgateway.gateways?.[0]?.id);
export const gatewayStatus = testgateway.then(testgateway => testgateway.gateways?.[0]?.status);
export const gatewayDescription = testgateway.then(testgateway => testgateway.gateways?.[0]?.description);
export const gatewayVersion = testgateway.then(testgateway => testgateway.gateways?.[0]?.version);
export const gatewayHostname = testgateway.then(testgateway => testgateway.gateways?.[0]?.hostname);
export const gatewayGrpcAddress = testgateway.then(testgateway => testgateway.gateways?.[0]?.grpcAddress);

import pulumi
import pulumi_aquasec as aquasec

testgateway = aquasec.get_gateways()
pulumi.export("gatewayData", testgateway)
pulumi.export("gatewayName", testgateway.gateways[0].id)
pulumi.export("gatewayStatus", testgateway.gateways[0].status)
pulumi.export("gatewayDescription", testgateway.gateways[0].description)
pulumi.export("gatewayVersion", testgateway.gateways[0].version)
pulumi.export("gatewayHostname", testgateway.gateways[0].hostname)
pulumi.export("gatewayGrpcAddress", testgateway.gateways[0].grpc_address)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testgateway, err := aquasec.GetGateways(ctx, nil, nil)
		if err != nil {
			return err
		}
		ctx.Export("gatewayData", testgateway)
		ctx.Export("gatewayName", testgateway.Gateways[0].Id)
		ctx.Export("gatewayStatus", testgateway.Gateways[0].Status)
		ctx.Export("gatewayDescription", testgateway.Gateways[0].Description)
		ctx.Export("gatewayVersion", testgateway.Gateways[0].Version)
		ctx.Export("gatewayHostname", testgateway.Gateways[0].Hostname)
		ctx.Export("gatewayGrpcAddress", testgateway.Gateways[0].GrpcAddress)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testgateway = Aquasec.GetGateways.Invoke();

    return new Dictionary<string, object?>
    {
        ["gatewayData"] = testgateway,
        ["gatewayName"] = testgateway.Apply(getGatewaysResult => getGatewaysResult.Gateways[0]?.Id),
        ["gatewayStatus"] = testgateway.Apply(getGatewaysResult => getGatewaysResult.Gateways[0]?.Status),
        ["gatewayDescription"] = testgateway.Apply(getGatewaysResult => getGatewaysResult.Gateways[0]?.Description),
        ["gatewayVersion"] = testgateway.Apply(getGatewaysResult => getGatewaysResult.Gateways[0]?.Version),
        ["gatewayHostname"] = testgateway.Apply(getGatewaysResult => getGatewaysResult.Gateways[0]?.Hostname),
        ["gatewayGrpcAddress"] = testgateway.Apply(getGatewaysResult => getGatewaysResult.Gateways[0]?.GrpcAddress),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aquasec.AquasecFunctions;
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 testgateway = AquasecFunctions.getGateways();

        ctx.export("gatewayData", testgateway.applyValue(getGatewaysResult -> getGatewaysResult));
        ctx.export("gatewayName", testgateway.applyValue(getGatewaysResult -> getGatewaysResult.gateways()[0].id()));
        ctx.export("gatewayStatus", testgateway.applyValue(getGatewaysResult -> getGatewaysResult.gateways()[0].status()));
        ctx.export("gatewayDescription", testgateway.applyValue(getGatewaysResult -> getGatewaysResult.gateways()[0].description()));
        ctx.export("gatewayVersion", testgateway.applyValue(getGatewaysResult -> getGatewaysResult.gateways()[0].version()));
        ctx.export("gatewayHostname", testgateway.applyValue(getGatewaysResult -> getGatewaysResult.gateways()[0].hostname()));
        ctx.export("gatewayGrpcAddress", testgateway.applyValue(getGatewaysResult -> getGatewaysResult.gateways()[0].grpcAddress()));
    }
}

variables:
  testgateway:
    fn::invoke:
      Function: aquasec:getGateways
      Arguments: {}
outputs:
  gatewayData: ${testgateway}
  gatewayName: ${testgateway.gateways[0].id}
  gatewayStatus: ${testgateway.gateways[0].status}
  gatewayDescription: ${testgateway.gateways[0].description}
  gatewayVersion: ${testgateway.gateways[0].version}
  gatewayHostname: ${testgateway.gateways[0].hostname}
  gatewayGrpcAddress: ${testgateway.gateways[0].grpcAddress}

function getGateways(opts?: InvokeOptions): Promise<GetGatewaysResult>
function getGatewaysOutput(opts?: InvokeOptions): Output<GetGatewaysResult>

def get_gateways(opts: Optional[InvokeOptions] = None) -> GetGatewaysResult
def get_gateways_output(opts: Optional[InvokeOptions] = None) -> Output[GetGatewaysResult]

func GetGateways(ctx *Context, opts ...InvokeOption) (*GetGatewaysResult, error)
func GetGatewaysOutput(ctx *Context, opts ...InvokeOption) GetGatewaysResultOutput

public static class GetGateways 
{
    public static Task<GetGatewaysResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetGatewaysResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetGatewaysResult> getGateways(InvokeOptions options)
public static Output<GetGatewaysResult> getGateways(InvokeOptions options)

fn::invoke:
  function: aquasec:index/getGateways:getGateways
  arguments:
    # arguments dictionary