linode.getAccountLogins

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

const filtered-account-logins = linode.getAccountLogins({
    filters: [
        {
            name: "restricted",
            values: ["true"],
        },
        {
            name: "username",
            values: ["myUsername"],
        },
    ],
});
export const loginIds = filtered_account_logins.then(filtered_account_logins => filtered_account_logins.logins.map(__item => __item.id));

import pulumi
import pulumi_linode as linode

filtered_account_logins = linode.get_account_logins(filters=[
    {
        "name": "restricted",
        "values": ["true"],
    },
    {
        "name": "username",
        "values": ["myUsername"],
    },
])
pulumi.export("loginIds", [__item.id for __item in filtered_account_logins.logins])

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v4/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
filtered_account_logins, err := linode.GetAccountLogins(ctx, &linode.GetAccountLoginsArgs{
Filters: []linode.GetAccountLoginsFilter{
{
Name: "restricted",
Values: []string{
"true",
},
},
{
Name: "username",
Values: []string{
"myUsername",
},
},
},
}, nil);
if err != nil {
return err
}
ctx.Export("loginIds", pulumi.IntArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:11,11-47)))
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var filtered_account_logins = Linode.GetAccountLogins.Invoke(new()
    {
        Filters = new[]
        {
            new Linode.Inputs.GetAccountLoginsFilterInputArgs
            {
                Name = "restricted",
                Values = new[]
                {
                    "true",
                },
            },
            new Linode.Inputs.GetAccountLoginsFilterInputArgs
            {
                Name = "username",
                Values = new[]
                {
                    "myUsername",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["loginIds"] = filtered_account_logins.Apply(filtered_account_logins => filtered_account_logins.Apply(getAccountLoginsResult => getAccountLoginsResult.Logins).Select(__item => __item.Id).ToList()),
    };
});

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.GetAccountLoginsArgs;
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 filtered-account-logins = LinodeFunctions.getAccountLogins(GetAccountLoginsArgs.builder()
            .filters(            
                GetAccountLoginsFilterArgs.builder()
                    .name("restricted")
                    .values("true")
                    .build(),
                GetAccountLoginsFilterArgs.builder()
                    .name("username")
                    .values("myUsername")
                    .build())
            .build());

        ctx.export("loginIds", filtered_account_logins.logins().stream().map(element -> element.id()).collect(toList()));
    }
}

function getAccountLogins(args: GetAccountLoginsArgs, opts?: InvokeOptions): Promise<GetAccountLoginsResult>
function getAccountLoginsOutput(args: GetAccountLoginsOutputArgs, opts?: InvokeOptions): Output<GetAccountLoginsResult>

def get_account_logins(filters: Optional[Sequence[GetAccountLoginsFilter]] = None,
                       logins: Optional[Sequence[GetAccountLoginsLogin]] = None,
                       opts: Optional[InvokeOptions] = None) -> GetAccountLoginsResult
def get_account_logins_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetAccountLoginsFilterArgs]]]] = None,
                       logins: Optional[pulumi.Input[Sequence[pulumi.Input[GetAccountLoginsLoginArgs]]]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[GetAccountLoginsResult]

func GetAccountLogins(ctx *Context, args *GetAccountLoginsArgs, opts ...InvokeOption) (*GetAccountLoginsResult, error)
func GetAccountLoginsOutput(ctx *Context, args *GetAccountLoginsOutputArgs, opts ...InvokeOption) GetAccountLoginsResultOutput

public static class GetAccountLogins 
{
    public static Task<GetAccountLoginsResult> InvokeAsync(GetAccountLoginsArgs args, InvokeOptions? opts = null)
    public static Output<GetAccountLoginsResult> Invoke(GetAccountLoginsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAccountLoginsResult> getAccountLogins(GetAccountLoginsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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