Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. incident.io
  4. API Docs
  5. getCatalogType
Viewing docs for incident.io v0.4.1
published on Wednesday, Oct 21, 2026 by incident-io
Schema (JSON)
incident-io/pulumi-incident

incident.getCatalogType

incident logo incident.io
Viewing docs for incident.io v0.4.1
published on Wednesday, Oct 21, 2026 by incident-io
Schema (JSON)
incident-io/pulumi-incident

    This data source provides information about a catalog type.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as incident from "@incident-io/pulumi";

// Reference the catalog type by its name.
const service = incident.getCatalogType({
    name: "Service",
});
// An entry's values are keyed by attribute ID, so look the attributes up by name rather
// than pinning IDs that differ between workspaces.
const serviceDescription = service.then(service => incident.getCatalogTypeAttribute({
    catalogTypeId: service.id,
    name: "Description",
}));
const serviceTags = service.then(service => incident.getCatalogTypeAttribute({
    catalogTypeId: service.id,
    name: "Tags",
}));
// Now provision the entries for the catalog type.
const services = new incident.CatalogEntries("services", {
    catalogEntriesId: service.then(service => service.id),
    entries: {
        primary: {
            name: "artist-web",
            attributeValues: Promise.all([serviceDescription, serviceTags]).then(([serviceDescription, serviceTags]) => {
                [serviceDescription.id]: {
                    value: "public-websites",
                },
                [serviceTags.id]: {
                    arrayValue: ["java"],
                },
            }),
        },
    },
});

    import pulumi
import pulumi_incident as incident

# Reference the catalog type by its name.
service = incident.get_catalog_type(name="Service")
# An entry's values are keyed by attribute ID, so look the attributes up by name rather
# than pinning IDs that differ between workspaces.
service_description = incident.get_catalog_type_attribute(catalog_type_id=service.id,
    name="Description")
service_tags = incident.get_catalog_type_attribute(catalog_type_id=service.id,
    name="Tags")
# Now provision the entries for the catalog type.
services = incident.CatalogEntries("services",
    catalog_entries_id=service.id,
    entries={
        "primary": {
            "name": "artist-web",
            "attribute_values": {
                service_description.id: {
                    "value": "public-websites",
                },
                service_tags.id: {
                    "array_value": ["java"],
                },
            },
        },
    })

    package main

import (
	"github.com/incident-io/pulumi-incident/sdk/go/incident"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Reference the catalog type by its name.
		service, err := incident.GetCatalogType(ctx, &incident.LookupCatalogTypeArgs{
			Name: pulumi.StringRef("Service"),
		}, nil)
		if err != nil {
			return err
		}
		// An entry's values are keyed by attribute ID, so look the attributes up by name rather
		// than pinning IDs that differ between workspaces.
		serviceDescription, err := incident.GetCatalogTypeAttribute(ctx, &incident.LookupCatalogTypeAttributeArgs{
			CatalogTypeId: service.Id,
			Name:          "Description",
		}, nil)
		if err != nil {
			return err
		}
		serviceTags, err := incident.GetCatalogTypeAttribute(ctx, &incident.LookupCatalogTypeAttributeArgs{
			CatalogTypeId: service.Id,
			Name:          "Tags",
		}, nil)
		if err != nil {
			return err
		}
		// Now provision the entries for the catalog type.
		_, err = incident.NewCatalogEntries(ctx, "services", &incident.CatalogEntriesArgs{
			CatalogEntriesId: pulumi.String(service.Id),
			Entries: incident.CatalogEntriesEntriesMap{
				"primary": &incident.CatalogEntriesEntriesArgs{
					Name: pulumi.String("artist-web"),
					AttributeValues: incident.CatalogEntriesEntriesAttributeValuesMap{
						pulumi.String(serviceDescription.Id): &incident.CatalogEntriesEntriesAttributeValuesArgs{
							Value: pulumi.String("public-websites"),
						},
						pulumi.String(serviceTags.Id): &incident.CatalogEntriesEntriesAttributeValuesArgs{
							ArrayValue: []string{
								"java",
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Reference the catalog type by its name.
    var service = Incident.GetCatalogType.Invoke(new()
    {
        Name = "Service",
    });

    // An entry's values are keyed by attribute ID, so look the attributes up by name rather
    // than pinning IDs that differ between workspaces.
    var serviceDescription = Incident.GetCatalogTypeAttribute.Invoke(new()
    {
        CatalogTypeId = service.Apply(getCatalogTypeResult => getCatalogTypeResult.Id),
        Name = "Description",
    });

    var serviceTags = Incident.GetCatalogTypeAttribute.Invoke(new()
    {
        CatalogTypeId = service.Apply(getCatalogTypeResult => getCatalogTypeResult.Id),
        Name = "Tags",
    });

    // Now provision the entries for the catalog type.
    var services = new Incident.CatalogEntries("services", new()
    {
        CatalogEntriesId = service.Apply(getCatalogTypeResult => getCatalogTypeResult.Id),
        Entries = 
        {
            { "primary", new Incident.Inputs.CatalogEntriesEntriesArgs
            {
                Name = "artist-web",
                AttributeValues = Output.Tuple(serviceDescription, serviceTags).Apply(values =>
                {
                    var serviceDescription = values.Item1;
                    var serviceTags = values.Item2;
                    return 
                    {
                        { serviceDescription.Apply(getCatalogTypeAttributeResult => getCatalogTypeAttributeResult.Id), 
                        {
                            { "value", "public-websites" },
                        } },
                        { serviceTags.Apply(getCatalogTypeAttributeResult => getCatalogTypeAttributeResult.Id), 
                        {
                            { "arrayValue", new[]
                            {
                                "java",
                            } },
                        } },
                    };
                }),
            } },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.IncidentFunctions;
import com.pulumi.incident.inputs.GetCatalogTypeArgs;
import com.pulumi.incident.inputs.GetCatalogTypeAttributeArgs;
import com.pulumi.incident.CatalogEntries;
import com.pulumi.incident.CatalogEntriesArgs;
import com.pulumi.incident.inputs.CatalogEntriesEntriesArgs;
import com.pulumi.incident.inputs.CatalogEntriesEntriesAttributeValuesArgs;
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) {
        // Reference the catalog type by its name.
        final var service = IncidentFunctions.getCatalogType(GetCatalogTypeArgs.builder()
            .name("Service")
            .build());

        // An entry's values are keyed by attribute ID, so look the attributes up by name rather
        // than pinning IDs that differ between workspaces.
        final var serviceDescription = IncidentFunctions.getCatalogTypeAttribute(GetCatalogTypeAttributeArgs.builder()
            .catalogTypeId(service.id())
            .name("Description")
            .build());

        final var serviceTags = IncidentFunctions.getCatalogTypeAttribute(GetCatalogTypeAttributeArgs.builder()
            .catalogTypeId(service.id())
            .name("Tags")
            .build());

        // Now provision the entries for the catalog type.
        var services = new CatalogEntries("services", CatalogEntriesArgs.builder()
            .catalogEntriesId(service.id())
            .entries(Map.of("primary", CatalogEntriesEntriesArgs.builder()
                .name("artist-web")
                .attributeValues(Output.tuple(serviceDescription.id(), CatalogEntriesEntriesAttributeValuesArgs.builder()
                    .value("public-websites")
                    .build(), serviceTags.id(), CatalogEntriesEntriesAttributeValuesArgs.builder()
                    .arrayValue(Arrays.asList("java"))
                    .build()).applyValue(values -> {
                    var __convert = values.t1;
                    var __convert1 = values.t2;
                    var __convert2 = values.t3;
                    var __convert3 = values.t4;
                    return Map.ofEntries(
                        Map.entry(__convert, __convert1),
                        Map.entry(__convert2, __convert3)
                    );
                }))
                .build()))
            .build());

    }
}

    resources:
  # Now provision the entries for the catalog type.
  services:
    type: incident:CatalogEntries
    properties:
      catalogEntriesId: ${service.id}
      entries:
        primary:
          name: artist-web
          attributeValues:
            ${serviceDescription.id}:
              value: public-websites
            ${serviceTags.id}:
              arrayValue:
                - java
variables:
  # Reference the catalog type by its name.
  service:
    fn::invoke:
      function: incident:getCatalogType
      arguments:
        name: Service
  # An entry's values are keyed by attribute ID, so look the attributes up by name rather
  # than pinning IDs that differ between workspaces.
  serviceDescription:
    fn::invoke:
      function: incident:getCatalogTypeAttribute
      arguments:
        catalogTypeId: ${service.id}
        name: Description
  serviceTags:
    fn::invoke:
      function: incident:getCatalogTypeAttribute
      arguments:
        catalogTypeId: ${service.id}
        name: Tags

    pulumi {
  required_providers {
    incident = {
      source = "pulumi/incident"
    }
  }
}

data "incident_getcatalogtype" "service" {
  name = "Service"
}
data "incident_getcatalogtypeattribute" "serviceDescription" {
  catalog_type_id = data.incident_getcatalogtype.service.id
  name            = "Description"
}
data "incident_getcatalogtypeattribute" "serviceTags" {
  catalog_type_id = data.incident_getcatalogtype.service.id
  name            = "Tags"
}

# Now provision the entries for the catalog type.
resource "incident_catalogentries" "services" {
  catalog_entries_id = data.incident_getcatalogtype.service.id
  entries = {
    "primary" = {
      name = "artist-web"
      attribute_values = {
        data.incident_getcatalogtypeattribute.serviceDescription.id = {
          value = "public-websites"
        }
        data.incident_getcatalogtypeattribute.serviceTags.id = {
          array_value = ["java"]
        }
      }
    }
  }
}
# Reference the catalog type by its name.
# An entry's values are keyed by attribute ID, so look the attributes up by name rather
# than pinning IDs that differ between workspaces.

    Using getCatalogType

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getCatalogType(args: GetCatalogTypeArgs, opts?: InvokeOptions): Promise<GetCatalogTypeResult>
function getCatalogTypeOutput(args: GetCatalogTypeOutputArgs, opts?: InvokeOutputOptions): Output<GetCatalogTypeResult>
    def get_catalog_type(categories: Optional[Sequence[str]] = None,
                     name: Optional[str] = None,
                     type_name: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetCatalogTypeResult
def get_catalog_type_output(categories: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                     name: pulumi.Input[Optional[str]] = None,
                     type_name: pulumi.Input[Optional[str]] = None,
                     opts: Optional[InvokeOutputOptions] = None) -> Output[GetCatalogTypeResult]
    func LookupCatalogType(ctx *Context, args *LookupCatalogTypeArgs, opts ...InvokeOption) (*LookupCatalogTypeResult, error)
func LookupCatalogTypeOutput(ctx *Context, args *LookupCatalogTypeOutputArgs, opts ...InvokeOption) LookupCatalogTypeResultOutput

    > Note: This function is named LookupCatalogType in the Go SDK.

    public static class GetCatalogType 
{
    public static Task<GetCatalogTypeResult> InvokeAsync(GetCatalogTypeArgs args, InvokeOptions? opts = null)
    public static Output<GetCatalogTypeResult> Invoke(GetCatalogTypeInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetCatalogTypeResult> Invoke(GetCatalogTypeInvokeArgs args, InvokeOutputOptions opts)
}
    public static CompletableFuture<GetCatalogTypeResult> getCatalogType(GetCatalogTypeArgs args, InvokeOptions options)
public static Output<GetCatalogTypeResult> getCatalogType(GetCatalogTypeArgs args, InvokeOptions options)
public static Output<GetCatalogTypeResult> getCatalogType(GetCatalogTypeArgs args, InvokeOutputOptions options)

    fn::invoke:
  function: incident:index/getCatalogType:getCatalogType
  arguments:
    # arguments dictionary
    data "incident_get_catalog_type" "name" {
    # arguments
}

    The following arguments are supported:

    Categories List<string>
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    Name string
    Name is the human readable name of this type
    TypeName string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    Categories []string
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    Name string
    Name is the human readable name of this type
    TypeName string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    categories list(string)
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    name string
    Name is the human readable name of this type
    type_name string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    categories List<String>
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    name String
    Name is the human readable name of this type
    typeName String
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    categories string[]
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    name string
    Name is the human readable name of this type
    typeName string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    categories Sequence[str]
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    name str
    Name is the human readable name of this type
    type_name str
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    categories List<String>
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    name String
    Name is the human readable name of this type
    typeName String
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]

    getCatalogType Result

    The following output properties are available:

    AttributeType string
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    Description string
    Human readble description of this type
    Id string
    ID of this catalog type
    Name string
    Name is the human readable name of this type
    OwningTeamIds List<string>
    IDs of the teams that own this catalog type
    SourceRepoUrl string
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    TypeName string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    UnlockInDashboard bool
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    UseNameAsIdentifier bool
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    Categories List<string>
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    AttributeType string
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    Description string
    Human readble description of this type
    Id string
    ID of this catalog type
    Name string
    Name is the human readable name of this type
    OwningTeamIds []string
    IDs of the teams that own this catalog type
    SourceRepoUrl string
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    TypeName string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    UnlockInDashboard bool
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    UseNameAsIdentifier bool
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    Categories []string
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    attribute_type string
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    description string
    Human readble description of this type
    id string
    ID of this catalog type
    name string
    Name is the human readable name of this type
    owning_team_ids list(string)
    IDs of the teams that own this catalog type
    source_repo_url string
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    type_name string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    unlock_in_dashboard bool
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    use_name_as_identifier bool
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    categories list(string)
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    attributeType String
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    description String
    Human readble description of this type
    id String
    ID of this catalog type
    name String
    Name is the human readable name of this type
    owningTeamIds List<String>
    IDs of the teams that own this catalog type
    sourceRepoUrl String
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    typeName String
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    unlockInDashboard Boolean
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    useNameAsIdentifier Boolean
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    categories List<String>
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    attributeType string
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    description string
    Human readble description of this type
    id string
    ID of this catalog type
    name string
    Name is the human readable name of this type
    owningTeamIds string[]
    IDs of the teams that own this catalog type
    sourceRepoUrl string
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    typeName string
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    unlockInDashboard boolean
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    useNameAsIdentifier boolean
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    categories string[]
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    attribute_type str
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    description str
    Human readble description of this type
    id str
    ID of this catalog type
    name str
    Name is the human readable name of this type
    owning_team_ids Sequence[str]
    IDs of the teams that own this catalog type
    source_repo_url str
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    type_name str
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    unlock_in_dashboard bool
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    use_name_as_identifier bool
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    categories Sequence[str]
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.
    attributeType String
    How to refer to this type when saying that something holds its entries: the type of an alert attribute or catalog attribute, or the as of an engine expression. Take it from here rather than writing it out - a type that one of our integrations owns is referenced by its registry name rather than its ID, so the two don't have the same shape.
    description String
    Human readble description of this type
    id String
    ID of this catalog type
    name String
    Name is the human readable name of this type
    owningTeamIds List<String>
    IDs of the teams that own this catalog type
    sourceRepoUrl String
    The url of the external repository where this type is managed. If set, users will not be able to edit the catalog type (or its entries) via the UI, and will instead be provided a link to this URL.
    typeName String
    The type name of this catalog type, to be used when defining attributes. This is immutable once a CatalogType has been created. For non-externally sync types, it must follow the pattern Custom["SomeName"]
    unlockInDashboard Boolean
    Not populated: whether Terraform claims a resource is configuration, and no read endpoint reports it.
    useNameAsIdentifier Boolean
    If enabled, you can refer to entries of this type by their name, as well as their external ID and any aliases.
    categories List<String>
    The categories that this type belongs to, to be shown in the web dashboard. Possible values are: customer, issue-tracker, product-feature, service, on-call, team, user.

    Package Details

    Repository
    incident incident-io/pulumi-incident
    License
    MIT
    Notes
    This Pulumi package is based on the incident Terraform Provider.
    incident logo incident.io
    Viewing docs for incident.io v0.4.1
    published on Wednesday, Oct 21, 2026 by incident-io
    Schema (JSON)
    incident-io/pulumi-incident

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial