linode.getFirewallTemplates

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

const all = linode.getFirewallTemplates({});
export const firewallTemplateSlugs = all.then(all => all.firewallTemplates);

import pulumi
import pulumi_linode as linode

all = linode.get_firewall_templates()
pulumi.export("firewallTemplateSlugs", all.firewall_templates)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		all, err := linode.GetFirewallTemplates(ctx, &linode.GetFirewallTemplatesArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("firewallTemplateSlugs", all.FirewallTemplates)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = Linode.GetFirewallTemplates.Invoke();

    return new Dictionary<string, object?>
    {
        ["firewallTemplateSlugs"] = all.Apply(getFirewallTemplatesResult => getFirewallTemplatesResult.FirewallTemplates),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetFirewallTemplatesArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 all = LinodeFunctions.getFirewallTemplates(GetFirewallTemplatesArgs.builder()
            .build());

        ctx.export("firewallTemplateSlugs", all.firewallTemplates());
    }
}

variables:
  all:
    fn::invoke:
      function: linode:getFirewallTemplates
      arguments: {}
outputs:
  firewallTemplateSlugs: ${all.firewallTemplates}

pulumi {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_getfirewalltemplates" "all" {
}

output "firewallTemplateSlugs" {
  value = data.linode_getfirewalltemplates.all.firewall_templates
}

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

const filtered = linode.getFirewallTemplates({
    filters: [{
        name: "slug",
        values: ["public"],
        matchBy: "exact",
    }],
});
export const firewallTemplateSlugs = filtered.then(filtered => filtered.firewallTemplates);

import pulumi
import pulumi_linode as linode

filtered = linode.get_firewall_templates(filters=[{
    "name": "slug",
    "values": ["public"],
    "match_by": "exact",
}])
pulumi.export("firewallTemplateSlugs", filtered.firewall_templates)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		filtered, err := linode.GetFirewallTemplates(ctx, &linode.GetFirewallTemplatesArgs{
			Filters: []linode.GetFirewallTemplatesFilter{
				{
					Name: "slug",
					Values: []string{
						"public",
					},
					MatchBy: pulumi.StringRef("exact"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("firewallTemplateSlugs", filtered.FirewallTemplates)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var filtered = Linode.GetFirewallTemplates.Invoke(new()
    {
        Filters = new[]
        {
            new Linode.Inputs.GetFirewallTemplatesFilterInputArgs
            {
                Name = "slug",
                Values = new[]
                {
                    "public",
                },
                MatchBy = "exact",
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["firewallTemplateSlugs"] = filtered.Apply(getFirewallTemplatesResult => getFirewallTemplatesResult.FirewallTemplates),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetFirewallTemplatesArgs;
import com.pulumi.linode.inputs.GetFirewallTemplatesFilterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 filtered = LinodeFunctions.getFirewallTemplates(GetFirewallTemplatesArgs.builder()
            .filters(GetFirewallTemplatesFilterArgs.builder()
                .name("slug")
                .values("public")
                .matchBy("exact")
                .build())
            .build());

        ctx.export("firewallTemplateSlugs", filtered.firewallTemplates());
    }
}

variables:
  filtered:
    fn::invoke:
      function: linode:getFirewallTemplates
      arguments:
        filters:
          - name: slug
            values:
              - public
            matchBy: exact
outputs:
  firewallTemplateSlugs: ${filtered.firewallTemplates}

pulumi {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_getfirewalltemplates" "filtered" {
  filters {
    name     = "slug"
    values   = ["public"]
    match_by = "exact"
  }
}

output "firewallTemplateSlugs" {
  value = data.linode_getfirewalltemplates.filtered.firewall_templates
}

function getFirewallTemplates(args: GetFirewallTemplatesArgs, opts?: InvokeOptions): Promise<GetFirewallTemplatesResult>
function getFirewallTemplatesOutput(args: GetFirewallTemplatesOutputArgs, opts?: InvokeOutputOptions): Output<GetFirewallTemplatesResult>

def get_firewall_templates(filters: Optional[Sequence[GetFirewallTemplatesFilter]] = None,
                           opts: Optional[InvokeOptions] = None) -> GetFirewallTemplatesResult
def get_firewall_templates_output(filters: pulumi.Input[Optional[Sequence[pulumi.Input[GetFirewallTemplatesFilterArgs]]]] = None,
                           opts: Optional[InvokeOutputOptions] = None) -> Output[GetFirewallTemplatesResult]

func GetFirewallTemplates(ctx *Context, args *GetFirewallTemplatesArgs, opts ...InvokeOption) (*GetFirewallTemplatesResult, error)
func GetFirewallTemplatesOutput(ctx *Context, args *GetFirewallTemplatesOutputArgs, opts ...InvokeOption) GetFirewallTemplatesResultOutput

public static class GetFirewallTemplates 
{
    public static Task<GetFirewallTemplatesResult> InvokeAsync(GetFirewallTemplatesArgs args, InvokeOptions? opts = null)
    public static Output<GetFirewallTemplatesResult> Invoke(GetFirewallTemplatesInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetFirewallTemplatesResult> Invoke(GetFirewallTemplatesInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetFirewallTemplatesResult> getFirewallTemplates(GetFirewallTemplatesArgs args, InvokeOptions options)
public static Output<GetFirewallTemplatesResult> getFirewallTemplates(GetFirewallTemplatesArgs args, InvokeOptions options)
public static Output<GetFirewallTemplatesResult> getFirewallTemplates(GetFirewallTemplatesArgs args, InvokeOutputOptions options)

fn::invoke:
  function: linode:index/getFirewallTemplates:getFirewallTemplates
  arguments:
    # arguments dictionary

data "linode_get_firewall_templates" "name" {
    # arguments
}