alicloud.esa.getWafRulesets

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const _default = alicloud.esa.getSites({
    planSubscribeType: "enterpriseplan",
});
const defaultWafRuleset = new alicloud.esa.WafRuleset("default", {
    siteId: _default.then(_default => _default.sites?.[0]?.siteId),
    phase: "http_custom",
    siteVersion: 0,
    name: name,
});
const ids = pulumi.all([defaultWafRuleset.id, defaultWafRuleset.siteId, defaultWafRuleset.phase, defaultWafRuleset.siteVersion]).apply(([id, siteId, phase, siteVersion]) => alicloud.esa.getWafRulesetsOutput({
    ids: [id],
    siteId: siteId,
    phase: phase,
    siteVersion: siteVersion,
}));
export const esaWafRulesetsId0 = ids.apply(ids => ids.sets?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default = alicloud.esa.get_sites(plan_subscribe_type="enterpriseplan")
default_waf_ruleset = alicloud.esa.WafRuleset("default",
    site_id=default.sites[0].site_id,
    phase="http_custom",
    site_version=0,
    name=name)
ids = pulumi.Output.all(
    id=default_waf_ruleset.id,
    site_id=default_waf_ruleset.site_id,
    phase=default_waf_ruleset.phase,
    site_version=default_waf_ruleset.site_version
).apply(lambda resolved_outputs: alicloud.esa.get_waf_rulesets_output(ids=[resolved_outputs['id']],
    site_id=resolved_outputs['site_id'],
    phase=resolved_outputs['phase'],
    site_version=resolved_outputs['site_version']))

pulumi.export("esaWafRulesetsId0", ids.sets[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/esa"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := esa.GetSites(ctx, &esa.GetSitesArgs{
			PlanSubscribeType: pulumi.StringRef("enterpriseplan"),
		}, nil)
		if err != nil {
			return err
		}
		defaultWafRuleset, err := esa.NewWafRuleset(ctx, "default", &esa.WafRulesetArgs{
			SiteId:      pulumi.String(pulumi.Int(_default.Sites[0].SiteId)),
			Phase:       pulumi.String("http_custom"),
			SiteVersion: pulumi.Int(0),
			Name:        pulumi.String(pulumi.String(name)),
		})
		if err != nil {
			return err
		}
		ids := pulumi.All(defaultWafRuleset.ID(), defaultWafRuleset.SiteId, defaultWafRuleset.Phase, defaultWafRuleset.SiteVersion).ApplyT(func(_args []interface{}) (esa.GetWafRulesetsResult, error) {
			id := _args[0].(string)
			siteId := _args[1].(string)
			phase := _args[2].(string)
			siteVersion := _args[3].(*int)
			return esa.GetWafRulesetsResult(interface{}(esa.GetWafRulesets(ctx, &esa.GetWafRulesetsArgs{
				Ids: []string{
					id,
				},
				SiteId:      siteId,
				Phase:       phase,
				SiteVersion: siteVersion,
			}, nil))), nil
		}).(esa.GetWafRulesetsResultOutput)
		ctx.Export("esaWafRulesetsId0", ids.ApplyT(func(ids esa.GetWafRulesetsResult) (*string, error) {
			return &ids.Sets[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var @default = AliCloud.Esa.GetSites.Invoke(new()
    {
        PlanSubscribeType = "enterpriseplan",
    });

    var defaultWafRuleset = new AliCloud.Esa.WafRuleset("default", new()
    {
        SiteId = @default.Apply(@default => @default.Apply(getSitesResult => getSitesResult.Sites[0]?.SiteId)),
        Phase = "http_custom",
        SiteVersion = 0,
        Name = name,
    });

    var ids = AliCloud.Esa.GetWafRulesets.Invoke(new()
    {
        Ids = new[]
        {
            defaultWafRuleset.Id,
        },
        SiteId = defaultWafRuleset.SiteId,
        Phase = defaultWafRuleset.Phase,
        SiteVersion = defaultWafRuleset.SiteVersion,
    });

    return new Dictionary<string, object?>
    {
        ["esaWafRulesetsId0"] = ids.Apply(getWafRulesetsResult => getWafRulesetsResult.Sets[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.esa.EsaFunctions;
import com.pulumi.alicloud.esa.inputs.GetSitesArgs;
import com.pulumi.alicloud.esa.WafRuleset;
import com.pulumi.alicloud.esa.WafRulesetArgs;
import com.pulumi.alicloud.esa.inputs.GetWafRulesetsArgs;
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 config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        final var default = EsaFunctions.getSites(GetSitesArgs.builder()
            .planSubscribeType("enterpriseplan")
            .build());

        var defaultWafRuleset = new WafRuleset("defaultWafRuleset", WafRulesetArgs.builder()
            .siteId(default_.sites()[0].siteId())
            .phase("http_custom")
            .siteVersion(0)
            .name(name)
            .build());

        final var ids = Output.tuple(defaultWafRuleset.id(), defaultWafRuleset.siteId(), defaultWafRuleset.phase(), defaultWafRuleset.siteVersion()).applyValue(values -> {
            var id = values.t1;
            var siteId = values.t2;
            var phase = values.t3;
            var siteVersion = values.t4;
            return EsaFunctions.getWafRulesets(GetWafRulesetsArgs.builder()
                .ids(id)
                .siteId(siteId)
                .phase(phase)
                .siteVersion(siteVersion)
                .build());
        });

        ctx.export("esaWafRulesetsId0", ids.applyValue(_ids -> _ids.sets()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultWafRuleset:
    type: alicloud:esa:WafRuleset
    name: default
    properties:
      siteId: ${default.sites[0].siteId}
      phase: http_custom
      siteVersion: '0'
      name: ${name}
variables:
  default:
    fn::invoke:
      function: alicloud:esa:getSites
      arguments:
        planSubscribeType: enterpriseplan
  ids:
    fn::invoke:
      function: alicloud:esa:getWafRulesets
      arguments:
        ids:
          - ${defaultWafRuleset.id}
        siteId: ${defaultWafRuleset.siteId}
        phase: ${defaultWafRuleset.phase}
        siteVersion: ${defaultWafRuleset.siteVersion}
outputs:
  esaWafRulesetsId0: ${ids.sets[0].id}

function getWafRulesets(args: GetWafRulesetsArgs, opts?: InvokeOptions): Promise<GetWafRulesetsResult>
function getWafRulesetsOutput(args: GetWafRulesetsOutputArgs, opts?: InvokeOptions): Output<GetWafRulesetsResult>

def get_waf_rulesets(ids: Optional[Sequence[str]] = None,
                     name_regex: Optional[str] = None,
                     output_file: Optional[str] = None,
                     phase: Optional[str] = None,
                     query_args: Optional[GetWafRulesetsQueryArgs] = None,
                     site_id: Optional[str] = None,
                     site_version: Optional[int] = None,
                     status: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetWafRulesetsResult
def get_waf_rulesets_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                     name_regex: Optional[pulumi.Input[str]] = None,
                     output_file: Optional[pulumi.Input[str]] = None,
                     phase: Optional[pulumi.Input[str]] = None,
                     query_args: Optional[pulumi.Input[GetWafRulesetsQueryArgsArgs]] = None,
                     site_id: Optional[pulumi.Input[str]] = None,
                     site_version: Optional[pulumi.Input[int]] = None,
                     status: Optional[pulumi.Input[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetWafRulesetsResult]

func GetWafRulesets(ctx *Context, args *GetWafRulesetsArgs, opts ...InvokeOption) (*GetWafRulesetsResult, error)
func GetWafRulesetsOutput(ctx *Context, args *GetWafRulesetsOutputArgs, opts ...InvokeOption) GetWafRulesetsResultOutput

public static class GetWafRulesets 
{
    public static Task<GetWafRulesetsResult> InvokeAsync(GetWafRulesetsArgs args, InvokeOptions? opts = null)
    public static Output<GetWafRulesetsResult> Invoke(GetWafRulesetsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetWafRulesetsResult> getWafRulesets(GetWafRulesetsArgs args, InvokeOptions options)
public static Output<GetWafRulesetsResult> getWafRulesets(GetWafRulesetsArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:esa/getWafRulesets:getWafRulesets
  arguments:
    # arguments dictionary