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

const myRule = new auth0.Rule("my_rule", {
    name: "empty-rule",
    script: `    function (user, context, callback) {
      callback(null, user, context);
    }
`,
    enabled: true,
});
const myRuleConfig = new auth0.RuleConfig("my_rule_config", {
    key: "foo",
    value: "bar",
});

import pulumi
import pulumi_auth0 as auth0

my_rule = auth0.Rule("my_rule",
    name="empty-rule",
    script="""    function (user, context, callback) {
      callback(null, user, context);
    }
""",
    enabled=True)
my_rule_config = auth0.RuleConfig("my_rule_config",
    key="foo",
    value="bar")

package main

import (
	"github.com/pulumi/pulumi-auth0/sdk/v3/go/auth0"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := auth0.NewRule(ctx, "my_rule", &auth0.RuleArgs{
			Name:    pulumi.String("empty-rule"),
			Script:  pulumi.String("    function (user, context, callback) {\n      callback(null, user, context);\n    }\n"),
			Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = auth0.NewRuleConfig(ctx, "my_rule_config", &auth0.RuleConfigArgs{
			Key:   pulumi.String("foo"),
			Value: pulumi.String("bar"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myRule = new Auth0.Rule("my_rule", new()
    {
        Name = "empty-rule",
        Script = @"    function (user, context, callback) {
      callback(null, user, context);
    }
",
        Enabled = true,
    });

    var myRuleConfig = new Auth0.RuleConfig("my_rule_config", new()
    {
        Key = "foo",
        Value = "bar",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Rule;
import com.pulumi.auth0.RuleArgs;
import com.pulumi.auth0.RuleConfig;
import com.pulumi.auth0.RuleConfigArgs;
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) {
        var myRule = new Rule("myRule", RuleArgs.builder()
            .name("empty-rule")
            .script("""
    function (user, context, callback) {
      callback(null, user, context);
    }
            """)
            .enabled(true)
            .build());

        var myRuleConfig = new RuleConfig("myRuleConfig", RuleConfigArgs.builder()
            .key("foo")
            .value("bar")
            .build());

    }
}

resources:
  myRule:
    type: auth0:Rule
    name: my_rule
    properties:
      name: empty-rule
      script: |2
            function (user, context, callback) {
              callback(null, user, context);
            }
      enabled: true
  myRuleConfig:
    type: auth0:RuleConfig
    name: my_rule_config
    properties:
      key: foo
      value: bar

var ruleConfigResource = new Auth0.RuleConfig("ruleConfigResource", new()
{
    Key = "string",
    Value = "string",
});

example, err := auth0.NewRuleConfig(ctx, "ruleConfigResource", &auth0.RuleConfigArgs{
	Key:   pulumi.String("string"),
	Value: pulumi.String("string"),
})

var ruleConfigResource = new RuleConfig("ruleConfigResource", RuleConfigArgs.builder()
    .key("string")
    .value("string")
    .build());

rule_config_resource = auth0.RuleConfig("ruleConfigResource",
    key="string",
    value="string")

const ruleConfigResource = new auth0.RuleConfig("ruleConfigResource", {
    key: "string",
    value: "string",
});

type: auth0:RuleConfig
properties:
    key: string
    value: string