netlify.getManagedWafRules

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

const example = netlify.getManagedWafRules({
    teamId: "6600abcdef1234567890abcd",
});

import pulumi
import pulumi_netlify as netlify

example = netlify.get_managed_waf_rules(team_id="6600abcdef1234567890abcd")

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netlify/netlify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := netlify.GetManagedWafRules(ctx, &netlify.GetManagedWafRulesArgs{
			TeamId: "6600abcdef1234567890abcd",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Netlify.GetManagedWafRules.Invoke(new()
    {
        TeamId = "6600abcdef1234567890abcd",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.netlify.NetlifyFunctions;
import com.pulumi.netlify.inputs.GetManagedWafRulesArgs;
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 example = NetlifyFunctions.getManagedWafRules(GetManagedWafRulesArgs.builder()
            .teamId("6600abcdef1234567890abcd")
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: netlify:getManagedWafRules
      arguments:
        teamId: 6600abcdef1234567890abcd

function getManagedWafRules(args: GetManagedWafRulesArgs, opts?: InvokeOptions): Promise<GetManagedWafRulesResult>
function getManagedWafRulesOutput(args: GetManagedWafRulesOutputArgs, opts?: InvokeOptions): Output<GetManagedWafRulesResult>

def get_managed_waf_rules(team_id: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetManagedWafRulesResult
def get_managed_waf_rules_output(team_id: Optional[pulumi.Input[str]] = None,
                          opts: Optional[InvokeOptions] = None) -> Output[GetManagedWafRulesResult]

func GetManagedWafRules(ctx *Context, args *GetManagedWafRulesArgs, opts ...InvokeOption) (*GetManagedWafRulesResult, error)
func GetManagedWafRulesOutput(ctx *Context, args *GetManagedWafRulesOutputArgs, opts ...InvokeOption) GetManagedWafRulesResultOutput

public static class GetManagedWafRules 
{
    public static Task<GetManagedWafRulesResult> InvokeAsync(GetManagedWafRulesArgs args, InvokeOptions? opts = null)
    public static Output<GetManagedWafRulesResult> Invoke(GetManagedWafRulesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagedWafRulesResult> getManagedWafRules(GetManagedWafRulesArgs args, InvokeOptions options)
public static Output<GetManagedWafRulesResult> getManagedWafRules(GetManagedWafRulesArgs args, InvokeOptions options)

fn::invoke:
  function: netlify:index/getManagedWafRules:getManagedWafRules
  arguments:
    # arguments dictionary