volcengine.cen.Cens

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

const fooCen: volcengine.cen.Cen[] = [];
for (const range = {value: 0}; range.value < 2; range.value++) {
    fooCen.push(new volcengine.cen.Cen(`fooCen-${range.value}`, {
        cenName: "acc-test-cen",
        description: "acc-test",
        projectName: "default",
        tags: [{
            key: "k1",
            value: "v1",
        }],
    }));
}
const fooCens = volcengine.cen.CensOutput({
    ids: fooCen.map(__item => __item.id),
});

import pulumi
import pulumi_volcengine as volcengine

foo_cen = []
for range in [{"value": i} for i in range(0, 2)]:
    foo_cen.append(volcengine.cen.Cen(f"fooCen-{range['value']}",
        cen_name="acc-test-cen",
        description="acc-test",
        project_name="default",
        tags=[volcengine.cen.CenTagArgs(
            key="k1",
            value="v1",
        )]))
foo_cens = volcengine.cen.cens_output(ids=[__item.id for __item in foo_cen])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/cen"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var fooCen []*cen.Cen
for index := 0; index < 2; index++ {
    key0 := index
    _ := index
__res, err := cen.NewCen(ctx, fmt.Sprintf("fooCen-%v", key0), &cen.CenArgs{
CenName: pulumi.String("acc-test-cen"),
Description: pulumi.String("acc-test"),
ProjectName: pulumi.String("default"),
Tags: cen.CenTagArray{
&cen.CenTagArgs{
Key: pulumi.String("k1"),
Value: pulumi.String("v1"),
},
},
})
if err != nil {
return err
}
fooCen = append(fooCen, __res)
}
_ = cen.CensOutput(ctx, cen.CensOutputArgs{
Ids: %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ #-functions-volcengine:cen-cens:Cens.pp:14,9-21),
}, nil);
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var fooCen = new List<Volcengine.Cen.Cen>();
    for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        fooCen.Add(new Volcengine.Cen.Cen($"fooCen-{range.Value}", new()
        {
            CenName = "acc-test-cen",
            Description = "acc-test",
            ProjectName = "default",
            Tags = new[]
            {
                new Volcengine.Cen.Inputs.CenTagArgs
                {
                    Key = "k1",
                    Value = "v1",
                },
            },
        }));
    }
    var fooCens = Volcengine.Cen.Cens.Invoke(new()
    {
        Ids = fooCen.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.cen.Cen;
import com.pulumi.volcengine.cen.CenArgs;
import com.pulumi.volcengine.cen.inputs.CenTagArgs;
import com.pulumi.volcengine.cen.CenFunctions;
import com.pulumi.volcengine.cen.inputs.CensArgs;
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 Cen("fooCen-" + i, CenArgs.builder()            
                .cenName("acc-test-cen")
                .description("acc-test")
                .projectName("default")
                .tags(CenTagArgs.builder()
                    .key("k1")
                    .value("v1")
                    .build())
                .build());

        
}
        final var fooCens = CenFunctions.Cens(CensArgs.builder()
            .ids(fooCen.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

function cens(args: CensArgs, opts?: InvokeOptions): Promise<CensResult>
function censOutput(args: CensOutputArgs, opts?: InvokeOptions): Output<CensResult>

def cens(cen_names: Optional[Sequence[str]] = None,
         ids: Optional[Sequence[str]] = None,
         name_regex: Optional[str] = None,
         output_file: Optional[str] = None,
         tags: Optional[Sequence[CensTag]] = None,
         opts: Optional[InvokeOptions] = None) -> CensResult
def cens_output(cen_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
         ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
         name_regex: Optional[pulumi.Input[str]] = None,
         output_file: Optional[pulumi.Input[str]] = None,
         tags: Optional[pulumi.Input[Sequence[pulumi.Input[CensTagArgs]]]] = None,
         opts: Optional[InvokeOptions] = None) -> Output[CensResult]

func Cens(ctx *Context, args *CensArgs, opts ...InvokeOption) (*CensResult, error)
func CensOutput(ctx *Context, args *CensOutputArgs, opts ...InvokeOption) CensResultOutput

public static class Cens 
{
    public static Task<CensResult> InvokeAsync(CensArgs args, InvokeOptions? opts = null)
    public static Output<CensResult> Invoke(CensInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<CensResult> cens(CensArgs args, InvokeOptions options)
public static Output<CensResult> cens(CensArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:cen:Cens
  arguments:
    # arguments dictionary