volcengine.iam.Users

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

const fooUser = new volcengine.iam.User("fooUser", {
    userName: "acc-test-user",
    description: "acc test",
    displayName: "name",
});
const fooUsers = volcengine.iam.UsersOutput({
    userNames: [fooUser.userName],
});

import pulumi
import pulumi_volcengine as volcengine

foo_user = volcengine.iam.User("fooUser",
    user_name="acc-test-user",
    description="acc test",
    display_name="name")
foo_users = volcengine.iam.users_output(user_names=[foo_user.user_name])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooUser, err := iam.NewUser(ctx, "fooUser", &iam.UserArgs{
			UserName:    pulumi.String("acc-test-user"),
			Description: pulumi.String("acc test"),
			DisplayName: pulumi.String("name"),
		})
		if err != nil {
			return err
		}
		_ = iam.UsersOutput(ctx, iam.UsersOutputArgs{
			UserNames: pulumi.StringArray{
				fooUser.UserName,
			},
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var fooUser = new Volcengine.Iam.User("fooUser", new()
    {
        UserName = "acc-test-user",
        Description = "acc test",
        DisplayName = "name",
    });

    var fooUsers = Volcengine.Iam.Users.Invoke(new()
    {
        UserNames = new[]
        {
            fooUser.UserName,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.iam.User;
import com.pulumi.volcengine.iam.UserArgs;
import com.pulumi.volcengine.iam.IamFunctions;
import com.pulumi.volcengine.iam.inputs.UsersArgs;
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 fooUser = new User("fooUser", UserArgs.builder()        
            .userName("acc-test-user")
            .description("acc test")
            .displayName("name")
            .build());

        final var fooUsers = IamFunctions.Users(UsersArgs.builder()
            .userNames(fooUser.userName())
            .build());

    }
}

resources:
  fooUser:
    type: volcengine:iam:User
    properties:
      userName: acc-test-user
      description: acc test
      displayName: name
variables:
  fooUsers:
    fn::invoke:
      Function: volcengine:iam:Users
      Arguments:
        userNames:
          - ${fooUser.userName}

function users(args: UsersArgs, opts?: InvokeOptions): Promise<UsersResult>
function usersOutput(args: UsersOutputArgs, opts?: InvokeOptions): Output<UsersResult>

def users(name_regex: Optional[str] = None,
          output_file: Optional[str] = None,
          user_names: Optional[Sequence[str]] = None,
          opts: Optional[InvokeOptions] = None) -> UsersResult
def users_output(name_regex: Optional[pulumi.Input[str]] = None,
          output_file: Optional[pulumi.Input[str]] = None,
          user_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
          opts: Optional[InvokeOptions] = None) -> Output[UsersResult]

func Users(ctx *Context, args *UsersArgs, opts ...InvokeOption) (*UsersResult, error)
func UsersOutput(ctx *Context, args *UsersOutputArgs, opts ...InvokeOption) UsersResultOutput

public static class Users 
{
    public static Task<UsersResult> InvokeAsync(UsersArgs args, InvokeOptions? opts = null)
    public static Output<UsersResult> Invoke(UsersInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<UsersResult> users(UsersArgs args, InvokeOptions options)
public static Output<UsersResult> users(UsersArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:iam:Users
  arguments:
    # arguments dictionary