volcengine.cloud_identity.PermissionSets

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

const fooPermissionSet: volcengine.cloud_identity.PermissionSet[] = [];
for (const range = {value: 0}; range.value < 2; range.value++) {
    fooPermissionSet.push(new volcengine.cloud_identity.PermissionSet(`fooPermissionSet-${range.value}`, {
        description: "tf",
        sessionDuration: 5000,
        permissionPolicies: [
            {
                permissionPolicyType: "System",
                permissionPolicyName: "AdministratorAccess",
                inlinePolicyDocument: "",
            },
            {
                permissionPolicyType: "System",
                permissionPolicyName: "ReadOnlyAccess",
                inlinePolicyDocument: "",
            },
            {
                permissionPolicyType: "Inline",
                inlinePolicyDocument: "{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"auto_scaling:DescribeScalingGroups\"],\"Resource\":[\"*\"]}]}",
            },
        ],
    }));
}
const fooPermissionSets = volcengine.cloud_identity.PermissionSetsOutput({
    ids: fooPermissionSet.map(__item => __item.id),
});

import pulumi
import pulumi_volcengine as volcengine

foo_permission_set = []
for range in [{"value": i} for i in range(0, 2)]:
    foo_permission_set.append(volcengine.cloud_identity.PermissionSet(f"fooPermissionSet-{range['value']}",
        description="tf",
        session_duration=5000,
        permission_policies=[
            volcengine.cloud_identity.PermissionSetPermissionPolicyArgs(
                permission_policy_type="System",
                permission_policy_name="AdministratorAccess",
                inline_policy_document="",
            ),
            volcengine.cloud_identity.PermissionSetPermissionPolicyArgs(
                permission_policy_type="System",
                permission_policy_name="ReadOnlyAccess",
                inline_policy_document="",
            ),
            volcengine.cloud_identity.PermissionSetPermissionPolicyArgs(
                permission_policy_type="Inline",
                inline_policy_document="{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"auto_scaling:DescribeScalingGroups\"],\"Resource\":[\"*\"]}]}",
            ),
        ]))
foo_permission_sets = volcengine.cloud_identity.permission_sets_output(ids=[__item.id for __item in foo_permission_set])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/cloud_identity"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var fooPermissionSet []*cloud_identity.PermissionSet
for index := 0; index < 2; index++ {
    key0 := index
    _ := index
__res, err := cloud_identity.NewPermissionSet(ctx, fmt.Sprintf("fooPermissionSet-%v", key0), &cloud_identity.PermissionSetArgs{
Description: pulumi.String("tf"),
SessionDuration: pulumi.Int(5000),
PermissionPolicies: cloud_identity.PermissionSetPermissionPolicyArray{
&cloud_identity.PermissionSetPermissionPolicyArgs{
PermissionPolicyType: pulumi.String("System"),
PermissionPolicyName: pulumi.String("AdministratorAccess"),
InlinePolicyDocument: pulumi.String(""),
},
&cloud_identity.PermissionSetPermissionPolicyArgs{
PermissionPolicyType: pulumi.String("System"),
PermissionPolicyName: pulumi.String("ReadOnlyAccess"),
InlinePolicyDocument: pulumi.String(""),
},
&cloud_identity.PermissionSetPermissionPolicyArgs{
PermissionPolicyType: pulumi.String("Inline"),
InlinePolicyDocument: pulumi.String("{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"auto_scaling:DescribeScalingGroups\"],\"Resource\":[\"*\"]}]}"),
},
},
})
if err != nil {
return err
}
fooPermissionSet = append(fooPermissionSet, __res)
}
_ = cloud_identity.PermissionSetsOutput(ctx, cloud_identity.PermissionSetsOutputArgs{
Ids: %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ #-functions-volcengine:cloud_identity-permissionSets:PermissionSets.pp:23,9-31),
}, nil);
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var fooPermissionSet = new List<Volcengine.Cloud_identity.PermissionSet>();
    for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        fooPermissionSet.Add(new Volcengine.Cloud_identity.PermissionSet($"fooPermissionSet-{range.Value}", new()
        {
            Description = "tf",
            SessionDuration = 5000,
            PermissionPolicies = new[]
            {
                new Volcengine.Cloud_identity.Inputs.PermissionSetPermissionPolicyArgs
                {
                    PermissionPolicyType = "System",
                    PermissionPolicyName = "AdministratorAccess",
                    InlinePolicyDocument = "",
                },
                new Volcengine.Cloud_identity.Inputs.PermissionSetPermissionPolicyArgs
                {
                    PermissionPolicyType = "System",
                    PermissionPolicyName = "ReadOnlyAccess",
                    InlinePolicyDocument = "",
                },
                new Volcengine.Cloud_identity.Inputs.PermissionSetPermissionPolicyArgs
                {
                    PermissionPolicyType = "Inline",
                    InlinePolicyDocument = "{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"auto_scaling:DescribeScalingGroups\"],\"Resource\":[\"*\"]}]}",
                },
            },
        }));
    }
    var fooPermissionSets = Volcengine.Cloud_identity.PermissionSets.Invoke(new()
    {
        Ids = fooPermissionSet.Select(__item => __item.Id).ToList(),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.cloud_identity.PermissionSet;
import com.pulumi.volcengine.cloud_identity.PermissionSetArgs;
import com.pulumi.volcengine.cloud_identity.inputs.PermissionSetPermissionPolicyArgs;
import com.pulumi.volcengine.cloud_identity.Cloud_identityFunctions;
import com.pulumi.volcengine.cloud_identity.inputs.PermissionSetsArgs;
import com.pulumi.codegen.internal.KeyedValue;
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) {
        for (var i = 0; i < 2; i++) {
            new PermissionSet("fooPermissionSet-" + i, PermissionSetArgs.builder()            
                .description("tf")
                .sessionDuration(5000)
                .permissionPolicies(                
                    PermissionSetPermissionPolicyArgs.builder()
                        .permissionPolicyType("System")
                        .permissionPolicyName("AdministratorAccess")
                        .inlinePolicyDocument("")
                        .build(),
                    PermissionSetPermissionPolicyArgs.builder()
                        .permissionPolicyType("System")
                        .permissionPolicyName("ReadOnlyAccess")
                        .inlinePolicyDocument("")
                        .build(),
                    PermissionSetPermissionPolicyArgs.builder()
                        .permissionPolicyType("Inline")
                        .inlinePolicyDocument("{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"auto_scaling:DescribeScalingGroups\"],\"Resource\":[\"*\"]}]}")
                        .build())
                .build());

        
}
        final var fooPermissionSets = Cloud_identityFunctions.PermissionSets(PermissionSetsArgs.builder()
            .ids(fooPermissionSet.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

function permissionSets(args: PermissionSetsArgs, opts?: InvokeOptions): Promise<PermissionSetsResult>
function permissionSetsOutput(args: PermissionSetsOutputArgs, opts?: InvokeOptions): Output<PermissionSetsResult>

def permission_sets(ids: Optional[Sequence[str]] = None,
                    name_regex: Optional[str] = None,
                    output_file: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> PermissionSetsResult
def permission_sets_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                    name_regex: Optional[pulumi.Input[str]] = None,
                    output_file: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[PermissionSetsResult]

func PermissionSets(ctx *Context, args *PermissionSetsArgs, opts ...InvokeOption) (*PermissionSetsResult, error)
func PermissionSetsOutput(ctx *Context, args *PermissionSetsOutputArgs, opts ...InvokeOption) PermissionSetsResultOutput

public static class PermissionSets 
{
    public static Task<PermissionSetsResult> InvokeAsync(PermissionSetsArgs args, InvokeOptions? opts = null)
    public static Output<PermissionSetsResult> Invoke(PermissionSetsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<PermissionSetsResult> permissionSets(PermissionSetsArgs args, InvokeOptions options)
public static Output<PermissionSetsResult> permissionSets(PermissionSetsArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:cloud_identity:PermissionSets
  arguments:
    # arguments dictionary