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, map[string]interface{}{
}, nil);
if err != nil {
return err
}
ctx.Export("agentPoolName", pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:3,11-37)))
ctx.Export("autoProvision", pulumi.BoolArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:7,11-46)))
ctx.Export("autoUpdate", pulumi.BoolArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:11,11-43)))
ctx.Export("poolType", pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:15,11-41)))
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(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        ctx.export("agentPoolName", example.agentPools().stream().map(element -> element.name()).collect(toList()));
        ctx.export("autoProvision", example.agentPools().stream().map(element -> element.autoProvision()).collect(toList()));
        ctx.export("autoUpdate", example.agentPools().stream().map(element -> element.autoUpdate()).collect(toList()));
        ctx.export("poolType", example.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)
public static Output<GetPoolsResult> getPools(InvokeOptions options)

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