volcengine.bandwidth_package.BandwidthPackages

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

return await Deployment.RunAsync(() => 
{
    var fooBandwidthPackage = new List<Volcengine.Bandwidth_package.BandwidthPackage>();
    for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        fooBandwidthPackage.Add(new Volcengine.Bandwidth_package.BandwidthPackage($"fooBandwidthPackage-{range.Value}", new()
        {
            BandwidthPackageName = "acc-test-bp",
            BillingType = "PostPaidByBandwidth",
            Isp = "BGP",
            Description = "acc-test",
            Bandwidth = 2,
            Protocol = "IPv4",
            SecurityProtectionTypes = new[]
            {
                "AntiDDoS_Enhanced",
            },
            Tags = new[]
            {
                new Volcengine.Bandwidth_package.Inputs.BandwidthPackageTagArgs
                {
                    Key = "k1",
                    Value = "v1",
                },
            },
        }));
    }
    var fooBandwidthPackages = Volcengine.Bandwidth_package.BandwidthPackages.Invoke(new()
    {
        Ids = fooBandwidthPackage.Select(__item => __item.Id).ToList(),
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/bandwidth_package"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var fooBandwidthPackage []*bandwidth_package.BandwidthPackage
for index := 0; index < 2; index++ {
    key0 := index
    _ := index
__res, err := bandwidth_package.NewBandwidthPackage(ctx, fmt.Sprintf("fooBandwidthPackage-%v", key0), &bandwidth_package.BandwidthPackageArgs{
BandwidthPackageName: pulumi.String("acc-test-bp"),
BillingType: pulumi.String("PostPaidByBandwidth"),
Isp: pulumi.String("BGP"),
Description: pulumi.String("acc-test"),
Bandwidth: pulumi.Int(2),
Protocol: pulumi.String("IPv4"),
SecurityProtectionTypes: pulumi.StringArray{
pulumi.String("AntiDDoS_Enhanced"),
},
Tags: bandwidth_package.BandwidthPackageTagArray{
&bandwidth_package.BandwidthPackageTagArgs{
Key: pulumi.String("k1"),
Value: pulumi.String("v1"),
},
},
})
if err != nil {
return err
}
fooBandwidthPackage = append(fooBandwidthPackage, __res)
}
_ = bandwidth_package.BandwidthPackagesOutput(ctx, bandwidth_package.BandwidthPackagesOutputArgs{
Ids: %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ #-functions-volcengine:bandwidth_package-bandwidthPackages:BandwidthPackages.pp:18,9-34),
}, nil);
return nil
})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.bandwidth_package.BandwidthPackage;
import com.pulumi.volcengine.bandwidth_package.BandwidthPackageArgs;
import com.pulumi.volcengine.bandwidth_package.inputs.BandwidthPackageTagArgs;
import com.pulumi.volcengine.bandwidth_package.Bandwidth_packageFunctions;
import com.pulumi.volcengine.bandwidth_package.inputs.BandwidthPackagesArgs;
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 BandwidthPackage("fooBandwidthPackage-" + i, BandwidthPackageArgs.builder()            
                .bandwidthPackageName("acc-test-bp")
                .billingType("PostPaidByBandwidth")
                .isp("BGP")
                .description("acc-test")
                .bandwidth(2)
                .protocol("IPv4")
                .securityProtectionTypes("AntiDDoS_Enhanced")
                .tags(BandwidthPackageTagArgs.builder()
                    .key("k1")
                    .value("v1")
                    .build())
                .build());

        
}
        final var fooBandwidthPackages = Bandwidth_packageFunctions.BandwidthPackages(BandwidthPackagesArgs.builder()
            .ids(fooBandwidthPackage.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo_bandwidth_package = []
for range in [{"value": i} for i in range(0, 2)]:
    foo_bandwidth_package.append(volcengine.bandwidth_package.BandwidthPackage(f"fooBandwidthPackage-{range['value']}",
        bandwidth_package_name="acc-test-bp",
        billing_type="PostPaidByBandwidth",
        isp="BGP",
        description="acc-test",
        bandwidth=2,
        protocol="IPv4",
        security_protection_types=["AntiDDoS_Enhanced"],
        tags=[volcengine.bandwidth_package.BandwidthPackageTagArgs(
            key="k1",
            value="v1",
        )]))
foo_bandwidth_packages = volcengine.bandwidth_package.bandwidth_packages_output(ids=[__item.id for __item in foo_bandwidth_package])

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

const fooBandwidthPackage: volcengine.bandwidth_package.BandwidthPackage[] = [];
for (const range = {value: 0}; range.value < 2; range.value++) {
    fooBandwidthPackage.push(new volcengine.bandwidth_package.BandwidthPackage(`fooBandwidthPackage-${range.value}`, {
        bandwidthPackageName: "acc-test-bp",
        billingType: "PostPaidByBandwidth",
        isp: "BGP",
        description: "acc-test",
        bandwidth: 2,
        protocol: "IPv4",
        securityProtectionTypes: ["AntiDDoS_Enhanced"],
        tags: [{
            key: "k1",
            value: "v1",
        }],
    }));
}
const fooBandwidthPackages = volcengine.bandwidth_package.BandwidthPackagesOutput({
    ids: fooBandwidthPackage.map(__item => __item.id),
});