Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. Newrelic Provider
  4. API Docs
  5. Team
Viewing docs for New Relic v5.80.4
published on Tuesday, Oct 27, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-newrelic

newrelic.Team

newrelic logo newrelic logo
Viewing docs for New Relic v5.80.4
published on Tuesday, Oct 27, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-newrelic

    Use this resource to create, update, and delete New Relic Teams.

    Teams group people and associate owned entities (services, dashboards, scorecards, and more) under a single operational identity. They appear across alerts, service maps, and the Teams UI.

    NOTE: Entity ownership is managed non-authoritatively. Terraform tracks only the entities you declare in the entities block and ensures they remain in the collection. Entities added to the collection outside Terraform — through tag-based discovery or manual additions via the UI or API — are not surfaced as drift and are not removed on apply. To disable entity management entirely and suppress all entity-related plan output, set entityManagementMode = "unmanaged".

    Example Usage

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

const platform = new newrelic.Team("platform", {
    name: "Platform Engineering",
    description: "Owns core platform services and shared infrastructure",
    aliases: [
        "platform",
        "infra",
    ],
    tags: [
        {
            key: "department",
            values: ["engineering"],
        },
        {
            key: "tier",
            values: ["1"],
        },
    ],
    members: [
        1234567,
        2345678,
    ],
    managers: [1234567],
    resources: [
        {
            type: "GITHUB",
            content: "https://github.com/example-org/platform",
            title: "GitHub Repository",
        },
        {
            type: "SLACK",
            content: "https://example.slack.com/channels/platform-eng",
            title: "Team Slack Channel",
        },
    ],
    entityManagementMode: "managed",
    entities: [
        "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        engineeringStandards.id,
    ],
});

    import pulumi
import pulumi_newrelic as newrelic

platform = newrelic.Team("platform",
    name="Platform Engineering",
    description="Owns core platform services and shared infrastructure",
    aliases=[
        "platform",
        "infra",
    ],
    tags=[
        {
            "key": "department",
            "values": ["engineering"],
        },
        {
            "key": "tier",
            "values": ["1"],
        },
    ],
    members=[
        1234567,
        2345678,
    ],
    managers=[1234567],
    resources=[
        {
            "type": "GITHUB",
            "content": "https://github.com/example-org/platform",
            "title": "GitHub Repository",
        },
        {
            "type": "SLACK",
            "content": "https://example.slack.com/channels/platform-eng",
            "title": "Team Slack Channel",
        },
    ],
    entity_management_mode="managed",
    entities=[
        "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        engineering_standards["id"],
    ])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewTeam(ctx, "platform", &newrelic.TeamArgs{
			Name:        pulumi.String("Platform Engineering"),
			Description: pulumi.String("Owns core platform services and shared infrastructure"),
			Aliases: pulumi.StringArray{
				pulumi.String("platform"),
				pulumi.String("infra"),
			},
			Tags: newrelic.TeamTagArray{
				&newrelic.TeamTagArgs{
					Key: pulumi.String("department"),
					Values: pulumi.StringArray{
						pulumi.String("engineering"),
					},
				},
				&newrelic.TeamTagArgs{
					Key: pulumi.String("tier"),
					Values: pulumi.StringArray{
						pulumi.String("1"),
					},
				},
			},
			Members: pulumi.IntArray{
				pulumi.Int(1234567),
				pulumi.Int(2345678),
			},
			Managers: pulumi.IntArray{
				pulumi.Int(1234567),
			},
			Resources: newrelic.TeamResourceArray{
				&newrelic.TeamResourceArgs{
					Type:    pulumi.String("GITHUB"),
					Content: pulumi.String("https://github.com/example-org/platform"),
					Title:   pulumi.String("GitHub Repository"),
				},
				&newrelic.TeamResourceArgs{
					Type:    pulumi.String("SLACK"),
					Content: pulumi.String("https://example.slack.com/channels/platform-eng"),
					Title:   pulumi.String("Team Slack Channel"),
				},
			},
			EntityManagementMode: pulumi.String("managed"),
			Entities: pulumi.StringArray{
				pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
				engineeringStandards.Id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var platform = new NewRelic.Team("platform", new()
    {
        Name = "Platform Engineering",
        Description = "Owns core platform services and shared infrastructure",
        Aliases = new[]
        {
            "platform",
            "infra",
        },
        Tags = new[]
        {
            new NewRelic.Inputs.TeamTagArgs
            {
                Key = "department",
                Values = new[]
                {
                    "engineering",
                },
            },
            new NewRelic.Inputs.TeamTagArgs
            {
                Key = "tier",
                Values = new[]
                {
                    "1",
                },
            },
        },
        Members = new[]
        {
            1234567,
            2345678,
        },
        Managers = new[]
        {
            1234567,
        },
        Resources = new[]
        {
            new NewRelic.Inputs.TeamResourceArgs
            {
                Type = "GITHUB",
                Content = "https://github.com/example-org/platform",
                Title = "GitHub Repository",
            },
            new NewRelic.Inputs.TeamResourceArgs
            {
                Type = "SLACK",
                Content = "https://example.slack.com/channels/platform-eng",
                Title = "Team Slack Channel",
            },
        },
        EntityManagementMode = "managed",
        Entities = new[]
        {
            "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
            engineeringStandards.Id,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
import com.pulumi.newrelic.inputs.TeamTagArgs;
import com.pulumi.newrelic.inputs.TeamResourceArgs;
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) {
        var platform = new Team("platform", TeamArgs.builder()
            .name("Platform Engineering")
            .description("Owns core platform services and shared infrastructure")
            .aliases(            
                "platform",
                "infra")
            .tags(            
                TeamTagArgs.builder()
                    .key("department")
                    .values("engineering")
                    .build(),
                TeamTagArgs.builder()
                    .key("tier")
                    .values("1")
                    .build())
            .members(            
                1234567,
                2345678)
            .managers(1234567)
            .resources(            
                TeamResourceArgs.builder()
                    .type("GITHUB")
                    .content("https://github.com/example-org/platform")
                    .title("GitHub Repository")
                    .build(),
                TeamResourceArgs.builder()
                    .type("SLACK")
                    .content("https://example.slack.com/channels/platform-eng")
                    .title("Team Slack Channel")
                    .build())
            .entityManagementMode("managed")
            .entities(            
                "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
                engineeringStandards.get("id"))
            .build());

    }
}

    resources:
  platform:
    type: newrelic:Team
    properties:
      name: Platform Engineering
      description: Owns core platform services and shared infrastructure
      aliases:
        - platform
        - infra
      tags:
        - key: department
          values:
            - engineering
        - key: tier
          values:
            - '1'
      members:
        - 1.234567e+06
        - 2.345678e+06
      managers:
        - 1.234567e+06
      resources:
        - type: GITHUB
          content: https://github.com/example-org/platform
          title: GitHub Repository
        - type: SLACK
          content: https://example.slack.com/channels/platform-eng
          title: Team Slack Channel
      entityManagementMode: managed
      entities:
        - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
        - ${engineeringStandards.id}

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "platform" {
  lifecycle {
    create_before_destroy = true
  }
  name        = "Platform Engineering"
  description = "Owns core platform services and shared infrastructure"
  aliases     = ["platform", "infra"]
  tags {
    key    = "department"
    values = ["engineering"]
  }
  tags {
    key    = "tier"
    values = ["1"]
  }
  members  = [1234567, 2345678]
  managers = [1234567]
  resources {
    type    = "GITHUB"
    content = "https://github.com/example-org/platform"
    title   = "GitHub Repository"
  }
  resources {
    type    = "SLACK"
    content = "https://example.slack.com/channels/platform-eng"
    title   = "Team Slack Channel"
  }
  entity_management_mode = "managed"
  entities               = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1", engineeringStandards.id]
}

    See additional examples below.

    Entity Ownership Modes

    managed (default)

    Terraform manages a declared set of entities within the team’s ownership collection using a non-authoritative approach. You declare which entity GUIDs Terraform should track; Terraform ensures those entities are present in the collection and surfaces a plan change only when one of them is missing.

    Entities added to the collection outside Terraform — through tag-based discovery or manual additions via the UI or API — are not surfaced as drift and are not removed on apply. This means the ownership collection can contain more entities than are declared in entities, and Terraform will not interfere with those additional entries.

    When to use: You want Terraform to maintain a specific set of owned entities (for example, a scorecard or a key service) while allowing the platform to populate the rest of the collection through its own discovery mechanisms.

    Behaviour:

    • Entities declared in the entities block are added to the collection on apply.
    • Entities removed from the entities block are removed from the collection on apply.
    • If a declared entity is removed from the collection outside Terraform, the next plan surfaces a change to re-add it.
    • Entities present in the collection but not declared in entities are silently ignored — no drift, no warnings.
    import * as pulumi from "@pulumi/pulumi";
import * as newrelic from "@pulumi/newrelic";

const example = new newrelic.Team("example", {
    name: "Payments Service",
    entityManagementMode: "managed",
    entities: [
        "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        platformStandards.id,
    ],
});

    import pulumi
import pulumi_newrelic as newrelic

example = newrelic.Team("example",
    name="Payments Service",
    entity_management_mode="managed",
    entities=[
        "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
        platform_standards["id"],
    ])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewTeam(ctx, "example", &newrelic.TeamArgs{
			Name:                 pulumi.String("Payments Service"),
			EntityManagementMode: pulumi.String("managed"),
			Entities: pulumi.StringArray{
				pulumi.String("MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1"),
				platformStandards.Id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new NewRelic.Team("example", new()
    {
        Name = "Payments Service",
        EntityManagementMode = "managed",
        Entities = new[]
        {
            "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
            platformStandards.Id,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
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) {
        var example = new Team("example", TeamArgs.builder()
            .name("Payments Service")
            .entityManagementMode("managed")
            .entities(            
                "MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1",
                platformStandards.get("id"))
            .build());

    }
}

    resources:
  example:
    type: newrelic:Team
    properties:
      name: Payments Service
      entityManagementMode: managed
      entities:
        - MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1
        - ${platformStandards.id}

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "example" {
  lifecycle {
    create_before_destroy = true
  }
  name                   = "Payments Service"
  entity_management_mode = "managed"
  entities               = ["MjUyMDUyOHxBUE18QVBQTElDQVRJT058MjE1MDM3Nzk1", platformStandards.id]
}

    unmanaged

    Terraform does not manage the team’s entity ownership collection at all. The collection is left entirely to the New Relic platform — tag-based discovery or manual management through the Teams UI or API.

    When to use: Entity ownership for this team is governed entirely outside Terraform (for example, by tagging conventions). You want to manage the team resource itself — name, aliases, members — without Terraform interfering with what the platform assigns to the collection.

    Behaviour:

    • The entities attribute cannot be set in config. The provider returns a plan-time error if it is.
    • The entities attribute is always empty in state.
    • No drift is surfaced for the ownership collection, regardless of what is added or removed externally.
    import * as pulumi from "@pulumi/pulumi";
import * as newrelic from "@pulumi/newrelic";

const example = new newrelic.Team("example", {
    name: "Payments Service",
    entityManagementMode: "unmanaged",
});

    import pulumi
import pulumi_newrelic as newrelic

example = newrelic.Team("example",
    name="Payments Service",
    entity_management_mode="unmanaged")

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewTeam(ctx, "example", &newrelic.TeamArgs{
			Name:                 pulumi.String("Payments Service"),
			EntityManagementMode: pulumi.String("unmanaged"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new NewRelic.Team("example", new()
    {
        Name = "Payments Service",
        EntityManagementMode = "unmanaged",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
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) {
        var example = new Team("example", TeamArgs.builder()
            .name("Payments Service")
            .entityManagementMode("unmanaged")
            .build());

    }
}

    resources:
  example:
    type: newrelic:Team
    properties:
      name: Payments Service
      entityManagementMode: unmanaged

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "example" {
  lifecycle {
    create_before_destroy = true
  }
  name                   = "Payments Service"
  entity_management_mode = "unmanaged"
}

    Switching Between Modes

    Switching from managed to unmanaged clears entities from state on the next apply. The ownership collection itself is not modified — entities remain in the collection and are governed entirely outside Terraform from that point.

    Switching from unmanaged back to managed allows entity tracking to resume. Entities already in the collection are unaffected; you can begin declaring any of them in the entities block to bring them under Terraform management.

    Hierarchy Levels

    When teams are linked via parentId, the platform automatically assigns each team a hierarchyLevelId based on its depth in the hierarchy. This value becomes available on the next plan after parentId is first set.

    You can reference hierarchyLevelId directly in newrelic.TeamsOrganizationSettings to rename the level, without requiring a separate NerdGraph query or data source lookup:

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

const division = new newrelic.Team("division", {name: "Engineering Division"});
const squad = new newrelic.Team("squad", {
    name: "Backend Squad",
    parentId: division.id,
});
const org = new newrelic.TeamsOrganizationSettings("org", {hierarchyLevels: [
    {
        id: division.hierarchyLevelId,
        name: "Division",
    },
    {
        id: squad.hierarchyLevelId,
        name: "Squad",
    },
]});

    import pulumi
import pulumi_newrelic as newrelic

division = newrelic.Team("division", name="Engineering Division")
squad = newrelic.Team("squad",
    name="Backend Squad",
    parent_id=division.id)
org = newrelic.TeamsOrganizationSettings("org", hierarchy_levels=[
    {
        "id": division.hierarchy_level_id,
        "name": "Division",
    },
    {
        "id": squad.hierarchy_level_id,
        "name": "Squad",
    },
])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		division, err := newrelic.NewTeam(ctx, "division", &newrelic.TeamArgs{
			Name: pulumi.String("Engineering Division"),
		})
		if err != nil {
			return err
		}
		squad, err := newrelic.NewTeam(ctx, "squad", &newrelic.TeamArgs{
			Name:     pulumi.String("Backend Squad"),
			ParentId: division.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewTeamsOrganizationSettings(ctx, "org", &newrelic.TeamsOrganizationSettingsArgs{
			HierarchyLevels: newrelic.TeamsOrganizationSettingsHierarchyLevelArray{
				&newrelic.TeamsOrganizationSettingsHierarchyLevelArgs{
					Id:   division.HierarchyLevelId,
					Name: pulumi.String("Division"),
				},
				&newrelic.TeamsOrganizationSettingsHierarchyLevelArgs{
					Id:   squad.HierarchyLevelId,
					Name: pulumi.String("Squad"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var division = new NewRelic.Team("division", new()
    {
        Name = "Engineering Division",
    });

    var squad = new NewRelic.Team("squad", new()
    {
        Name = "Backend Squad",
        ParentId = division.Id,
    });

    var org = new NewRelic.TeamsOrganizationSettings("org", new()
    {
        HierarchyLevels = new[]
        {
            new NewRelic.Inputs.TeamsOrganizationSettingsHierarchyLevelArgs
            {
                Id = division.HierarchyLevelId,
                Name = "Division",
            },
            new NewRelic.Inputs.TeamsOrganizationSettingsHierarchyLevelArgs
            {
                Id = squad.HierarchyLevelId,
                Name = "Squad",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
import com.pulumi.newrelic.TeamsOrganizationSettings;
import com.pulumi.newrelic.TeamsOrganizationSettingsArgs;
import com.pulumi.newrelic.inputs.TeamsOrganizationSettingsHierarchyLevelArgs;
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) {
        var division = new Team("division", TeamArgs.builder()
            .name("Engineering Division")
            .build());

        var squad = new Team("squad", TeamArgs.builder()
            .name("Backend Squad")
            .parentId(division.id())
            .build());

        var org = new TeamsOrganizationSettings("org", TeamsOrganizationSettingsArgs.builder()
            .hierarchyLevels(            
                TeamsOrganizationSettingsHierarchyLevelArgs.builder()
                    .id(division.hierarchyLevelId())
                    .name("Division")
                    .build(),
                TeamsOrganizationSettingsHierarchyLevelArgs.builder()
                    .id(squad.hierarchyLevelId())
                    .name("Squad")
                    .build())
            .build());

    }
}

    resources:
  division:
    type: newrelic:Team
    properties:
      name: Engineering Division
  squad:
    type: newrelic:Team
    properties:
      name: Backend Squad
      parentId: ${division.id}
  org:
    type: newrelic:TeamsOrganizationSettings
    properties:
      hierarchyLevels:
        - id: ${division.hierarchyLevelId}
          name: Division
        - id: ${squad.hierarchyLevelId}
          name: Squad

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "division" {
  lifecycle {
    create_before_destroy = true
  }
  name = "Engineering Division"
}
resource "newrelic_team" "squad" {
  lifecycle {
    create_before_destroy = true
  }
  name      = "Backend Squad"
  parent_id = newrelic_team.division.id
}
resource "newrelic_teams_organization_settings" "org" {
  lifecycle {
    create_before_destroy = true
  }
  hierarchy_levels {
    id   = newrelic_team.division.hierarchy_level_id
    name = "Division"
  }
  hierarchy_levels {
    id   = newrelic_team.squad.hierarchy_level_id
    name = "Squad"
  }
}

    Alternatively, use the newrelic.getTeamsHierarchyLevels data source to reference levels by index:

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

const all = newrelic.getTeamsHierarchyLevels({});
const org = new newrelic.TeamsOrganizationSettings("org", {hierarchyLevels: [{
    id: all.then(all => all.levels?.[0]?.id),
    name: "Division",
}]});

    import pulumi
import pulumi_newrelic as newrelic

all = newrelic.get_teams_hierarchy_levels()
org = newrelic.TeamsOrganizationSettings("org", hierarchy_levels=[{
    "id": all.levels[0].id,
    "name": "Division",
}])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		all, err := newrelic.GetTeamsHierarchyLevels(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		_, err = newrelic.NewTeamsOrganizationSettings(ctx, "org", &newrelic.TeamsOrganizationSettingsArgs{
			HierarchyLevels: newrelic.TeamsOrganizationSettingsHierarchyLevelArray{
				&newrelic.TeamsOrganizationSettingsHierarchyLevelArgs{
					Id:   pulumi.String(all.Levels[0].Id),
					Name: pulumi.String("Division"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = NewRelic.GetTeamsHierarchyLevels.Invoke();

    var org = new NewRelic.TeamsOrganizationSettings("org", new()
    {
        HierarchyLevels = new[]
        {
            new NewRelic.Inputs.TeamsOrganizationSettingsHierarchyLevelArgs
            {
                Id = all.Apply(getTeamsHierarchyLevelsResult => getTeamsHierarchyLevelsResult.Levels[0]?.Id),
                Name = "Division",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NewrelicFunctions;
import com.pulumi.newrelic.TeamsOrganizationSettings;
import com.pulumi.newrelic.TeamsOrganizationSettingsArgs;
import com.pulumi.newrelic.inputs.TeamsOrganizationSettingsHierarchyLevelArgs;
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 = NewrelicFunctions.getTeamsHierarchyLevels(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var org = new TeamsOrganizationSettings("org", TeamsOrganizationSettingsArgs.builder()
            .hierarchyLevels(TeamsOrganizationSettingsHierarchyLevelArgs.builder()
                .id(all.levels()[0].id())
                .name("Division")
                .build())
            .build());

    }
}

    resources:
  org:
    type: newrelic:TeamsOrganizationSettings
    properties:
      hierarchyLevels:
        - id: ${all.levels[0].id}
          name: Division
variables:
  all:
    fn::invoke:
      function: newrelic:getTeamsHierarchyLevels
      arguments: {}

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

data "newrelic_teams_hierarchy_levels" "all" {
}

resource "newrelic_teams_organization_settings" "org" {
  lifecycle {
    create_before_destroy = true
  }
  hierarchy_levels {
    id   = data.newrelic_teams_hierarchy_levels.all.levels[0].id
    name = "Division"
  }
}

    Additional Examples

    Minimal team

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

const backend = new newrelic.Team("backend", {name: "Backend Engineering"});

    import pulumi
import pulumi_newrelic as newrelic

backend = newrelic.Team("backend", name="Backend Engineering")

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewTeam(ctx, "backend", &newrelic.TeamArgs{
			Name: pulumi.String("Backend Engineering"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var backend = new NewRelic.Team("backend", new()
    {
        Name = "Backend Engineering",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
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) {
        var backend = new Team("backend", TeamArgs.builder()
            .name("Backend Engineering")
            .build());

    }
}

    resources:
  backend:
    type: newrelic:Team
    properties:
      name: Backend Engineering

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "backend" {
  lifecycle {
    create_before_destroy = true
  }
  name = "Backend Engineering"
}

    Team with a parent (hierarchy)

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

const engineering = new newrelic.Team("engineering", {
    name: "Engineering",
    description: "Top-level engineering division",
});
const backend = new newrelic.Team("backend", {
    name: "Backend",
    parentId: engineering.id,
});

    import pulumi
import pulumi_newrelic as newrelic

engineering = newrelic.Team("engineering",
    name="Engineering",
    description="Top-level engineering division")
backend = newrelic.Team("backend",
    name="Backend",
    parent_id=engineering.id)

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		engineering, err := newrelic.NewTeam(ctx, "engineering", &newrelic.TeamArgs{
			Name:        pulumi.String("Engineering"),
			Description: pulumi.String("Top-level engineering division"),
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewTeam(ctx, "backend", &newrelic.TeamArgs{
			Name:     pulumi.String("Backend"),
			ParentId: engineering.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var engineering = new NewRelic.Team("engineering", new()
    {
        Name = "Engineering",
        Description = "Top-level engineering division",
    });

    var backend = new NewRelic.Team("backend", new()
    {
        Name = "Backend",
        ParentId = engineering.Id,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
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) {
        var engineering = new Team("engineering", TeamArgs.builder()
            .name("Engineering")
            .description("Top-level engineering division")
            .build());

        var backend = new Team("backend", TeamArgs.builder()
            .name("Backend")
            .parentId(engineering.id())
            .build());

    }
}

    resources:
  engineering:
    type: newrelic:Team
    properties:
      name: Engineering
      description: Top-level engineering division
  backend:
    type: newrelic:Team
    properties:
      name: Backend
      parentId: ${engineering.id}

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "engineering" {
  lifecycle {
    create_before_destroy = true
  }
  name        = "Engineering"
  description = "Top-level engineering division"
}
resource "newrelic_team" "backend" {
  lifecycle {
    create_before_destroy = true
  }
  name      = "Backend"
  parent_id = newrelic_team.engineering.id
}

    Team owning a scorecard

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

const standards = new newrelic.Scorecard("standards", {
    name: "Engineering Standards",
    ruleIds: [alertCoverage.id],
});
const platform = new newrelic.Team("platform", {
    name: "Platform",
    entityManagementMode: "managed",
    entities: [standards.id],
});

    import pulumi
import pulumi_newrelic as newrelic

standards = newrelic.Scorecard("standards",
    name="Engineering Standards",
    rule_ids=[alert_coverage["id"]])
platform = newrelic.Team("platform",
    name="Platform",
    entity_management_mode="managed",
    entities=[standards.id])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		standards, err := newrelic.NewScorecard(ctx, "standards", &newrelic.ScorecardArgs{
			Name: pulumi.String("Engineering Standards"),
			RuleIds: pulumi.StringArray{
				alertCoverage.Id,
			},
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewTeam(ctx, "platform", &newrelic.TeamArgs{
			Name:                 pulumi.String("Platform"),
			EntityManagementMode: pulumi.String("managed"),
			Entities: pulumi.StringArray{
				standards.ID().ToIDOutput().ToStringOutput(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var standards = new NewRelic.Scorecard("standards", new()
    {
        Name = "Engineering Standards",
        RuleIds = new[]
        {
            alertCoverage.Id,
        },
    });

    var platform = new NewRelic.Team("platform", new()
    {
        Name = "Platform",
        EntityManagementMode = "managed",
        Entities = new[]
        {
            standards.Id,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Scorecard;
import com.pulumi.newrelic.ScorecardArgs;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
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) {
        var standards = new Scorecard("standards", ScorecardArgs.builder()
            .name("Engineering Standards")
            .ruleIds(alertCoverage.get("id"))
            .build());

        var platform = new Team("platform", TeamArgs.builder()
            .name("Platform")
            .entityManagementMode("managed")
            .entities(standards.id())
            .build());

    }
}

    resources:
  standards:
    type: newrelic:Scorecard
    properties:
      name: Engineering Standards
      ruleIds:
        - ${alertCoverage.id}
  platform:
    type: newrelic:Team
    properties:
      name: Platform
      entityManagementMode: managed
      entities:
        - ${standards.id}

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_scorecard" "standards" {
  lifecycle {
    create_before_destroy = true
  }
  name     = "Engineering Standards"
  rule_ids = [alertCoverage.id]
}
resource "newrelic_team" "platform" {
  lifecycle {
    create_before_destroy = true
  }
  name                   = "Platform"
  entity_management_mode = "managed"
  entities               = [newrelic_scorecard.standards.id]
}

    Team with externally managed entity ownership

    Use unmanaged mode when entity ownership is managed outside Terraform — through tag-based discovery, relationship rules, or the Teams UI — and you do not want Terraform to produce any drift for the ownership collection.

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

const payments = new newrelic.Team("payments", {
    name: "Payments",
    aliases: ["payments-service"],
    entityManagementMode: "unmanaged",
});

    import pulumi
import pulumi_newrelic as newrelic

payments = newrelic.Team("payments",
    name="Payments",
    aliases=["payments-service"],
    entity_management_mode="unmanaged")

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewTeam(ctx, "payments", &newrelic.TeamArgs{
			Name: pulumi.String("Payments"),
			Aliases: pulumi.StringArray{
				pulumi.String("payments-service"),
			},
			EntityManagementMode: pulumi.String("unmanaged"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var payments = new NewRelic.Team("payments", new()
    {
        Name = "Payments",
        Aliases = new[]
        {
            "payments-service",
        },
        EntityManagementMode = "unmanaged",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
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) {
        var payments = new Team("payments", TeamArgs.builder()
            .name("Payments")
            .aliases("payments-service")
            .entityManagementMode("unmanaged")
            .build());

    }
}

    resources:
  payments:
    type: newrelic:Team
    properties:
      name: Payments
      aliases:
        - payments-service
      entityManagementMode: unmanaged

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "payments" {
  lifecycle {
    create_before_destroy = true
  }
  name                   = "Payments"
  aliases                = ["payments-service"]
  entity_management_mode = "unmanaged"
}

    Team with members, managers, and supplemental resources

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

const platform = new newrelic.Team("platform", {
    name: "Platform Engineering",
    description: "Owns shared infrastructure and developer tooling",
    members: [
        1234567,
        2345678,
        3456789,
    ],
    managers: [1234567],
    resources: [
        {
            type: "GITHUB",
            content: "https://github.com/example-org/platform",
            title: "Source Repository",
        },
        {
            type: "SLACK",
            content: "https://example.slack.com/channels/platform-eng",
            title: "Team Channel",
        },
        {
            type: "PAGERDUTY",
            content: "https://example.pagerduty.com/teams/platform",
            title: "On-Call Schedule",
        },
    ],
});

    import pulumi
import pulumi_newrelic as newrelic

platform = newrelic.Team("platform",
    name="Platform Engineering",
    description="Owns shared infrastructure and developer tooling",
    members=[
        1234567,
        2345678,
        3456789,
    ],
    managers=[1234567],
    resources=[
        {
            "type": "GITHUB",
            "content": "https://github.com/example-org/platform",
            "title": "Source Repository",
        },
        {
            "type": "SLACK",
            "content": "https://example.slack.com/channels/platform-eng",
            "title": "Team Channel",
        },
        {
            "type": "PAGERDUTY",
            "content": "https://example.pagerduty.com/teams/platform",
            "title": "On-Call Schedule",
        },
    ])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewTeam(ctx, "platform", &newrelic.TeamArgs{
			Name:        pulumi.String("Platform Engineering"),
			Description: pulumi.String("Owns shared infrastructure and developer tooling"),
			Members: pulumi.IntArray{
				pulumi.Int(1234567),
				pulumi.Int(2345678),
				pulumi.Int(3456789),
			},
			Managers: pulumi.IntArray{
				pulumi.Int(1234567),
			},
			Resources: newrelic.TeamResourceArray{
				&newrelic.TeamResourceArgs{
					Type:    pulumi.String("GITHUB"),
					Content: pulumi.String("https://github.com/example-org/platform"),
					Title:   pulumi.String("Source Repository"),
				},
				&newrelic.TeamResourceArgs{
					Type:    pulumi.String("SLACK"),
					Content: pulumi.String("https://example.slack.com/channels/platform-eng"),
					Title:   pulumi.String("Team Channel"),
				},
				&newrelic.TeamResourceArgs{
					Type:    pulumi.String("PAGERDUTY"),
					Content: pulumi.String("https://example.pagerduty.com/teams/platform"),
					Title:   pulumi.String("On-Call Schedule"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var platform = new NewRelic.Team("platform", new()
    {
        Name = "Platform Engineering",
        Description = "Owns shared infrastructure and developer tooling",
        Members = new[]
        {
            1234567,
            2345678,
            3456789,
        },
        Managers = new[]
        {
            1234567,
        },
        Resources = new[]
        {
            new NewRelic.Inputs.TeamResourceArgs
            {
                Type = "GITHUB",
                Content = "https://github.com/example-org/platform",
                Title = "Source Repository",
            },
            new NewRelic.Inputs.TeamResourceArgs
            {
                Type = "SLACK",
                Content = "https://example.slack.com/channels/platform-eng",
                Title = "Team Channel",
            },
            new NewRelic.Inputs.TeamResourceArgs
            {
                Type = "PAGERDUTY",
                Content = "https://example.pagerduty.com/teams/platform",
                Title = "On-Call Schedule",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Team;
import com.pulumi.newrelic.TeamArgs;
import com.pulumi.newrelic.inputs.TeamResourceArgs;
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) {
        var platform = new Team("platform", TeamArgs.builder()
            .name("Platform Engineering")
            .description("Owns shared infrastructure and developer tooling")
            .members(            
                1234567,
                2345678,
                3456789)
            .managers(1234567)
            .resources(            
                TeamResourceArgs.builder()
                    .type("GITHUB")
                    .content("https://github.com/example-org/platform")
                    .title("Source Repository")
                    .build(),
                TeamResourceArgs.builder()
                    .type("SLACK")
                    .content("https://example.slack.com/channels/platform-eng")
                    .title("Team Channel")
                    .build(),
                TeamResourceArgs.builder()
                    .type("PAGERDUTY")
                    .content("https://example.pagerduty.com/teams/platform")
                    .title("On-Call Schedule")
                    .build())
            .build());

    }
}

    resources:
  platform:
    type: newrelic:Team
    properties:
      name: Platform Engineering
      description: Owns shared infrastructure and developer tooling
      members:
        - 1.234567e+06
        - 2.345678e+06
        - 3.456789e+06
      managers:
        - 1.234567e+06
      resources:
        - type: GITHUB
          content: https://github.com/example-org/platform
          title: Source Repository
        - type: SLACK
          content: https://example.slack.com/channels/platform-eng
          title: Team Channel
        - type: PAGERDUTY
          content: https://example.pagerduty.com/teams/platform
          title: On-Call Schedule

    terraform {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_team" "platform" {
  lifecycle {
    create_before_destroy = true
  }
  name        = "Platform Engineering"
  description = "Owns shared infrastructure and developer tooling"
  members     = [1234567, 2345678, 3456789]
  managers    = [1234567]
  resources {
    type    = "GITHUB"
    content = "https://github.com/example-org/platform"
    title   = "Source Repository"
  }
  resources {
    type    = "SLACK"
    content = "https://example.slack.com/channels/platform-eng"
    title   = "Team Channel"
  }
  resources {
    type    = "PAGERDUTY"
    content = "https://example.pagerduty.com/teams/platform"
    title   = "On-Call Schedule"
  }
}

    Create Team Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Team(name: string, args?: TeamArgs, opts?: CustomResourceOptions);
    @overload
def Team(resource_name: str,
         args: Optional[TeamArgs] = None,
         opts: Optional[ResourceOptions] = None)

@overload
def Team(resource_name: str,
         opts: Optional[ResourceOptions] = None,
         aliases: Optional[Sequence[str]] = None,
         description: Optional[str] = None,
         entities: Optional[Sequence[str]] = None,
         entity_management_mode: Optional[str] = None,
         managers: Optional[Sequence[int]] = None,
         members: Optional[Sequence[int]] = None,
         name: Optional[str] = None,
         parent_id: Optional[str] = None,
         resources: Optional[Sequence[TeamResourceArgs]] = None,
         tags: Optional[Sequence[TeamTagArgs]] = None)
    func NewTeam(ctx *Context, name string, args *TeamArgs, opts ...ResourceOption) (*Team, error)
    public Team(string name, TeamArgs? args = null, CustomResourceOptions? opts = null)
    public Team(String name, TeamArgs args)
public Team(String name, TeamArgs args, CustomResourceOptions options)

    type: newrelic:Team
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "newrelic_team" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args TeamArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args TeamArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args TeamArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args TeamArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args TeamArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var teamResource = new NewRelic.Team("teamResource", new()
{
    Aliases = new[]
    {
        "string",
    },
    Description = "string",
    Entities = new[]
    {
        "string",
    },
    EntityManagementMode = "string",
    Managers = new[]
    {
        0,
    },
    Members = new[]
    {
        0,
    },
    Name = "string",
    ParentId = "string",
    Resources = new[]
    {
        new NewRelic.Inputs.TeamResourceArgs
        {
            Content = "string",
            Type = "string",
            Title = "string",
        },
    },
    Tags = new[]
    {
        new NewRelic.Inputs.TeamTagArgs
        {
            Key = "string",
            Values = new[]
            {
                "string",
            },
        },
    },
});

    example, err := newrelic.NewTeam(ctx, "teamResource", &newrelic.TeamArgs{
	Aliases: pulumi.StringArray{
		pulumi.String("string"),
	},
	Description: pulumi.String("string"),
	Entities: pulumi.StringArray{
		pulumi.String("string"),
	},
	EntityManagementMode: pulumi.String("string"),
	Managers: pulumi.IntArray{
		pulumi.Int(0),
	},
	Members: pulumi.IntArray{
		pulumi.Int(0),
	},
	Name:     pulumi.String("string"),
	ParentId: pulumi.String("string"),
	Resources: newrelic.TeamResourceArray{
		&newrelic.TeamResourceArgs{
			Content: pulumi.String("string"),
			Type:    pulumi.String("string"),
			Title:   pulumi.String("string"),
		},
	},
	Tags: newrelic.TeamTagArray{
		&newrelic.TeamTagArgs{
			Key: pulumi.String("string"),
			Values: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
})

    resource "newrelic_team" "teamResource" {
  lifecycle {
    create_before_destroy = true
  }
  aliases                = ["string"]
  description            = "string"
  entities               = ["string"]
  entity_management_mode = "string"
  managers               = [0]
  members                = [0]
  name                   = "string"
  parent_id              = "string"
  resources {
    content = "string"
    type    = "string"
    title   = "string"
  }
  tags {
    key    = "string"
    values = ["string"]
  }
}

    var teamResource = new Team("teamResource", TeamArgs.builder()
    .aliases("string")
    .description("string")
    .entities("string")
    .entityManagementMode("string")
    .managers(0)
    .members(0)
    .name("string")
    .parentId("string")
    .resources(TeamResourceArgs.builder()
        .content("string")
        .type("string")
        .title("string")
        .build())
    .tags(TeamTagArgs.builder()
        .key("string")
        .values("string")
        .build())
    .build());

    team_resource = newrelic.Team("teamResource",
    aliases=["string"],
    description="string",
    entities=["string"],
    entity_management_mode="string",
    managers=[0],
    members=[0],
    name="string",
    parent_id="string",
    resources=[{
        "content": "string",
        "type": "string",
        "title": "string",
    }],
    tags=[{
        "key": "string",
        "values": ["string"],
    }])

    const teamResource = new newrelic.Team("teamResource", {
    aliases: ["string"],
    description: "string",
    entities: ["string"],
    entityManagementMode: "string",
    managers: [0],
    members: [0],
    name: "string",
    parentId: "string",
    resources: [{
        content: "string",
        type: "string",
        title: "string",
    }],
    tags: [{
        key: "string",
        values: ["string"],
    }],
});

    type: newrelic:Team
properties:
    aliases:
        - string
    description: string
    entities:
        - string
    entityManagementMode: string
    managers:
        - 0
    members:
        - 0
    name: string
    parentId: string
    resources:
        - content: string
          title: string
          type: string
    tags:
        - key: string
          values:
            - string

    Team Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Team resource accepts the following input properties:

    Aliases List<string>
    Additional searchable names for the team. Each alias must be unique within the organization.
    Description string
    A free-text description of the team.
    Entities List<string>
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    EntityManagementMode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    Managers List<int>
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    Members List<int>
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    Name string
    The name of the team. Must be unique within the organization.
    ParentId string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    Resources List<Pulumi.NewRelic.Inputs.TeamResource>
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    Tags List<Pulumi.NewRelic.Inputs.TeamTag>
    Tags to assign to this resource. Each tag has a key and one or more values.
    Aliases []string
    Additional searchable names for the team. Each alias must be unique within the organization.
    Description string
    A free-text description of the team.
    Entities []string
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    EntityManagementMode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    Managers []int
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    Members []int
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    Name string
    The name of the team. Must be unique within the organization.
    ParentId string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    Resources []TeamResourceArgs
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    Tags []TeamTagArgs
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases list(string)
    Additional searchable names for the team. Each alias must be unique within the organization.
    description string
    A free-text description of the team.
    entities list(string)
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entity_management_mode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    managers list(number)
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members list(number)
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    name string
    The name of the team. Must be unique within the organization.
    parent_id string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources list(object)
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags list(object)
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases List<String>
    Additional searchable names for the team. Each alias must be unique within the organization.
    description String
    A free-text description of the team.
    entities List<String>
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entityManagementMode String

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    managers List<Integer>
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members List<Integer>
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    name String
    The name of the team. Must be unique within the organization.
    parentId String
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources List<TeamResource>
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags List<TeamTag>
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases string[]
    Additional searchable names for the team. Each alias must be unique within the organization.
    description string
    A free-text description of the team.
    entities string[]
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entityManagementMode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    managers number[]
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members number[]
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    name string
    The name of the team. Must be unique within the organization.
    parentId string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources TeamResource[]
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags TeamTag[]
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases Sequence[str]
    Additional searchable names for the team. Each alias must be unique within the organization.
    description str
    A free-text description of the team.
    entities Sequence[str]
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entity_management_mode str

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    managers Sequence[int]
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members Sequence[int]
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    name str
    The name of the team. Must be unique within the organization.
    parent_id str
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources Sequence[TeamResourceArgs]
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags Sequence[TeamTagArgs]
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases List<String>
    Additional searchable names for the team. Each alias must be unique within the organization.
    description String
    A free-text description of the team.
    entities List<String>
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entityManagementMode String

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    managers List<Number>
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members List<Number>
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    name String
    The name of the team. Must be unique within the organization.
    parentId String
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources List<Property Map>
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags List<Property Map>
    Tags to assign to this resource. Each tag has a key and one or more values.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Team resource produces the following output properties:

    HierarchyLevelId string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    Id string
    The provider-assigned unique ID for this managed resource.
    MembershipCollectionId string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    OrganizationId string
    The organisation UUID, resolved automatically from the provider account.
    OwnershipCollectionId string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    HierarchyLevelId string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    Id string
    The provider-assigned unique ID for this managed resource.
    MembershipCollectionId string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    OrganizationId string
    The organisation UUID, resolved automatically from the provider account.
    OwnershipCollectionId string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    hierarchy_level_id string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    id string
    The provider-assigned unique ID for this managed resource.
    membership_collection_id string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    organization_id string
    The organisation UUID, resolved automatically from the provider account.
    ownership_collection_id string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    hierarchyLevelId String
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    id String
    The provider-assigned unique ID for this managed resource.
    membershipCollectionId String
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    organizationId String
    The organisation UUID, resolved automatically from the provider account.
    ownershipCollectionId String
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    hierarchyLevelId string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    id string
    The provider-assigned unique ID for this managed resource.
    membershipCollectionId string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    organizationId string
    The organisation UUID, resolved automatically from the provider account.
    ownershipCollectionId string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    hierarchy_level_id str
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    id str
    The provider-assigned unique ID for this managed resource.
    membership_collection_id str
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    organization_id str
    The organisation UUID, resolved automatically from the provider account.
    ownership_collection_id str
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    hierarchyLevelId String
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    id String
    The provider-assigned unique ID for this managed resource.
    membershipCollectionId String
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    organizationId String
    The organisation UUID, resolved automatically from the provider account.
    ownershipCollectionId String
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.

    Look up Existing Team Resource

    Get an existing Team resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: TeamState, opts?: CustomResourceOptions): Team
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        aliases: Optional[Sequence[str]] = None,
        description: Optional[str] = None,
        entities: Optional[Sequence[str]] = None,
        entity_management_mode: Optional[str] = None,
        hierarchy_level_id: Optional[str] = None,
        managers: Optional[Sequence[int]] = None,
        members: Optional[Sequence[int]] = None,
        membership_collection_id: Optional[str] = None,
        name: Optional[str] = None,
        organization_id: Optional[str] = None,
        ownership_collection_id: Optional[str] = None,
        parent_id: Optional[str] = None,
        resources: Optional[Sequence[TeamResourceArgs]] = None,
        tags: Optional[Sequence[TeamTagArgs]] = None) -> Team
    func GetTeam(ctx *Context, name string, id IDInput, state *TeamState, opts ...ResourceOption) (*Team, error)
    public static Team Get(string name, Input<string> id, TeamState? state, CustomResourceOptions? opts = null)
    public static Team get(String name, Output<String> id, TeamState state, CustomResourceOptions options)
    resources:  _:    type: newrelic:Team    get:      id: ${id}
    import {
  to = newrelic_team.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Aliases List<string>
    Additional searchable names for the team. Each alias must be unique within the organization.
    Description string
    A free-text description of the team.
    Entities List<string>
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    EntityManagementMode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    HierarchyLevelId string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    Managers List<int>
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    Members List<int>
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    MembershipCollectionId string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    Name string
    The name of the team. Must be unique within the organization.
    OrganizationId string
    The organisation UUID, resolved automatically from the provider account.
    OwnershipCollectionId string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    ParentId string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    Resources List<Pulumi.NewRelic.Inputs.TeamResource>
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    Tags List<Pulumi.NewRelic.Inputs.TeamTag>
    Tags to assign to this resource. Each tag has a key and one or more values.
    Aliases []string
    Additional searchable names for the team. Each alias must be unique within the organization.
    Description string
    A free-text description of the team.
    Entities []string
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    EntityManagementMode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    HierarchyLevelId string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    Managers []int
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    Members []int
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    MembershipCollectionId string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    Name string
    The name of the team. Must be unique within the organization.
    OrganizationId string
    The organisation UUID, resolved automatically from the provider account.
    OwnershipCollectionId string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    ParentId string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    Resources []TeamResourceArgs
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    Tags []TeamTagArgs
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases list(string)
    Additional searchable names for the team. Each alias must be unique within the organization.
    description string
    A free-text description of the team.
    entities list(string)
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entity_management_mode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    hierarchy_level_id string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    managers list(number)
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members list(number)
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    membership_collection_id string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    name string
    The name of the team. Must be unique within the organization.
    organization_id string
    The organisation UUID, resolved automatically from the provider account.
    ownership_collection_id string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    parent_id string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources list(object)
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags list(object)
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases List<String>
    Additional searchable names for the team. Each alias must be unique within the organization.
    description String
    A free-text description of the team.
    entities List<String>
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entityManagementMode String

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    hierarchyLevelId String
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    managers List<Integer>
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members List<Integer>
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    membershipCollectionId String
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    name String
    The name of the team. Must be unique within the organization.
    organizationId String
    The organisation UUID, resolved automatically from the provider account.
    ownershipCollectionId String
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    parentId String
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources List<TeamResource>
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags List<TeamTag>
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases string[]
    Additional searchable names for the team. Each alias must be unique within the organization.
    description string
    A free-text description of the team.
    entities string[]
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entityManagementMode string

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    hierarchyLevelId string
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    managers number[]
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members number[]
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    membershipCollectionId string
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    name string
    The name of the team. Must be unique within the organization.
    organizationId string
    The organisation UUID, resolved automatically from the provider account.
    ownershipCollectionId string
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    parentId string
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources TeamResource[]
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags TeamTag[]
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases Sequence[str]
    Additional searchable names for the team. Each alias must be unique within the organization.
    description str
    A free-text description of the team.
    entities Sequence[str]
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entity_management_mode str

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    hierarchy_level_id str
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    managers Sequence[int]
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members Sequence[int]
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    membership_collection_id str
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    name str
    The name of the team. Must be unique within the organization.
    organization_id str
    The organisation UUID, resolved automatically from the provider account.
    ownership_collection_id str
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    parent_id str
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources Sequence[TeamResourceArgs]
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags Sequence[TeamTagArgs]
    Tags to assign to this resource. Each tag has a key and one or more values.
    aliases List<String>
    Additional searchable names for the team. Each alias must be unique within the organization.
    description String
    A free-text description of the team.
    entities List<String>
    Set of entity GUIDs that this team owns. Added to the team's auto-created ownership collection.
    entityManagementMode String

    Controls how Terraform manages this team's entity ownership collection.

    • managed (default): Terraform tracks the entities declared in the entities block and ensures they remain in the collection. Drift surfaces only when a declared entity goes missing. External additions are silently ignored. • unmanaged: Terraform does not control entity ownership. The ownership collection is left entirely to tag-based discovery and/or manual UI management. No drift or warnings are shown for entities, and the entities attribute cannot be set in this mode.

    hierarchyLevelId String
    The GUID of the hierarchy level this team is assigned to. The platform assigns this automatically based on the team's depth in the parentId chain. It becomes available on the plan cycle after parentId is first set (one refresh cycle of eventual consistency). Matches a level GUID from the newrelic.TeamsOrganizationSettings hierarchyLevels list. See Hierarchy Levels.
    managers List<Number>
    Set of New Relic user IDs (integers) to designate as team managers. Each ID must also appear in members.
    members List<Number>
    Set of New Relic user IDs (integers) to add as members of this team. Managers must be a subset of members.
    membershipCollectionId String
    The GUID of the auto-created team membership collection. Managed by the provider; do not modify directly.
    name String
    The name of the team. Must be unique within the organization.
    organizationId String
    The organisation UUID, resolved automatically from the provider account.
    ownershipCollectionId String
    The GUID of the auto-created team ownership collection. Managed by the provider; do not modify directly.
    parentId String
    Entity management GUID of the parent team. Cannot be set to the team's own GUID.
    resources List<Property Map>
    Supplemental resource links attached to this team (e.g. runbooks, chat channels, on-call schedules). These are displayed in the team's Settings page in the New Relic UI under Contacts or Links, automatically categorised by type.
    tags List<Property Map>
    Tags to assign to this resource. Each tag has a key and one or more values.

    Supporting Types

    TeamResource, TeamResourceArgs

    Content string
    The URL or contact address for this resource.
    Type string
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    Title string
    A short label shown in the UI for this resource.
    Content string
    The URL or contact address for this resource.
    Type string
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    Title string
    A short label shown in the UI for this resource.
    content string
    The URL or contact address for this resource.
    type string
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    title string
    A short label shown in the UI for this resource.
    content String
    The URL or contact address for this resource.
    type String
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    title String
    A short label shown in the UI for this resource.
    content string
    The URL or contact address for this resource.
    type string
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    title string
    A short label shown in the UI for this resource.
    content str
    The URL or contact address for this resource.
    type str
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    title str
    A short label shown in the UI for this resource.
    content String
    The URL or contact address for this resource.
    type String
    Resource category. Valid values are defined in TeamResourceTypeValues() in the go-client and stay in sync with the API automatically.
    title String
    A short label shown in the UI for this resource.

    TeamTag, TeamTagArgs

    Key string
    The tag key.
    Values List<string>
    The tag values.
    Key string
    The tag key.
    Values []string
    The tag values.
    key string
    The tag key.
    values list(string)
    The tag values.
    key String
    The tag key.
    values List<String>
    The tag values.
    key string
    The tag key.
    values string[]
    The tag values.
    key str
    The tag key.
    values Sequence[str]
    The tag values.
    key String
    The tag key.
    values List<String>
    The tag values.

    Import

    Teams can be imported using the entity GUID:

    $ pulumi import newrelic:index/team:Team example <guid>

    To find a team’s GUID after creating it, use terraform state show or the following NerdGraph query:

    {
  actor {
    entityManagement {
      entitySearch(query: "type = 'TEAM' AND name = 'Your Team Name'") {
        entities { id name }
      }
    }
  }
}

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    New Relic pulumi/pulumi-newrelic
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the newrelic Terraform Provider.
    newrelic logo newrelic logo
    Viewing docs for New Relic v5.80.4
    published on Tuesday, Oct 27, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-newrelic

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial