# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'GetStackResult',
    'AwaitableGetStackResult',
    'get_stack',
    'get_stack_output',
]

@pulumi.output_type
class GetStackResult:
    """
    A collection of values returned by getStack.
    """
    def __init__(__self__, alertmanager_ip_allow_list_cname=None, alertmanager_name=None, alertmanager_status=None, alertmanager_url=None, alertmanager_user_id=None, cluster_slug=None, description=None, fleet_management_name=None, fleet_management_status=None, fleet_management_url=None, fleet_management_user_id=None, grafanas_ip_allow_list_cname=None, graphite_ip_allow_list_cname=None, graphite_name=None, graphite_private_connectivity_info_private_dns=None, graphite_private_connectivity_info_service_name=None, graphite_status=None, graphite_url=None, graphite_user_id=None, id=None, influx_url=None, labels=None, logs_ip_allow_list_cname=None, logs_name=None, logs_private_connectivity_info_private_dns=None, logs_private_connectivity_info_service_name=None, logs_status=None, logs_url=None, logs_user_id=None, name=None, org_id=None, org_name=None, org_slug=None, otlp_private_connectivity_info_private_dns=None, otlp_private_connectivity_info_service_name=None, otlp_url=None, pdc_api_private_connectivity_info_private_dns=None, pdc_api_private_connectivity_info_service_name=None, pdc_gateway_private_connectivity_info_private_dns=None, pdc_gateway_private_connectivity_info_service_name=None, profiles_ip_allow_list_cname=None, profiles_name=None, profiles_private_connectivity_info_private_dns=None, profiles_private_connectivity_info_service_name=None, profiles_status=None, profiles_url=None, profiles_user_id=None, prometheus_ip_allow_list_cname=None, prometheus_name=None, prometheus_private_connectivity_info_private_dns=None, prometheus_private_connectivity_info_service_name=None, prometheus_remote_endpoint=None, prometheus_remote_write_endpoint=None, prometheus_status=None, prometheus_url=None, prometheus_user_id=None, region_slug=None, slug=None, status=None, traces_ip_allow_list_cname=None, traces_name=None, traces_private_connectivity_info_private_dns=None, traces_private_connectivity_info_service_name=None, traces_status=None, traces_url=None, traces_user_id=None, url=None):
        if alertmanager_ip_allow_list_cname and not isinstance(alertmanager_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'alertmanager_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "alertmanager_ip_allow_list_cname", alertmanager_ip_allow_list_cname)
        if alertmanager_name and not isinstance(alertmanager_name, str):
            raise TypeError("Expected argument 'alertmanager_name' to be a str")
        pulumi.set(__self__, "alertmanager_name", alertmanager_name)
        if alertmanager_status and not isinstance(alertmanager_status, str):
            raise TypeError("Expected argument 'alertmanager_status' to be a str")
        pulumi.set(__self__, "alertmanager_status", alertmanager_status)
        if alertmanager_url and not isinstance(alertmanager_url, str):
            raise TypeError("Expected argument 'alertmanager_url' to be a str")
        pulumi.set(__self__, "alertmanager_url", alertmanager_url)
        if alertmanager_user_id and not isinstance(alertmanager_user_id, int):
            raise TypeError("Expected argument 'alertmanager_user_id' to be a int")
        pulumi.set(__self__, "alertmanager_user_id", alertmanager_user_id)
        if cluster_slug and not isinstance(cluster_slug, str):
            raise TypeError("Expected argument 'cluster_slug' to be a str")
        pulumi.set(__self__, "cluster_slug", cluster_slug)
        if description and not isinstance(description, str):
            raise TypeError("Expected argument 'description' to be a str")
        pulumi.set(__self__, "description", description)
        if fleet_management_name and not isinstance(fleet_management_name, str):
            raise TypeError("Expected argument 'fleet_management_name' to be a str")
        pulumi.set(__self__, "fleet_management_name", fleet_management_name)
        if fleet_management_status and not isinstance(fleet_management_status, str):
            raise TypeError("Expected argument 'fleet_management_status' to be a str")
        pulumi.set(__self__, "fleet_management_status", fleet_management_status)
        if fleet_management_url and not isinstance(fleet_management_url, str):
            raise TypeError("Expected argument 'fleet_management_url' to be a str")
        pulumi.set(__self__, "fleet_management_url", fleet_management_url)
        if fleet_management_user_id and not isinstance(fleet_management_user_id, int):
            raise TypeError("Expected argument 'fleet_management_user_id' to be a int")
        pulumi.set(__self__, "fleet_management_user_id", fleet_management_user_id)
        if grafanas_ip_allow_list_cname and not isinstance(grafanas_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'grafanas_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "grafanas_ip_allow_list_cname", grafanas_ip_allow_list_cname)
        if graphite_ip_allow_list_cname and not isinstance(graphite_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'graphite_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "graphite_ip_allow_list_cname", graphite_ip_allow_list_cname)
        if graphite_name and not isinstance(graphite_name, str):
            raise TypeError("Expected argument 'graphite_name' to be a str")
        pulumi.set(__self__, "graphite_name", graphite_name)
        if graphite_private_connectivity_info_private_dns and not isinstance(graphite_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'graphite_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "graphite_private_connectivity_info_private_dns", graphite_private_connectivity_info_private_dns)
        if graphite_private_connectivity_info_service_name and not isinstance(graphite_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'graphite_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "graphite_private_connectivity_info_service_name", graphite_private_connectivity_info_service_name)
        if graphite_status and not isinstance(graphite_status, str):
            raise TypeError("Expected argument 'graphite_status' to be a str")
        pulumi.set(__self__, "graphite_status", graphite_status)
        if graphite_url and not isinstance(graphite_url, str):
            raise TypeError("Expected argument 'graphite_url' to be a str")
        pulumi.set(__self__, "graphite_url", graphite_url)
        if graphite_user_id and not isinstance(graphite_user_id, int):
            raise TypeError("Expected argument 'graphite_user_id' to be a int")
        pulumi.set(__self__, "graphite_user_id", graphite_user_id)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if influx_url and not isinstance(influx_url, str):
            raise TypeError("Expected argument 'influx_url' to be a str")
        pulumi.set(__self__, "influx_url", influx_url)
        if labels and not isinstance(labels, dict):
            raise TypeError("Expected argument 'labels' to be a dict")
        pulumi.set(__self__, "labels", labels)
        if logs_ip_allow_list_cname and not isinstance(logs_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'logs_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "logs_ip_allow_list_cname", logs_ip_allow_list_cname)
        if logs_name and not isinstance(logs_name, str):
            raise TypeError("Expected argument 'logs_name' to be a str")
        pulumi.set(__self__, "logs_name", logs_name)
        if logs_private_connectivity_info_private_dns and not isinstance(logs_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'logs_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "logs_private_connectivity_info_private_dns", logs_private_connectivity_info_private_dns)
        if logs_private_connectivity_info_service_name and not isinstance(logs_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'logs_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "logs_private_connectivity_info_service_name", logs_private_connectivity_info_service_name)
        if logs_status and not isinstance(logs_status, str):
            raise TypeError("Expected argument 'logs_status' to be a str")
        pulumi.set(__self__, "logs_status", logs_status)
        if logs_url and not isinstance(logs_url, str):
            raise TypeError("Expected argument 'logs_url' to be a str")
        pulumi.set(__self__, "logs_url", logs_url)
        if logs_user_id and not isinstance(logs_user_id, int):
            raise TypeError("Expected argument 'logs_user_id' to be a int")
        pulumi.set(__self__, "logs_user_id", logs_user_id)
        if name and not isinstance(name, str):
            raise TypeError("Expected argument 'name' to be a str")
        pulumi.set(__self__, "name", name)
        if org_id and not isinstance(org_id, int):
            raise TypeError("Expected argument 'org_id' to be a int")
        pulumi.set(__self__, "org_id", org_id)
        if org_name and not isinstance(org_name, str):
            raise TypeError("Expected argument 'org_name' to be a str")
        pulumi.set(__self__, "org_name", org_name)
        if org_slug and not isinstance(org_slug, str):
            raise TypeError("Expected argument 'org_slug' to be a str")
        pulumi.set(__self__, "org_slug", org_slug)
        if otlp_private_connectivity_info_private_dns and not isinstance(otlp_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'otlp_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "otlp_private_connectivity_info_private_dns", otlp_private_connectivity_info_private_dns)
        if otlp_private_connectivity_info_service_name and not isinstance(otlp_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'otlp_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "otlp_private_connectivity_info_service_name", otlp_private_connectivity_info_service_name)
        if otlp_url and not isinstance(otlp_url, str):
            raise TypeError("Expected argument 'otlp_url' to be a str")
        pulumi.set(__self__, "otlp_url", otlp_url)
        if pdc_api_private_connectivity_info_private_dns and not isinstance(pdc_api_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'pdc_api_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "pdc_api_private_connectivity_info_private_dns", pdc_api_private_connectivity_info_private_dns)
        if pdc_api_private_connectivity_info_service_name and not isinstance(pdc_api_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'pdc_api_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "pdc_api_private_connectivity_info_service_name", pdc_api_private_connectivity_info_service_name)
        if pdc_gateway_private_connectivity_info_private_dns and not isinstance(pdc_gateway_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'pdc_gateway_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "pdc_gateway_private_connectivity_info_private_dns", pdc_gateway_private_connectivity_info_private_dns)
        if pdc_gateway_private_connectivity_info_service_name and not isinstance(pdc_gateway_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'pdc_gateway_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "pdc_gateway_private_connectivity_info_service_name", pdc_gateway_private_connectivity_info_service_name)
        if profiles_ip_allow_list_cname and not isinstance(profiles_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'profiles_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "profiles_ip_allow_list_cname", profiles_ip_allow_list_cname)
        if profiles_name and not isinstance(profiles_name, str):
            raise TypeError("Expected argument 'profiles_name' to be a str")
        pulumi.set(__self__, "profiles_name", profiles_name)
        if profiles_private_connectivity_info_private_dns and not isinstance(profiles_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'profiles_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "profiles_private_connectivity_info_private_dns", profiles_private_connectivity_info_private_dns)
        if profiles_private_connectivity_info_service_name and not isinstance(profiles_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'profiles_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "profiles_private_connectivity_info_service_name", profiles_private_connectivity_info_service_name)
        if profiles_status and not isinstance(profiles_status, str):
            raise TypeError("Expected argument 'profiles_status' to be a str")
        pulumi.set(__self__, "profiles_status", profiles_status)
        if profiles_url and not isinstance(profiles_url, str):
            raise TypeError("Expected argument 'profiles_url' to be a str")
        pulumi.set(__self__, "profiles_url", profiles_url)
        if profiles_user_id and not isinstance(profiles_user_id, int):
            raise TypeError("Expected argument 'profiles_user_id' to be a int")
        pulumi.set(__self__, "profiles_user_id", profiles_user_id)
        if prometheus_ip_allow_list_cname and not isinstance(prometheus_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'prometheus_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "prometheus_ip_allow_list_cname", prometheus_ip_allow_list_cname)
        if prometheus_name and not isinstance(prometheus_name, str):
            raise TypeError("Expected argument 'prometheus_name' to be a str")
        pulumi.set(__self__, "prometheus_name", prometheus_name)
        if prometheus_private_connectivity_info_private_dns and not isinstance(prometheus_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'prometheus_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "prometheus_private_connectivity_info_private_dns", prometheus_private_connectivity_info_private_dns)
        if prometheus_private_connectivity_info_service_name and not isinstance(prometheus_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'prometheus_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "prometheus_private_connectivity_info_service_name", prometheus_private_connectivity_info_service_name)
        if prometheus_remote_endpoint and not isinstance(prometheus_remote_endpoint, str):
            raise TypeError("Expected argument 'prometheus_remote_endpoint' to be a str")
        pulumi.set(__self__, "prometheus_remote_endpoint", prometheus_remote_endpoint)
        if prometheus_remote_write_endpoint and not isinstance(prometheus_remote_write_endpoint, str):
            raise TypeError("Expected argument 'prometheus_remote_write_endpoint' to be a str")
        pulumi.set(__self__, "prometheus_remote_write_endpoint", prometheus_remote_write_endpoint)
        if prometheus_status and not isinstance(prometheus_status, str):
            raise TypeError("Expected argument 'prometheus_status' to be a str")
        pulumi.set(__self__, "prometheus_status", prometheus_status)
        if prometheus_url and not isinstance(prometheus_url, str):
            raise TypeError("Expected argument 'prometheus_url' to be a str")
        pulumi.set(__self__, "prometheus_url", prometheus_url)
        if prometheus_user_id and not isinstance(prometheus_user_id, int):
            raise TypeError("Expected argument 'prometheus_user_id' to be a int")
        pulumi.set(__self__, "prometheus_user_id", prometheus_user_id)
        if region_slug and not isinstance(region_slug, str):
            raise TypeError("Expected argument 'region_slug' to be a str")
        pulumi.set(__self__, "region_slug", region_slug)
        if slug and not isinstance(slug, str):
            raise TypeError("Expected argument 'slug' to be a str")
        pulumi.set(__self__, "slug", slug)
        if status and not isinstance(status, str):
            raise TypeError("Expected argument 'status' to be a str")
        pulumi.set(__self__, "status", status)
        if traces_ip_allow_list_cname and not isinstance(traces_ip_allow_list_cname, str):
            raise TypeError("Expected argument 'traces_ip_allow_list_cname' to be a str")
        pulumi.set(__self__, "traces_ip_allow_list_cname", traces_ip_allow_list_cname)
        if traces_name and not isinstance(traces_name, str):
            raise TypeError("Expected argument 'traces_name' to be a str")
        pulumi.set(__self__, "traces_name", traces_name)
        if traces_private_connectivity_info_private_dns and not isinstance(traces_private_connectivity_info_private_dns, str):
            raise TypeError("Expected argument 'traces_private_connectivity_info_private_dns' to be a str")
        pulumi.set(__self__, "traces_private_connectivity_info_private_dns", traces_private_connectivity_info_private_dns)
        if traces_private_connectivity_info_service_name and not isinstance(traces_private_connectivity_info_service_name, str):
            raise TypeError("Expected argument 'traces_private_connectivity_info_service_name' to be a str")
        pulumi.set(__self__, "traces_private_connectivity_info_service_name", traces_private_connectivity_info_service_name)
        if traces_status and not isinstance(traces_status, str):
            raise TypeError("Expected argument 'traces_status' to be a str")
        pulumi.set(__self__, "traces_status", traces_status)
        if traces_url and not isinstance(traces_url, str):
            raise TypeError("Expected argument 'traces_url' to be a str")
        pulumi.set(__self__, "traces_url", traces_url)
        if traces_user_id and not isinstance(traces_user_id, int):
            raise TypeError("Expected argument 'traces_user_id' to be a int")
        pulumi.set(__self__, "traces_user_id", traces_user_id)
        if url and not isinstance(url, str):
            raise TypeError("Expected argument 'url' to be a str")
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter(name="alertmanagerIpAllowListCname")
    def alertmanager_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the Alertmanager instances (Optional)
        """
        return pulumi.get(self, "alertmanager_ip_allow_list_cname")

    @property
    @pulumi.getter(name="alertmanagerName")
    def alertmanager_name(self) -> str:
        """
        Name of the Alertmanager instance configured for this stack.
        """
        return pulumi.get(self, "alertmanager_name")

    @property
    @pulumi.getter(name="alertmanagerStatus")
    def alertmanager_status(self) -> str:
        """
        Status of the Alertmanager instance configured for this stack.
        """
        return pulumi.get(self, "alertmanager_status")

    @property
    @pulumi.getter(name="alertmanagerUrl")
    def alertmanager_url(self) -> str:
        """
        Base URL of the Alertmanager instance configured for this stack.
        """
        return pulumi.get(self, "alertmanager_url")

    @property
    @pulumi.getter(name="alertmanagerUserId")
    def alertmanager_user_id(self) -> int:
        """
        User ID of the Alertmanager instance configured for this stack.
        """
        return pulumi.get(self, "alertmanager_user_id")

    @property
    @pulumi.getter(name="clusterSlug")
    def cluster_slug(self) -> str:
        """
        Slug of the cluster where this stack resides.
        """
        return pulumi.get(self, "cluster_slug")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of stack.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="fleetManagementName")
    def fleet_management_name(self) -> str:
        """
        Name of the Fleet Management instance configured for this stack.
        """
        return pulumi.get(self, "fleet_management_name")

    @property
    @pulumi.getter(name="fleetManagementStatus")
    def fleet_management_status(self) -> str:
        """
        Status of the Fleet Management instance configured for this stack.
        """
        return pulumi.get(self, "fleet_management_status")

    @property
    @pulumi.getter(name="fleetManagementUrl")
    def fleet_management_url(self) -> str:
        """
        Base URL of the Fleet Management instance configured for this stack.
        """
        return pulumi.get(self, "fleet_management_url")

    @property
    @pulumi.getter(name="fleetManagementUserId")
    def fleet_management_user_id(self) -> int:
        """
        User ID of the Fleet Management instance configured for this stack.
        """
        return pulumi.get(self, "fleet_management_user_id")

    @property
    @pulumi.getter(name="grafanasIpAllowListCname")
    def grafanas_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the grafana instance (Optional)
        """
        return pulumi.get(self, "grafanas_ip_allow_list_cname")

    @property
    @pulumi.getter(name="graphiteIpAllowListCname")
    def graphite_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the Graphite instance (Optional)
        """
        return pulumi.get(self, "graphite_ip_allow_list_cname")

    @property
    @pulumi.getter(name="graphiteName")
    def graphite_name(self) -> str:
        return pulumi.get(self, "graphite_name")

    @property
    @pulumi.getter(name="graphitePrivateConnectivityInfoPrivateDns")
    def graphite_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for Graphite when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "graphite_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="graphitePrivateConnectivityInfoServiceName")
    def graphite_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for Graphite when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "graphite_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="graphiteStatus")
    def graphite_status(self) -> str:
        return pulumi.get(self, "graphite_status")

    @property
    @pulumi.getter(name="graphiteUrl")
    def graphite_url(self) -> str:
        return pulumi.get(self, "graphite_url")

    @property
    @pulumi.getter(name="graphiteUserId")
    def graphite_user_id(self) -> int:
        return pulumi.get(self, "graphite_user_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The stack id assigned to this stack by Grafana.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="influxUrl")
    def influx_url(self) -> str:
        """
        Base URL of the InfluxDB instance configured for this stack. The username is the same as the metrics' (`prometheus_user_id` attribute of this resource). See https://grafana.com/docs/grafana-cloud/send-data/metrics/metrics-influxdb/push-from-telegraf/ for docs on how to use this.
        """
        return pulumi.get(self, "influx_url")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, str]:
        """
        A map of labels to assign to the stack. Label keys and values must match the following regexp: "^[a-zA-Z0-9/\\-.]+$" and stacks cannot have more than 10 labels.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="logsIpAllowListCname")
    def logs_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the Logs instance (Optional)
        """
        return pulumi.get(self, "logs_ip_allow_list_cname")

    @property
    @pulumi.getter(name="logsName")
    def logs_name(self) -> str:
        return pulumi.get(self, "logs_name")

    @property
    @pulumi.getter(name="logsPrivateConnectivityInfoPrivateDns")
    def logs_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for Logs when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "logs_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="logsPrivateConnectivityInfoServiceName")
    def logs_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for Logs when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "logs_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="logsStatus")
    def logs_status(self) -> str:
        return pulumi.get(self, "logs_status")

    @property
    @pulumi.getter(name="logsUrl")
    def logs_url(self) -> str:
        return pulumi.get(self, "logs_url")

    @property
    @pulumi.getter(name="logsUserId")
    def logs_user_id(self) -> int:
        return pulumi.get(self, "logs_user_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of stack. Conventionally matches the url of the instance (e.g. `<stack_slug>.grafana.net`).
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="orgId")
    def org_id(self) -> int:
        """
        Organization id to assign to this stack.
        """
        return pulumi.get(self, "org_id")

    @property
    @pulumi.getter(name="orgName")
    def org_name(self) -> str:
        """
        Organization name to assign to this stack.
        """
        return pulumi.get(self, "org_name")

    @property
    @pulumi.getter(name="orgSlug")
    def org_slug(self) -> str:
        """
        Organization slug to assign to this stack.
        """
        return pulumi.get(self, "org_slug")

    @property
    @pulumi.getter(name="otlpPrivateConnectivityInfoPrivateDns")
    def otlp_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for OTLP when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "otlp_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="otlpPrivateConnectivityInfoServiceName")
    def otlp_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for OTLP when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "otlp_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="otlpUrl")
    def otlp_url(self) -> str:
        """
        Base URL of the OTLP instance configured for this stack. The username is the stack's ID (`id` attribute of this resource). See https://grafana.com/docs/grafana-cloud/send-data/otlp/send-data-otlp/ for docs on how to use this.
        """
        return pulumi.get(self, "otlp_url")

    @property
    @pulumi.getter(name="pdcApiPrivateConnectivityInfoPrivateDns")
    def pdc_api_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for PDC's API when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "pdc_api_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="pdcApiPrivateConnectivityInfoServiceName")
    def pdc_api_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for PDC's API when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "pdc_api_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="pdcGatewayPrivateConnectivityInfoPrivateDns")
    def pdc_gateway_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for PDC's Gateway when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "pdc_gateway_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="pdcGatewayPrivateConnectivityInfoServiceName")
    def pdc_gateway_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for PDC's Gateway when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "pdc_gateway_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="profilesIpAllowListCname")
    def profiles_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the Profiles instance (Optional)
        """
        return pulumi.get(self, "profiles_ip_allow_list_cname")

    @property
    @pulumi.getter(name="profilesName")
    def profiles_name(self) -> str:
        return pulumi.get(self, "profiles_name")

    @property
    @pulumi.getter(name="profilesPrivateConnectivityInfoPrivateDns")
    def profiles_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for Profiles when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "profiles_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="profilesPrivateConnectivityInfoServiceName")
    def profiles_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for Profiles when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "profiles_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="profilesStatus")
    def profiles_status(self) -> str:
        return pulumi.get(self, "profiles_status")

    @property
    @pulumi.getter(name="profilesUrl")
    def profiles_url(self) -> str:
        return pulumi.get(self, "profiles_url")

    @property
    @pulumi.getter(name="profilesUserId")
    def profiles_user_id(self) -> int:
        return pulumi.get(self, "profiles_user_id")

    @property
    @pulumi.getter(name="prometheusIpAllowListCname")
    def prometheus_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the Prometheus instance (Optional)
        """
        return pulumi.get(self, "prometheus_ip_allow_list_cname")

    @property
    @pulumi.getter(name="prometheusName")
    def prometheus_name(self) -> str:
        """
        Prometheus name for this instance.
        """
        return pulumi.get(self, "prometheus_name")

    @property
    @pulumi.getter(name="prometheusPrivateConnectivityInfoPrivateDns")
    def prometheus_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for Prometheus when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "prometheus_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="prometheusPrivateConnectivityInfoServiceName")
    def prometheus_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for Prometheus when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "prometheus_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="prometheusRemoteEndpoint")
    def prometheus_remote_endpoint(self) -> str:
        """
        Use this URL to query hosted metrics data e.g. Prometheus data source in Grafana
        """
        return pulumi.get(self, "prometheus_remote_endpoint")

    @property
    @pulumi.getter(name="prometheusRemoteWriteEndpoint")
    def prometheus_remote_write_endpoint(self) -> str:
        """
        Use this URL to send prometheus metrics to Grafana cloud
        """
        return pulumi.get(self, "prometheus_remote_write_endpoint")

    @property
    @pulumi.getter(name="prometheusStatus")
    def prometheus_status(self) -> str:
        """
        Prometheus status for this instance.
        """
        return pulumi.get(self, "prometheus_status")

    @property
    @pulumi.getter(name="prometheusUrl")
    def prometheus_url(self) -> str:
        """
        Prometheus url for this instance.
        """
        return pulumi.get(self, "prometheus_url")

    @property
    @pulumi.getter(name="prometheusUserId")
    def prometheus_user_id(self) -> int:
        """
        Prometheus user ID. Used for e.g. remote_write.
        """
        return pulumi.get(self, "prometheus_user_id")

    @property
    @pulumi.getter(name="regionSlug")
    def region_slug(self) -> str:
        """
        The region this stack is deployed to.
        """
        return pulumi.get(self, "region_slug")

    @property
    @pulumi.getter
    def slug(self) -> str:
        """
        Subdomain that the Grafana instance will be available at (i.e. setting slug to “\\n\\n” will make the instance
        available at “https://\\n\\n.grafana.net".
        """
        return pulumi.get(self, "slug")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Status of the stack.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tracesIpAllowListCname")
    def traces_ip_allow_list_cname(self) -> str:
        """
        Comma-separated list of CNAMEs that can be whitelisted to access the Traces instance (Optional)
        """
        return pulumi.get(self, "traces_ip_allow_list_cname")

    @property
    @pulumi.getter(name="tracesName")
    def traces_name(self) -> str:
        return pulumi.get(self, "traces_name")

    @property
    @pulumi.getter(name="tracesPrivateConnectivityInfoPrivateDns")
    def traces_private_connectivity_info_private_dns(self) -> str:
        """
        Private DNS for Traces when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "traces_private_connectivity_info_private_dns")

    @property
    @pulumi.getter(name="tracesPrivateConnectivityInfoServiceName")
    def traces_private_connectivity_info_service_name(self) -> str:
        """
        Service Name for Traces when using AWS PrivateLink (only for AWS stacks)
        """
        return pulumi.get(self, "traces_private_connectivity_info_service_name")

    @property
    @pulumi.getter(name="tracesStatus")
    def traces_status(self) -> str:
        return pulumi.get(self, "traces_status")

    @property
    @pulumi.getter(name="tracesUrl")
    def traces_url(self) -> str:
        """
        Base URL of the Traces instance configured for this stack. To use this in the Tempo data source in Grafana, append `/tempo` to the URL.
        """
        return pulumi.get(self, "traces_url")

    @property
    @pulumi.getter(name="tracesUserId")
    def traces_user_id(self) -> int:
        return pulumi.get(self, "traces_user_id")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Custom URL for the Grafana instance. Must have a CNAME setup to point to `.grafana.net` before creating the stack
        """
        return pulumi.get(self, "url")


class AwaitableGetStackResult(GetStackResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetStackResult(
            alertmanager_ip_allow_list_cname=self.alertmanager_ip_allow_list_cname,
            alertmanager_name=self.alertmanager_name,
            alertmanager_status=self.alertmanager_status,
            alertmanager_url=self.alertmanager_url,
            alertmanager_user_id=self.alertmanager_user_id,
            cluster_slug=self.cluster_slug,
            description=self.description,
            fleet_management_name=self.fleet_management_name,
            fleet_management_status=self.fleet_management_status,
            fleet_management_url=self.fleet_management_url,
            fleet_management_user_id=self.fleet_management_user_id,
            grafanas_ip_allow_list_cname=self.grafanas_ip_allow_list_cname,
            graphite_ip_allow_list_cname=self.graphite_ip_allow_list_cname,
            graphite_name=self.graphite_name,
            graphite_private_connectivity_info_private_dns=self.graphite_private_connectivity_info_private_dns,
            graphite_private_connectivity_info_service_name=self.graphite_private_connectivity_info_service_name,
            graphite_status=self.graphite_status,
            graphite_url=self.graphite_url,
            graphite_user_id=self.graphite_user_id,
            id=self.id,
            influx_url=self.influx_url,
            labels=self.labels,
            logs_ip_allow_list_cname=self.logs_ip_allow_list_cname,
            logs_name=self.logs_name,
            logs_private_connectivity_info_private_dns=self.logs_private_connectivity_info_private_dns,
            logs_private_connectivity_info_service_name=self.logs_private_connectivity_info_service_name,
            logs_status=self.logs_status,
            logs_url=self.logs_url,
            logs_user_id=self.logs_user_id,
            name=self.name,
            org_id=self.org_id,
            org_name=self.org_name,
            org_slug=self.org_slug,
            otlp_private_connectivity_info_private_dns=self.otlp_private_connectivity_info_private_dns,
            otlp_private_connectivity_info_service_name=self.otlp_private_connectivity_info_service_name,
            otlp_url=self.otlp_url,
            pdc_api_private_connectivity_info_private_dns=self.pdc_api_private_connectivity_info_private_dns,
            pdc_api_private_connectivity_info_service_name=self.pdc_api_private_connectivity_info_service_name,
            pdc_gateway_private_connectivity_info_private_dns=self.pdc_gateway_private_connectivity_info_private_dns,
            pdc_gateway_private_connectivity_info_service_name=self.pdc_gateway_private_connectivity_info_service_name,
            profiles_ip_allow_list_cname=self.profiles_ip_allow_list_cname,
            profiles_name=self.profiles_name,
            profiles_private_connectivity_info_private_dns=self.profiles_private_connectivity_info_private_dns,
            profiles_private_connectivity_info_service_name=self.profiles_private_connectivity_info_service_name,
            profiles_status=self.profiles_status,
            profiles_url=self.profiles_url,
            profiles_user_id=self.profiles_user_id,
            prometheus_ip_allow_list_cname=self.prometheus_ip_allow_list_cname,
            prometheus_name=self.prometheus_name,
            prometheus_private_connectivity_info_private_dns=self.prometheus_private_connectivity_info_private_dns,
            prometheus_private_connectivity_info_service_name=self.prometheus_private_connectivity_info_service_name,
            prometheus_remote_endpoint=self.prometheus_remote_endpoint,
            prometheus_remote_write_endpoint=self.prometheus_remote_write_endpoint,
            prometheus_status=self.prometheus_status,
            prometheus_url=self.prometheus_url,
            prometheus_user_id=self.prometheus_user_id,
            region_slug=self.region_slug,
            slug=self.slug,
            status=self.status,
            traces_ip_allow_list_cname=self.traces_ip_allow_list_cname,
            traces_name=self.traces_name,
            traces_private_connectivity_info_private_dns=self.traces_private_connectivity_info_private_dns,
            traces_private_connectivity_info_service_name=self.traces_private_connectivity_info_service_name,
            traces_status=self.traces_status,
            traces_url=self.traces_url,
            traces_user_id=self.traces_user_id,
            url=self.url)


def get_stack(slug: Optional[str] = None,
              opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStackResult:
    """
    Data source for Grafana Stack

    ## Example Usage

    ```python
    import pulumi
    import pulumi_grafana as grafana
    import pulumiverse_grafana as grafana

    test_stack = grafana.cloud.Stack("test",
        name="gcloudstacktest",
        slug="gcloudstacktest",
        region_slug="eu",
        description="Test Grafana Cloud Stack")
    test = grafana.cloud.get_stack_output(slug=test_stack.slug)
    ```


    :param str slug: Subdomain that the Grafana instance will be available at (i.e. setting slug to “\\n\\n” will make the instance
           available at “https://\\n\\n.grafana.net".
    """
    __args__ = dict()
    __args__['slug'] = slug
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('grafana:cloud/getStack:getStack', __args__, opts=opts, typ=GetStackResult).value

    return AwaitableGetStackResult(
        alertmanager_ip_allow_list_cname=pulumi.get(__ret__, 'alertmanager_ip_allow_list_cname'),
        alertmanager_name=pulumi.get(__ret__, 'alertmanager_name'),
        alertmanager_status=pulumi.get(__ret__, 'alertmanager_status'),
        alertmanager_url=pulumi.get(__ret__, 'alertmanager_url'),
        alertmanager_user_id=pulumi.get(__ret__, 'alertmanager_user_id'),
        cluster_slug=pulumi.get(__ret__, 'cluster_slug'),
        description=pulumi.get(__ret__, 'description'),
        fleet_management_name=pulumi.get(__ret__, 'fleet_management_name'),
        fleet_management_status=pulumi.get(__ret__, 'fleet_management_status'),
        fleet_management_url=pulumi.get(__ret__, 'fleet_management_url'),
        fleet_management_user_id=pulumi.get(__ret__, 'fleet_management_user_id'),
        grafanas_ip_allow_list_cname=pulumi.get(__ret__, 'grafanas_ip_allow_list_cname'),
        graphite_ip_allow_list_cname=pulumi.get(__ret__, 'graphite_ip_allow_list_cname'),
        graphite_name=pulumi.get(__ret__, 'graphite_name'),
        graphite_private_connectivity_info_private_dns=pulumi.get(__ret__, 'graphite_private_connectivity_info_private_dns'),
        graphite_private_connectivity_info_service_name=pulumi.get(__ret__, 'graphite_private_connectivity_info_service_name'),
        graphite_status=pulumi.get(__ret__, 'graphite_status'),
        graphite_url=pulumi.get(__ret__, 'graphite_url'),
        graphite_user_id=pulumi.get(__ret__, 'graphite_user_id'),
        id=pulumi.get(__ret__, 'id'),
        influx_url=pulumi.get(__ret__, 'influx_url'),
        labels=pulumi.get(__ret__, 'labels'),
        logs_ip_allow_list_cname=pulumi.get(__ret__, 'logs_ip_allow_list_cname'),
        logs_name=pulumi.get(__ret__, 'logs_name'),
        logs_private_connectivity_info_private_dns=pulumi.get(__ret__, 'logs_private_connectivity_info_private_dns'),
        logs_private_connectivity_info_service_name=pulumi.get(__ret__, 'logs_private_connectivity_info_service_name'),
        logs_status=pulumi.get(__ret__, 'logs_status'),
        logs_url=pulumi.get(__ret__, 'logs_url'),
        logs_user_id=pulumi.get(__ret__, 'logs_user_id'),
        name=pulumi.get(__ret__, 'name'),
        org_id=pulumi.get(__ret__, 'org_id'),
        org_name=pulumi.get(__ret__, 'org_name'),
        org_slug=pulumi.get(__ret__, 'org_slug'),
        otlp_private_connectivity_info_private_dns=pulumi.get(__ret__, 'otlp_private_connectivity_info_private_dns'),
        otlp_private_connectivity_info_service_name=pulumi.get(__ret__, 'otlp_private_connectivity_info_service_name'),
        otlp_url=pulumi.get(__ret__, 'otlp_url'),
        pdc_api_private_connectivity_info_private_dns=pulumi.get(__ret__, 'pdc_api_private_connectivity_info_private_dns'),
        pdc_api_private_connectivity_info_service_name=pulumi.get(__ret__, 'pdc_api_private_connectivity_info_service_name'),
        pdc_gateway_private_connectivity_info_private_dns=pulumi.get(__ret__, 'pdc_gateway_private_connectivity_info_private_dns'),
        pdc_gateway_private_connectivity_info_service_name=pulumi.get(__ret__, 'pdc_gateway_private_connectivity_info_service_name'),
        profiles_ip_allow_list_cname=pulumi.get(__ret__, 'profiles_ip_allow_list_cname'),
        profiles_name=pulumi.get(__ret__, 'profiles_name'),
        profiles_private_connectivity_info_private_dns=pulumi.get(__ret__, 'profiles_private_connectivity_info_private_dns'),
        profiles_private_connectivity_info_service_name=pulumi.get(__ret__, 'profiles_private_connectivity_info_service_name'),
        profiles_status=pulumi.get(__ret__, 'profiles_status'),
        profiles_url=pulumi.get(__ret__, 'profiles_url'),
        profiles_user_id=pulumi.get(__ret__, 'profiles_user_id'),
        prometheus_ip_allow_list_cname=pulumi.get(__ret__, 'prometheus_ip_allow_list_cname'),
        prometheus_name=pulumi.get(__ret__, 'prometheus_name'),
        prometheus_private_connectivity_info_private_dns=pulumi.get(__ret__, 'prometheus_private_connectivity_info_private_dns'),
        prometheus_private_connectivity_info_service_name=pulumi.get(__ret__, 'prometheus_private_connectivity_info_service_name'),
        prometheus_remote_endpoint=pulumi.get(__ret__, 'prometheus_remote_endpoint'),
        prometheus_remote_write_endpoint=pulumi.get(__ret__, 'prometheus_remote_write_endpoint'),
        prometheus_status=pulumi.get(__ret__, 'prometheus_status'),
        prometheus_url=pulumi.get(__ret__, 'prometheus_url'),
        prometheus_user_id=pulumi.get(__ret__, 'prometheus_user_id'),
        region_slug=pulumi.get(__ret__, 'region_slug'),
        slug=pulumi.get(__ret__, 'slug'),
        status=pulumi.get(__ret__, 'status'),
        traces_ip_allow_list_cname=pulumi.get(__ret__, 'traces_ip_allow_list_cname'),
        traces_name=pulumi.get(__ret__, 'traces_name'),
        traces_private_connectivity_info_private_dns=pulumi.get(__ret__, 'traces_private_connectivity_info_private_dns'),
        traces_private_connectivity_info_service_name=pulumi.get(__ret__, 'traces_private_connectivity_info_service_name'),
        traces_status=pulumi.get(__ret__, 'traces_status'),
        traces_url=pulumi.get(__ret__, 'traces_url'),
        traces_user_id=pulumi.get(__ret__, 'traces_user_id'),
        url=pulumi.get(__ret__, 'url'))
def get_stack_output(slug: Optional[pulumi.Input[str]] = None,
                     opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStackResult]:
    """
    Data source for Grafana Stack

    ## Example Usage

    ```python
    import pulumi
    import pulumi_grafana as grafana
    import pulumiverse_grafana as grafana

    test_stack = grafana.cloud.Stack("test",
        name="gcloudstacktest",
        slug="gcloudstacktest",
        region_slug="eu",
        description="Test Grafana Cloud Stack")
    test = grafana.cloud.get_stack_output(slug=test_stack.slug)
    ```


    :param str slug: Subdomain that the Grafana instance will be available at (i.e. setting slug to “\\n\\n” will make the instance
           available at “https://\\n\\n.grafana.net".
    """
    __args__ = dict()
    __args__['slug'] = slug
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('grafana:cloud/getStack:getStack', __args__, opts=opts, typ=GetStackResult)
    return __ret__.apply(lambda __response__: GetStackResult(
        alertmanager_ip_allow_list_cname=pulumi.get(__response__, 'alertmanager_ip_allow_list_cname'),
        alertmanager_name=pulumi.get(__response__, 'alertmanager_name'),
        alertmanager_status=pulumi.get(__response__, 'alertmanager_status'),
        alertmanager_url=pulumi.get(__response__, 'alertmanager_url'),
        alertmanager_user_id=pulumi.get(__response__, 'alertmanager_user_id'),
        cluster_slug=pulumi.get(__response__, 'cluster_slug'),
        description=pulumi.get(__response__, 'description'),
        fleet_management_name=pulumi.get(__response__, 'fleet_management_name'),
        fleet_management_status=pulumi.get(__response__, 'fleet_management_status'),
        fleet_management_url=pulumi.get(__response__, 'fleet_management_url'),
        fleet_management_user_id=pulumi.get(__response__, 'fleet_management_user_id'),
        grafanas_ip_allow_list_cname=pulumi.get(__response__, 'grafanas_ip_allow_list_cname'),
        graphite_ip_allow_list_cname=pulumi.get(__response__, 'graphite_ip_allow_list_cname'),
        graphite_name=pulumi.get(__response__, 'graphite_name'),
        graphite_private_connectivity_info_private_dns=pulumi.get(__response__, 'graphite_private_connectivity_info_private_dns'),
        graphite_private_connectivity_info_service_name=pulumi.get(__response__, 'graphite_private_connectivity_info_service_name'),
        graphite_status=pulumi.get(__response__, 'graphite_status'),
        graphite_url=pulumi.get(__response__, 'graphite_url'),
        graphite_user_id=pulumi.get(__response__, 'graphite_user_id'),
        id=pulumi.get(__response__, 'id'),
        influx_url=pulumi.get(__response__, 'influx_url'),
        labels=pulumi.get(__response__, 'labels'),
        logs_ip_allow_list_cname=pulumi.get(__response__, 'logs_ip_allow_list_cname'),
        logs_name=pulumi.get(__response__, 'logs_name'),
        logs_private_connectivity_info_private_dns=pulumi.get(__response__, 'logs_private_connectivity_info_private_dns'),
        logs_private_connectivity_info_service_name=pulumi.get(__response__, 'logs_private_connectivity_info_service_name'),
        logs_status=pulumi.get(__response__, 'logs_status'),
        logs_url=pulumi.get(__response__, 'logs_url'),
        logs_user_id=pulumi.get(__response__, 'logs_user_id'),
        name=pulumi.get(__response__, 'name'),
        org_id=pulumi.get(__response__, 'org_id'),
        org_name=pulumi.get(__response__, 'org_name'),
        org_slug=pulumi.get(__response__, 'org_slug'),
        otlp_private_connectivity_info_private_dns=pulumi.get(__response__, 'otlp_private_connectivity_info_private_dns'),
        otlp_private_connectivity_info_service_name=pulumi.get(__response__, 'otlp_private_connectivity_info_service_name'),
        otlp_url=pulumi.get(__response__, 'otlp_url'),
        pdc_api_private_connectivity_info_private_dns=pulumi.get(__response__, 'pdc_api_private_connectivity_info_private_dns'),
        pdc_api_private_connectivity_info_service_name=pulumi.get(__response__, 'pdc_api_private_connectivity_info_service_name'),
        pdc_gateway_private_connectivity_info_private_dns=pulumi.get(__response__, 'pdc_gateway_private_connectivity_info_private_dns'),
        pdc_gateway_private_connectivity_info_service_name=pulumi.get(__response__, 'pdc_gateway_private_connectivity_info_service_name'),
        profiles_ip_allow_list_cname=pulumi.get(__response__, 'profiles_ip_allow_list_cname'),
        profiles_name=pulumi.get(__response__, 'profiles_name'),
        profiles_private_connectivity_info_private_dns=pulumi.get(__response__, 'profiles_private_connectivity_info_private_dns'),
        profiles_private_connectivity_info_service_name=pulumi.get(__response__, 'profiles_private_connectivity_info_service_name'),
        profiles_status=pulumi.get(__response__, 'profiles_status'),
        profiles_url=pulumi.get(__response__, 'profiles_url'),
        profiles_user_id=pulumi.get(__response__, 'profiles_user_id'),
        prometheus_ip_allow_list_cname=pulumi.get(__response__, 'prometheus_ip_allow_list_cname'),
        prometheus_name=pulumi.get(__response__, 'prometheus_name'),
        prometheus_private_connectivity_info_private_dns=pulumi.get(__response__, 'prometheus_private_connectivity_info_private_dns'),
        prometheus_private_connectivity_info_service_name=pulumi.get(__response__, 'prometheus_private_connectivity_info_service_name'),
        prometheus_remote_endpoint=pulumi.get(__response__, 'prometheus_remote_endpoint'),
        prometheus_remote_write_endpoint=pulumi.get(__response__, 'prometheus_remote_write_endpoint'),
        prometheus_status=pulumi.get(__response__, 'prometheus_status'),
        prometheus_url=pulumi.get(__response__, 'prometheus_url'),
        prometheus_user_id=pulumi.get(__response__, 'prometheus_user_id'),
        region_slug=pulumi.get(__response__, 'region_slug'),
        slug=pulumi.get(__response__, 'slug'),
        status=pulumi.get(__response__, 'status'),
        traces_ip_allow_list_cname=pulumi.get(__response__, 'traces_ip_allow_list_cname'),
        traces_name=pulumi.get(__response__, 'traces_name'),
        traces_private_connectivity_info_private_dns=pulumi.get(__response__, 'traces_private_connectivity_info_private_dns'),
        traces_private_connectivity_info_service_name=pulumi.get(__response__, 'traces_private_connectivity_info_service_name'),
        traces_status=pulumi.get(__response__, 'traces_status'),
        traces_url=pulumi.get(__response__, 'traces_url'),
        traces_user_id=pulumi.get(__response__, 'traces_user_id'),
        url=pulumi.get(__response__, 'url')))
