azuredevops.getPools

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

return await Deployment.RunAsync(() => 
{
    var example = AzureDevOps.GetPools.Invoke();

    return new Dictionary<string, object?>
    {
        ["agentPoolName"] = example.Apply(getPoolsResult => getPoolsResult.AgentPools).Select(__item => __item.Name).ToList(),
        ["autoProvision"] = example.Apply(getPoolsResult => getPoolsResult.AgentPools).Select(__item => __item.AutoProvision).ToList(),
        ["autoUpdate"] = example.Apply(getPoolsResult => getPoolsResult.AgentPools).Select(__item => __item.AutoUpdate).ToList(),
        ["poolType"] = example.Apply(getPoolsResult => getPoolsResult.AgentPools).Select(__item => __item.PoolType).ToList(),
    };
});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := azuredevops.GetPools(ctx, nil, nil)
		if err != nil {
			return err
		}
		var splat0 []*string
		for _, val0 := range example.AgentPools {
			splat0 = append(splat0, val0.Name)
		}
		ctx.Export("agentPoolName", splat0)
		var splat1 []*bool
		for _, val0 := range example.AgentPools {
			splat1 = append(splat1, val0.AutoProvision)
		}
		ctx.Export("autoProvision", splat1)
		var splat2 []*bool
		for _, val0 := range example.AgentPools {
			splat2 = append(splat2, val0.AutoUpdate)
		}
		ctx.Export("autoUpdate", splat2)
		var splat3 []*string
		for _, val0 := range example.AgentPools {
			splat3 = append(splat3, val0.PoolType)
		}
		ctx.Export("poolType", splat3)
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuredevops.AzuredevopsFunctions;
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 example = AzuredevopsFunctions.getPools();

        ctx.export("agentPoolName", example.applyValue(getPoolsResult -> getPoolsResult.agentPools()).stream().map(element -> element.name()).collect(toList()));
        ctx.export("autoProvision", example.applyValue(getPoolsResult -> getPoolsResult.agentPools()).stream().map(element -> element.autoProvision()).collect(toList()));
        ctx.export("autoUpdate", example.applyValue(getPoolsResult -> getPoolsResult.agentPools()).stream().map(element -> element.autoUpdate()).collect(toList()));
        ctx.export("poolType", example.applyValue(getPoolsResult -> getPoolsResult.agentPools()).stream().map(element -> element.poolType()).collect(toList()));
    }
}

import pulumi
import pulumi_azuredevops as azuredevops

example = azuredevops.get_pools()
pulumi.export("agentPoolName", [__item.name for __item in example.agent_pools])
pulumi.export("autoProvision", [__item.auto_provision for __item in example.agent_pools])
pulumi.export("autoUpdate", [__item.auto_update for __item in example.agent_pools])
pulumi.export("poolType", [__item.pool_type for __item in example.agent_pools])

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

const example = azuredevops.getPools({});
export const agentPoolName = example.then(example => example.agentPools.map(__item => __item.name));
export const autoProvision = example.then(example => example.agentPools.map(__item => __item.autoProvision));
export const autoUpdate = example.then(example => example.agentPools.map(__item => __item.autoUpdate));
export const poolType = example.then(example => example.agentPools.map(__item => __item.poolType));