azuredevops.getPools

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));

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])

package main

import (
	"github.com/pulumi/pulumi-azuredevops/sdk/v3/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
	})
}

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 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()));
    }
}

function getPools(opts?: InvokeOptions): Promise<GetPoolsResult>
function getPoolsOutput(opts?: InvokeOptions): Output<GetPoolsResult>

def get_pools(opts: Optional[InvokeOptions] = None) -> GetPoolsResult
def get_pools_output(opts: Optional[InvokeOptions] = None) -> Output[GetPoolsResult]

func GetPools(ctx *Context, opts ...InvokeOption) (*GetPoolsResult, error)
func GetPoolsOutput(ctx *Context, opts ...InvokeOption) GetPoolsResultOutput

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

public static CompletableFuture<GetPoolsResult> getPools(InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: azuredevops:index/getPools:getPools
  arguments:
    # arguments dictionary