outscale.getQuota

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

const loadBalancerListenersQuota01 = outscale.getQuota({
    filters: [
        {
            name: "collections",
            values: ["LBU"],
        },
        {
            name: "quota_names",
            values: ["lb_listeners_limit"],
        },
        {
            name: "quota_types",
            values: ["global"],
        },
        {
            name: "short_descriptions",
            values: ["Load Balancer Listeners Limit"],
        },
    ],
});

import pulumi
import pulumi_outscale as outscale

load_balancer_listeners_quota01 = outscale.get_quota(filters=[
    {
        "name": "collections",
        "values": ["LBU"],
    },
    {
        "name": "quota_names",
        "values": ["lb_listeners_limit"],
    },
    {
        "name": "quota_types",
        "values": ["global"],
    },
    {
        "name": "short_descriptions",
        "values": ["Load Balancer Listeners Limit"],
    },
])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := outscale.GetQuota(ctx, &outscale.GetQuotaArgs{
			Filters: []outscale.GetQuotaFilter{
				{
					Name: "collections",
					Values: []string{
						"LBU",
					},
				},
				{
					Name: "quota_names",
					Values: []string{
						"lb_listeners_limit",
					},
				},
				{
					Name: "quota_types",
					Values: []string{
						"global",
					},
				},
				{
					Name: "short_descriptions",
					Values: []string{
						"Load Balancer Listeners Limit",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var loadBalancerListenersQuota01 = Outscale.GetQuota.Invoke(new()
    {
        Filters = new[]
        {
            new Outscale.Inputs.GetQuotaFilterInputArgs
            {
                Name = "collections",
                Values = new[]
                {
                    "LBU",
                },
            },
            new Outscale.Inputs.GetQuotaFilterInputArgs
            {
                Name = "quota_names",
                Values = new[]
                {
                    "lb_listeners_limit",
                },
            },
            new Outscale.Inputs.GetQuotaFilterInputArgs
            {
                Name = "quota_types",
                Values = new[]
                {
                    "global",
                },
            },
            new Outscale.Inputs.GetQuotaFilterInputArgs
            {
                Name = "short_descriptions",
                Values = new[]
                {
                    "Load Balancer Listeners Limit",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.outscale.OutscaleFunctions;
import com.pulumi.outscale.inputs.GetQuotaArgs;
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 loadBalancerListenersQuota01 = OutscaleFunctions.getQuota(GetQuotaArgs.builder()
            .filters(            
                GetQuotaFilterArgs.builder()
                    .name("collections")
                    .values("LBU")
                    .build(),
                GetQuotaFilterArgs.builder()
                    .name("quota_names")
                    .values("lb_listeners_limit")
                    .build(),
                GetQuotaFilterArgs.builder()
                    .name("quota_types")
                    .values("global")
                    .build(),
                GetQuotaFilterArgs.builder()
                    .name("short_descriptions")
                    .values("Load Balancer Listeners Limit")
                    .build())
            .build());

    }
}

variables:
  loadBalancerListenersQuota01:
    fn::invoke:
      function: outscale:getQuota
      arguments:
        filters:
          - name: collections
            values:
              - LBU
          - name: quota_names
            values:
              - lb_listeners_limit
          - name: quota_types
            values:
              - global
          - name: short_descriptions
            values:
              - Load Balancer Listeners Limit

function getQuota(args: GetQuotaArgs, opts?: InvokeOptions): Promise<GetQuotaResult>
function getQuotaOutput(args: GetQuotaOutputArgs, opts?: InvokeOptions): Output<GetQuotaResult>

def get_quota(filters: Optional[Sequence[GetQuotaFilter]] = None,
              opts: Optional[InvokeOptions] = None) -> GetQuotaResult
def get_quota_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuotaFilterArgs]]]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetQuotaResult]

func GetQuota(ctx *Context, args *GetQuotaArgs, opts ...InvokeOption) (*GetQuotaResult, error)
func GetQuotaOutput(ctx *Context, args *GetQuotaOutputArgs, opts ...InvokeOption) GetQuotaResultOutput

public static class GetQuota 
{
    public static Task<GetQuotaResult> InvokeAsync(GetQuotaArgs args, InvokeOptions? opts = null)
    public static Output<GetQuotaResult> Invoke(GetQuotaInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetQuotaResult> getQuota(GetQuotaArgs args, InvokeOptions options)
public static Output<GetQuotaResult> getQuota(GetQuotaArgs args, InvokeOptions options)

fn::invoke:
  function: outscale:index/getQuota:getQuota
  arguments:
    # arguments dictionary