pagerduty.getUsers

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

const devops = pagerduty.getTeam({
    name: "devops",
});
const me = pagerduty.getUser({
    email: "me@example.com",
});
const exampleWTeam = new pagerduty.User("example_w_team", {
    name: "user-with-team",
    email: "user-with-team@example.com",
});
const example = new pagerduty.TeamMembership("example", {
    teamId: devopsPagerdutyTeam.id,
    userId: exampleWTeam.id,
});
const allUsers = pagerduty.getUsers({});
const fromDevopsTeam = pagerduty.getUsers({
    teamIds: [devopsPagerdutyTeam.id],
});

import pulumi
import pulumi_pagerduty as pagerduty

devops = pagerduty.get_team(name="devops")
me = pagerduty.get_user(email="me@example.com")
example_w_team = pagerduty.User("example_w_team",
    name="user-with-team",
    email="user-with-team@example.com")
example = pagerduty.TeamMembership("example",
    team_id=devops_pagerduty_team["id"],
    user_id=example_w_team.id)
all_users = pagerduty.get_users()
from_devops_team = pagerduty.get_users(team_ids=[devops_pagerduty_team["id"]])

package main

import (
	"github.com/pulumi/pulumi-pagerduty/sdk/v4/go/pagerduty"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := pagerduty.LookupTeam(ctx, &pagerduty.LookupTeamArgs{
Name: "devops",
}, nil);
if err != nil {
return err
}
_, err = pagerduty.LookupUser(ctx, &pagerduty.LookupUserArgs{
Email: "me@example.com",
}, nil);
if err != nil {
return err
}
exampleWTeam, err := pagerduty.NewUser(ctx, "example_w_team", &pagerduty.UserArgs{
Name: pulumi.String("user-with-team"),
Email: pulumi.String("user-with-team@example.com"),
})
if err != nil {
return err
}
_, err = pagerduty.NewTeamMembership(ctx, "example", &pagerduty.TeamMembershipArgs{
TeamId: pulumi.Any(devopsPagerdutyTeam.Id),
UserId: exampleWTeam.ID(),
})
if err != nil {
return err
}
_, err = pagerduty.GetUsers(ctx, &pagerduty.GetUsersArgs{
}, nil);
if err != nil {
return err
}
_, err = pagerduty.GetUsers(ctx, &pagerduty.GetUsersArgs{
TeamIds: interface{}{
devopsPagerdutyTeam.Id,
},
}, nil);
if err != nil {
return err
}
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var devops = Pagerduty.GetTeam.Invoke(new()
    {
        Name = "devops",
    });

    var me = Pagerduty.GetUser.Invoke(new()
    {
        Email = "me@example.com",
    });

    var exampleWTeam = new Pagerduty.User("example_w_team", new()
    {
        Name = "user-with-team",
        Email = "user-with-team@example.com",
    });

    var example = new Pagerduty.TeamMembership("example", new()
    {
        TeamId = devopsPagerdutyTeam.Id,
        UserId = exampleWTeam.Id,
    });

    var allUsers = Pagerduty.GetUsers.Invoke();

    var fromDevopsTeam = Pagerduty.GetUsers.Invoke(new()
    {
        TeamIds = new[]
        {
            devopsPagerdutyTeam.Id,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.PagerdutyFunctions;
import com.pulumi.pagerduty.inputs.GetTeamArgs;
import com.pulumi.pagerduty.inputs.GetUserArgs;
import com.pulumi.pagerduty.User;
import com.pulumi.pagerduty.UserArgs;
import com.pulumi.pagerduty.TeamMembership;
import com.pulumi.pagerduty.TeamMembershipArgs;
import com.pulumi.pagerduty.inputs.GetUsersArgs;
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 devops = PagerdutyFunctions.getTeam(GetTeamArgs.builder()
            .name("devops")
            .build());

        final var me = PagerdutyFunctions.getUser(GetUserArgs.builder()
            .email("me@example.com")
            .build());

        var exampleWTeam = new User("exampleWTeam", UserArgs.builder()
            .name("user-with-team")
            .email("user-with-team@example.com")
            .build());

        var example = new TeamMembership("example", TeamMembershipArgs.builder()
            .teamId(devopsPagerdutyTeam.id())
            .userId(exampleWTeam.id())
            .build());

        final var allUsers = PagerdutyFunctions.getUsers(GetUsersArgs.builder()
            .build());

        final var fromDevopsTeam = PagerdutyFunctions.getUsers(GetUsersArgs.builder()
            .teamIds(devopsPagerdutyTeam.id())
            .build());

    }
}

resources:
  exampleWTeam:
    type: pagerduty:User
    name: example_w_team
    properties:
      name: user-with-team
      email: user-with-team@example.com
  example:
    type: pagerduty:TeamMembership
    properties:
      teamId: ${devopsPagerdutyTeam.id}
      userId: ${exampleWTeam.id}
variables:
  devops:
    fn::invoke:
      function: pagerduty:getTeam
      arguments:
        name: devops
  me:
    fn::invoke:
      function: pagerduty:getUser
      arguments:
        email: me@example.com
  allUsers:
    fn::invoke:
      function: pagerduty:getUsers
      arguments: {}
  fromDevopsTeam:
    fn::invoke:
      function: pagerduty:getUsers
      arguments:
        teamIds:
          - ${devopsPagerdutyTeam.id}

function getUsers(args: GetUsersArgs, opts?: InvokeOptions): Promise<GetUsersResult>
function getUsersOutput(args: GetUsersOutputArgs, opts?: InvokeOptions): Output<GetUsersResult>

def get_users(team_ids: Optional[Sequence[str]] = None,
              opts: Optional[InvokeOptions] = None) -> GetUsersResult
def get_users_output(team_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetUsersResult]

func GetUsers(ctx *Context, args *GetUsersArgs, opts ...InvokeOption) (*GetUsersResult, error)
func GetUsersOutput(ctx *Context, args *GetUsersOutputArgs, opts ...InvokeOption) GetUsersResultOutput

public static class GetUsers 
{
    public static Task<GetUsersResult> InvokeAsync(GetUsersArgs args, InvokeOptions? opts = null)
    public static Output<GetUsersResult> Invoke(GetUsersInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetUsersResult> getUsers(GetUsersArgs args, InvokeOptions options)
public static Output<GetUsersResult> getUsers(GetUsersArgs args, InvokeOptions options)

fn::invoke:
  function: pagerduty:index/getUsers:getUsers
  arguments:
    # arguments dictionary