azuredevops.getSecurityNamespaces

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

const all = azuredevops.getSecurityNamespaces({});
export const namespaces = all.then(all => all.namespaces);

import pulumi
import pulumi_azuredevops as azuredevops

all = azuredevops.get_security_namespaces()
pulumi.export("namespaces", all.namespaces)

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 {
		all, err := azuredevops.GetSecurityNamespaces(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("namespaces", all.Namespaces)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = AzureDevOps.GetSecurityNamespaces.Invoke();

    return new Dictionary<string, object?>
    {
        ["namespaces"] = all.Apply(getSecurityNamespacesResult => getSecurityNamespacesResult.Namespaces),
    };
});

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 all = AzuredevopsFunctions.getSecurityNamespaces(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        ctx.export("namespaces", all.namespaces());
    }
}

variables:
  all:
    fn::invoke:
      function: azuredevops:getSecurityNamespaces
      arguments: {}
outputs:
  namespaces: ${all.namespaces}

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

const all = azuredevops.getSecurityNamespaces({});
const projectNamespace = all.then(all => .filter(ns => ns.name == "Project").map(ns => (ns))[0]);
export const projectPermissions = .reduce((__obj, action) => ({ ...__obj, [action.name]: {
    displayName: action.displayName,
    bit: action.bit,
} }));

import pulumi
import pulumi_azuredevops as azuredevops

all = azuredevops.get_security_namespaces()
project_namespace = [ns for ns in all.namespaces if ns.name == "Project"][0]
pulumi.export("projectPermissions", {action.name: {
    "displayName": action.display_name,
    "bit": action.bit,
} for action in project_namespace.actions})

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

return await Deployment.RunAsync(() => 
{
    var all = AzureDevOps.GetSecurityNamespaces.Invoke();

    var projectNamespace = .Where(ns => ns.Name == "Project").Select(ns => 
    {
        return ns;
    }).ToList()[0];

    return new Dictionary<string, object?>
    {
        ["projectPermissions"] = .ToDictionary(item => {
            var action = item.Value;
            return action.Name;
        }, item => {
            var action = item.Value;
            return 
            {
                { "displayName", action.DisplayName },
                { "bit", action.Bit },
            };
        }),
    };
});

function getSecurityNamespaces(opts?: InvokeOptions): Promise<GetSecurityNamespacesResult>
function getSecurityNamespacesOutput(opts?: InvokeOptions): Output<GetSecurityNamespacesResult>

def get_security_namespaces(opts: Optional[InvokeOptions] = None) -> GetSecurityNamespacesResult
def get_security_namespaces_output(opts: Optional[InvokeOptions] = None) -> Output[GetSecurityNamespacesResult]

func GetSecurityNamespaces(ctx *Context, opts ...InvokeOption) (*GetSecurityNamespacesResult, error)
func GetSecurityNamespacesOutput(ctx *Context, opts ...InvokeOption) GetSecurityNamespacesResultOutput

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

public static CompletableFuture<GetSecurityNamespacesResult> getSecurityNamespaces(InvokeOptions options)
public static Output<GetSecurityNamespacesResult> getSecurityNamespaces(InvokeOptions options)

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