# 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 pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs

__all__ = [
    'AlertChannelConfig',
    'AlertConditionTerm',
    'AlertMutingRuleCondition',
    'AlertMutingRuleConditionCondition',
    'AlertMutingRuleSchedule',
    'EntityTagsTag',
    'InfraAlertConditionCritical',
    'InfraAlertConditionWarning',
    'NotificationChannelProperty',
    'NotificationDestinationAuthBasic',
    'NotificationDestinationAuthToken',
    'NotificationDestinationProperty',
    'NrqlAlertConditionCritical',
    'NrqlAlertConditionNrql',
    'NrqlAlertConditionTerm',
    'NrqlAlertConditionWarning',
    'OneDashboardPage',
    'OneDashboardPageWidgetArea',
    'OneDashboardPageWidgetAreaNrqlQuery',
    'OneDashboardPageWidgetBar',
    'OneDashboardPageWidgetBarNrqlQuery',
    'OneDashboardPageWidgetBillboard',
    'OneDashboardPageWidgetBillboardNrqlQuery',
    'OneDashboardPageWidgetBullet',
    'OneDashboardPageWidgetBulletNrqlQuery',
    'OneDashboardPageWidgetFunnel',
    'OneDashboardPageWidgetFunnelNrqlQuery',
    'OneDashboardPageWidgetHeatmap',
    'OneDashboardPageWidgetHeatmapNrqlQuery',
    'OneDashboardPageWidgetHistogram',
    'OneDashboardPageWidgetHistogramNrqlQuery',
    'OneDashboardPageWidgetJson',
    'OneDashboardPageWidgetJsonNrqlQuery',
    'OneDashboardPageWidgetLine',
    'OneDashboardPageWidgetLineNrqlQuery',
    'OneDashboardPageWidgetLogTable',
    'OneDashboardPageWidgetLogTableNrqlQuery',
    'OneDashboardPageWidgetMarkdown',
    'OneDashboardPageWidgetPy',
    'OneDashboardPageWidgetPyNrqlQuery',
    'OneDashboardPageWidgetStackedBar',
    'OneDashboardPageWidgetStackedBarNrqlQuery',
    'OneDashboardPageWidgetTable',
    'OneDashboardPageWidgetTableNrqlQuery',
    'OneDashboardRawPage',
    'OneDashboardRawPageWidget',
    'ServiceLevelEvents',
    'ServiceLevelEventsBadEvents',
    'ServiceLevelEventsGoodEvents',
    'ServiceLevelEventsValidEvents',
    'ServiceLevelObjective',
    'ServiceLevelObjectiveTimeWindow',
    'ServiceLevelObjectiveTimeWindowRolling',
    'WorkflowDestinationConfiguration',
    'WorkflowEnrichments',
    'WorkflowEnrichmentsNrql',
    'WorkflowEnrichmentsNrqlConfiguration',
    'WorkflowIssuesFilter',
    'WorkflowIssuesFilterPredicate',
    'GetAlertChannelConfigResult',
    'GetEntityTagResult',
]

@pulumi.output_type
class AlertChannelConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiKey":
            suggest = "api_key"
        elif key == "authPassword":
            suggest = "auth_password"
        elif key == "authType":
            suggest = "auth_type"
        elif key == "authUsername":
            suggest = "auth_username"
        elif key == "baseUrl":
            suggest = "base_url"
        elif key == "headersString":
            suggest = "headers_string"
        elif key == "includeJsonAttachment":
            suggest = "include_json_attachment"
        elif key == "payloadString":
            suggest = "payload_string"
        elif key == "payloadType":
            suggest = "payload_type"
        elif key == "routeKey":
            suggest = "route_key"
        elif key == "serviceKey":
            suggest = "service_key"
        elif key == "userId":
            suggest = "user_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AlertChannelConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AlertChannelConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AlertChannelConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_key: Optional[str] = None,
                 auth_password: Optional[str] = None,
                 auth_type: Optional[str] = None,
                 auth_username: Optional[str] = None,
                 base_url: Optional[str] = None,
                 channel: Optional[str] = None,
                 headers: Optional[Mapping[str, str]] = None,
                 headers_string: Optional[str] = None,
                 include_json_attachment: Optional[str] = None,
                 key: Optional[str] = None,
                 payload: Optional[Mapping[str, str]] = None,
                 payload_string: Optional[str] = None,
                 payload_type: Optional[str] = None,
                 recipients: Optional[str] = None,
                 region: Optional[str] = None,
                 route_key: Optional[str] = None,
                 service_key: Optional[str] = None,
                 tags: Optional[str] = None,
                 teams: Optional[str] = None,
                 url: Optional[str] = None,
                 user_id: Optional[str] = None):
        """
        :param str api_key: The API key for integrating with OpsGenie.
        :param str auth_password: Specifies an authentication password for use with a channel.  Supported by the `webhook` channel type.
        :param str auth_type: Specifies an authentication method for use with a channel.  Supported by the `webhook` channel type.  Only HTTP basic authentication is currently supported via the value `BASIC`.
        :param str auth_username: Specifies an authentication username for use with a channel.  Supported by the `webhook` channel type.
        :param str base_url: The base URL of the webhook destination.
        :param str channel: The Slack channel to send notifications to.
               * `opsgenie`
        :param Mapping[str, str] headers: A map of key/value pairs that represents extra HTTP headers to be sent along with the webhook payload.
        :param str headers_string: Use instead of `headers` if the desired payload is more complex than a list of key/value pairs (e.g. a set of headers that makes use of nested objects).  The value provided should be a valid JSON string with escaped double quotes. Conflicts with `headers`.
        :param str include_json_attachment: `true` or `false`. Flag for whether or not to attach a JSON document containing information about the associated alert to the email that is sent to recipients.
               * `webhook`
        :param str key: The key for integrating with VictorOps.
        :param Mapping[str, str] payload: A map of key/value pairs that represents the webhook payload.  Must provide `payload_type` if setting this argument.
        :param str payload_string: Use instead of `payload` if the desired payload is more complex than a list of key/value pairs (e.g. a payload that makes use of nested objects).  The value provided should be a valid JSON string with escaped double quotes. Conflicts with `payload`.
        :param str payload_type: Can either be `application/json` or `application/x-www-form-urlencoded`. The `payload_type` argument is _required_ if `payload` is set.
               * `pagerduty`
        :param str recipients: A set of recipients for targeting notifications.  Multiple values are comma separated.
        :param str region: The data center region to store your data.  Valid values are `US` and `EU`.  Default is `US`.
        :param str route_key: The route key for integrating with VictorOps.
               * `slack`
        :param str service_key: Specifies the service key for integrating with Pagerduty.
               * `victorops`
        :param str tags: A set of tags for targeting notifications. Multiple values are comma separated.
        :param str teams: A set of teams for targeting notifications. Multiple values are comma separated.
        :param str url: [Slack Webhook URL](https://slack.com/intl/en-es/help/articles/115005265063-Incoming-webhooks-for-Slack).
        """
        if api_key is not None:
            pulumi.set(__self__, "api_key", api_key)
        if auth_password is not None:
            pulumi.set(__self__, "auth_password", auth_password)
        if auth_type is not None:
            pulumi.set(__self__, "auth_type", auth_type)
        if auth_username is not None:
            pulumi.set(__self__, "auth_username", auth_username)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if headers_string is not None:
            pulumi.set(__self__, "headers_string", headers_string)
        if include_json_attachment is not None:
            pulumi.set(__self__, "include_json_attachment", include_json_attachment)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if payload is not None:
            pulumi.set(__self__, "payload", payload)
        if payload_string is not None:
            pulumi.set(__self__, "payload_string", payload_string)
        if payload_type is not None:
            pulumi.set(__self__, "payload_type", payload_type)
        if recipients is not None:
            pulumi.set(__self__, "recipients", recipients)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if route_key is not None:
            pulumi.set(__self__, "route_key", route_key)
        if service_key is not None:
            pulumi.set(__self__, "service_key", service_key)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if teams is not None:
            pulumi.set(__self__, "teams", teams)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if user_id is not None:
            pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> Optional[str]:
        """
        The API key for integrating with OpsGenie.
        """
        return pulumi.get(self, "api_key")

    @property
    @pulumi.getter(name="authPassword")
    def auth_password(self) -> Optional[str]:
        """
        Specifies an authentication password for use with a channel.  Supported by the `webhook` channel type.
        """
        return pulumi.get(self, "auth_password")

    @property
    @pulumi.getter(name="authType")
    def auth_type(self) -> Optional[str]:
        """
        Specifies an authentication method for use with a channel.  Supported by the `webhook` channel type.  Only HTTP basic authentication is currently supported via the value `BASIC`.
        """
        return pulumi.get(self, "auth_type")

    @property
    @pulumi.getter(name="authUsername")
    def auth_username(self) -> Optional[str]:
        """
        Specifies an authentication username for use with a channel.  Supported by the `webhook` channel type.
        """
        return pulumi.get(self, "auth_username")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        """
        The base URL of the webhook destination.
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter
    def channel(self) -> Optional[str]:
        """
        The Slack channel to send notifications to.
        * `opsgenie`
        """
        return pulumi.get(self, "channel")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Mapping[str, str]]:
        """
        A map of key/value pairs that represents extra HTTP headers to be sent along with the webhook payload.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter(name="headersString")
    def headers_string(self) -> Optional[str]:
        """
        Use instead of `headers` if the desired payload is more complex than a list of key/value pairs (e.g. a set of headers that makes use of nested objects).  The value provided should be a valid JSON string with escaped double quotes. Conflicts with `headers`.
        """
        return pulumi.get(self, "headers_string")

    @property
    @pulumi.getter(name="includeJsonAttachment")
    def include_json_attachment(self) -> Optional[str]:
        """
        `true` or `false`. Flag for whether or not to attach a JSON document containing information about the associated alert to the email that is sent to recipients.
        * `webhook`
        """
        return pulumi.get(self, "include_json_attachment")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The key for integrating with VictorOps.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def payload(self) -> Optional[Mapping[str, str]]:
        """
        A map of key/value pairs that represents the webhook payload.  Must provide `payload_type` if setting this argument.
        """
        return pulumi.get(self, "payload")

    @property
    @pulumi.getter(name="payloadString")
    def payload_string(self) -> Optional[str]:
        """
        Use instead of `payload` if the desired payload is more complex than a list of key/value pairs (e.g. a payload that makes use of nested objects).  The value provided should be a valid JSON string with escaped double quotes. Conflicts with `payload`.
        """
        return pulumi.get(self, "payload_string")

    @property
    @pulumi.getter(name="payloadType")
    def payload_type(self) -> Optional[str]:
        """
        Can either be `application/json` or `application/x-www-form-urlencoded`. The `payload_type` argument is _required_ if `payload` is set.
        * `pagerduty`
        """
        return pulumi.get(self, "payload_type")

    @property
    @pulumi.getter
    def recipients(self) -> Optional[str]:
        """
        A set of recipients for targeting notifications.  Multiple values are comma separated.
        """
        return pulumi.get(self, "recipients")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The data center region to store your data.  Valid values are `US` and `EU`.  Default is `US`.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="routeKey")
    def route_key(self) -> Optional[str]:
        """
        The route key for integrating with VictorOps.
        * `slack`
        """
        return pulumi.get(self, "route_key")

    @property
    @pulumi.getter(name="serviceKey")
    def service_key(self) -> Optional[str]:
        """
        Specifies the service key for integrating with Pagerduty.
        * `victorops`
        """
        return pulumi.get(self, "service_key")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        A set of tags for targeting notifications. Multiple values are comma separated.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def teams(self) -> Optional[str]:
        """
        A set of teams for targeting notifications. Multiple values are comma separated.
        """
        return pulumi.get(self, "teams")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        [Slack Webhook URL](https://slack.com/intl/en-es/help/articles/115005265063-Incoming-webhooks-for-Slack).
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[str]:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class AlertConditionTerm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeFunction":
            suggest = "time_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AlertConditionTerm. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AlertConditionTerm.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AlertConditionTerm.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: int,
                 threshold: float,
                 time_function: str,
                 operator: Optional[str] = None,
                 priority: Optional[str] = None):
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "time_function", time_function)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)

    @property
    @pulumi.getter
    def duration(self) -> int:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        return pulumi.get(self, "threshold")

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def priority(self) -> Optional[str]:
        return pulumi.get(self, "priority")


@pulumi.output_type
class AlertMutingRuleCondition(dict):
    def __init__(__self__, *,
                 conditions: Sequence['outputs.AlertMutingRuleConditionCondition'],
                 operator: str):
        """
        :param Sequence['AlertMutingRuleConditionConditionArgs'] conditions: The individual MutingRuleConditions within the group. See Nested conditions blocks below for details.
        :param str operator: The operator used to combine all the MutingRuleConditions within the group.
        """
        pulumi.set(__self__, "conditions", conditions)
        pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter
    def conditions(self) -> Sequence['outputs.AlertMutingRuleConditionCondition']:
        """
        The individual MutingRuleConditions within the group. See Nested conditions blocks below for details.
        """
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator used to combine all the MutingRuleConditions within the group.
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class AlertMutingRuleConditionCondition(dict):
    def __init__(__self__, *,
                 attribute: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str attribute: The attribute on a violation. Valid values are   `accountId`, `conditionId`, `conditionName`, `conditionRunbookUrl`, `conditionType`, `entity.guid`, `nrqlEventType`, `nrqlQuery`, `policyId`, `policyName`, `product`, `tags.<NAME>`, `targetId`, `targetName`
        :param str operator: The operator used to compare the attribute's value with the supplied value(s). Valid values are `ANY`, `CONTAINS`, `ENDS_WITH`, `EQUALS`, `IN`, `IS_BLANK`, `IS_NOT_BLANK`, `NOT_CONTAINS`, `NOT_ENDS_WITH`, `NOT_EQUALS`, `NOT_IN`, `NOT_STARTS_WITH`, `STARTS_WITH`
        :param Sequence[str] values: The value(s) to compare against the attribute's value.
        """
        pulumi.set(__self__, "attribute", attribute)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def attribute(self) -> str:
        """
        The attribute on a violation. Valid values are   `accountId`, `conditionId`, `conditionName`, `conditionRunbookUrl`, `conditionType`, `entity.guid`, `nrqlEventType`, `nrqlQuery`, `policyId`, `policyName`, `product`, `tags.<NAME>`, `targetId`, `targetName`
        """
        return pulumi.get(self, "attribute")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator used to compare the attribute's value with the supplied value(s). Valid values are `ANY`, `CONTAINS`, `ENDS_WITH`, `EQUALS`, `IN`, `IS_BLANK`, `IS_NOT_BLANK`, `NOT_CONTAINS`, `NOT_ENDS_WITH`, `NOT_EQUALS`, `NOT_IN`, `NOT_STARTS_WITH`, `STARTS_WITH`
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        The value(s) to compare against the attribute's value.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class AlertMutingRuleSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeZone":
            suggest = "time_zone"
        elif key == "endRepeat":
            suggest = "end_repeat"
        elif key == "endTime":
            suggest = "end_time"
        elif key == "repeatCount":
            suggest = "repeat_count"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "weeklyRepeatDays":
            suggest = "weekly_repeat_days"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AlertMutingRuleSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AlertMutingRuleSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AlertMutingRuleSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 time_zone: str,
                 end_repeat: Optional[str] = None,
                 end_time: Optional[str] = None,
                 repeat: Optional[str] = None,
                 repeat_count: Optional[int] = None,
                 start_time: Optional[str] = None,
                 weekly_repeat_days: Optional[Sequence[str]] = None):
        """
        :param str end_repeat: The datetime stamp when the muting rule schedule stops repeating. This is in local ISO 8601 format without an offset. Example: '2020-07-10T15:00:00'. Conflicts with `repeat_count`
        :param str end_time: The datetime stamp that represents when the muting rule ends. This is in local ISO 8601 format without an offset. Example: '2020-07-15T14:30:00'
        :param str repeat: The frequency the muting rule schedule repeats. If it does not repeat, omit this field. Options are DAILY, WEEKLY, MONTHLY
        :param int repeat_count: The number of times the muting rule schedule repeats. This includes the original schedule. For example, a repeatCount of 2 will recur one time. Conflicts with `end_repeat`
        :param str start_time: The datetime stamp that represents when the muting rule starts. This is in local ISO 8601 format without an offset. Example: '2020-07-08T14:30:00'
        :param Sequence[str] weekly_repeat_days: The day(s) of the week that a muting rule should repeat when the repeat field is set to 'WEEKLY'. Example: ['MONDAY', 'WEDNESDAY']
        """
        pulumi.set(__self__, "time_zone", time_zone)
        if end_repeat is not None:
            pulumi.set(__self__, "end_repeat", end_repeat)
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if repeat is not None:
            pulumi.set(__self__, "repeat", repeat)
        if repeat_count is not None:
            pulumi.set(__self__, "repeat_count", repeat_count)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if weekly_repeat_days is not None:
            pulumi.set(__self__, "weekly_repeat_days", weekly_repeat_days)

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

    @property
    @pulumi.getter(name="endRepeat")
    def end_repeat(self) -> Optional[str]:
        """
        The datetime stamp when the muting rule schedule stops repeating. This is in local ISO 8601 format without an offset. Example: '2020-07-10T15:00:00'. Conflicts with `repeat_count`
        """
        return pulumi.get(self, "end_repeat")

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[str]:
        """
        The datetime stamp that represents when the muting rule ends. This is in local ISO 8601 format without an offset. Example: '2020-07-15T14:30:00'
        """
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter
    def repeat(self) -> Optional[str]:
        """
        The frequency the muting rule schedule repeats. If it does not repeat, omit this field. Options are DAILY, WEEKLY, MONTHLY
        """
        return pulumi.get(self, "repeat")

    @property
    @pulumi.getter(name="repeatCount")
    def repeat_count(self) -> Optional[int]:
        """
        The number of times the muting rule schedule repeats. This includes the original schedule. For example, a repeatCount of 2 will recur one time. Conflicts with `end_repeat`
        """
        return pulumi.get(self, "repeat_count")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        """
        The datetime stamp that represents when the muting rule starts. This is in local ISO 8601 format without an offset. Example: '2020-07-08T14:30:00'
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="weeklyRepeatDays")
    def weekly_repeat_days(self) -> Optional[Sequence[str]]:
        """
        The day(s) of the week that a muting rule should repeat when the repeat field is set to 'WEEKLY'. Example: ['MONDAY', 'WEDNESDAY']
        """
        return pulumi.get(self, "weekly_repeat_days")


@pulumi.output_type
class EntityTagsTag(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        """
        :param str key: The tag key.
        :param Sequence[str] values: The tag values.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The tag key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        The tag values.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class InfraAlertConditionCritical(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeFunction":
            suggest = "time_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InfraAlertConditionCritical. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InfraAlertConditionCritical.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InfraAlertConditionCritical.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: int,
                 time_function: Optional[str] = None,
                 value: Optional[float] = None):
        pulumi.set(__self__, "duration", duration)
        if time_function is not None:
            pulumi.set(__self__, "time_function", time_function)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def duration(self) -> int:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter(name="timeFunction")
    def time_function(self) -> Optional[str]:
        return pulumi.get(self, "time_function")

    @property
    @pulumi.getter
    def value(self) -> Optional[float]:
        return pulumi.get(self, "value")


@pulumi.output_type
class InfraAlertConditionWarning(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeFunction":
            suggest = "time_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InfraAlertConditionWarning. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InfraAlertConditionWarning.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InfraAlertConditionWarning.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: int,
                 time_function: Optional[str] = None,
                 value: Optional[float] = None):
        pulumi.set(__self__, "duration", duration)
        if time_function is not None:
            pulumi.set(__self__, "time_function", time_function)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def duration(self) -> int:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter(name="timeFunction")
    def time_function(self) -> Optional[str]:
        return pulumi.get(self, "time_function")

    @property
    @pulumi.getter
    def value(self) -> Optional[float]:
        return pulumi.get(self, "value")


@pulumi.output_type
class NotificationChannelProperty(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayValue":
            suggest = "display_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotificationChannelProperty. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotificationChannelProperty.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotificationChannelProperty.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key: str,
                 value: str,
                 display_value: Optional[str] = None,
                 label: Optional[str] = None):
        """
        :param str key: The notification property key.
        :param str value: The notification property value.
        :param str display_value: The notification property display value.
               *
               Each notification channel type supports a specific set of arguments for the `property` block:
        :param str label: The notification property label.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if display_value is not None:
            pulumi.set(__self__, "display_value", display_value)
        if label is not None:
            pulumi.set(__self__, "label", label)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The notification property key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The notification property value.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter(name="displayValue")
    def display_value(self) -> Optional[str]:
        """
        The notification property display value.
        *
        Each notification channel type supports a specific set of arguments for the `property` block:
        """
        return pulumi.get(self, "display_value")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        The notification property label.
        """
        return pulumi.get(self, "label")


@pulumi.output_type
class NotificationDestinationAuthBasic(dict):
    def __init__(__self__, *,
                 password: str,
                 user: str):
        """
        :param str password: Specifies an authentication password for use with a destination.
        :param str user: The username of the basic auth.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        Specifies an authentication password for use with a destination.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> str:
        """
        The username of the basic auth.
        """
        return pulumi.get(self, "user")


@pulumi.output_type
class NotificationDestinationAuthToken(dict):
    def __init__(__self__, *,
                 token: str,
                 prefix: Optional[str] = None):
        """
        :param str token: Specifies the token for integrating.
        :param str prefix: The prefix of the token auth.
        """
        pulumi.set(__self__, "token", token)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def token(self) -> str:
        """
        Specifies the token for integrating.
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        The prefix of the token auth.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class NotificationDestinationProperty(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayValue":
            suggest = "display_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotificationDestinationProperty. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotificationDestinationProperty.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotificationDestinationProperty.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key: str,
                 value: str,
                 display_value: Optional[str] = None,
                 label: Optional[str] = None):
        """
        :param str key: The notification property key.
        :param str value: The notification property value.
        :param str display_value: The notification property display value.
        :param str label: The notification property label.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if display_value is not None:
            pulumi.set(__self__, "display_value", display_value)
        if label is not None:
            pulumi.set(__self__, "label", label)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The notification property key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The notification property value.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter(name="displayValue")
    def display_value(self) -> Optional[str]:
        """
        The notification property display value.
        """
        return pulumi.get(self, "display_value")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        The notification property label.
        """
        return pulumi.get(self, "label")


@pulumi.output_type
class NrqlAlertConditionCritical(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdDuration":
            suggest = "threshold_duration"
        elif key == "thresholdOccurrences":
            suggest = "threshold_occurrences"
        elif key == "timeFunction":
            suggest = "time_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionCritical. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NrqlAlertConditionCritical.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NrqlAlertConditionCritical.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 threshold: float,
                 duration: Optional[int] = None,
                 operator: Optional[str] = None,
                 threshold_duration: Optional[int] = None,
                 threshold_occurrences: Optional[str] = None,
                 time_function: Optional[str] = None):
        pulumi.set(__self__, "threshold", threshold)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if threshold_duration is not None:
            pulumi.set(__self__, "threshold_duration", threshold_duration)
        if threshold_occurrences is not None:
            pulumi.set(__self__, "threshold_occurrences", threshold_occurrences)
        if time_function is not None:
            pulumi.set(__self__, "time_function", time_function)

    @property
    @pulumi.getter
    def threshold(self) -> float:
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def duration(self) -> Optional[int]:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter(name="thresholdDuration")
    def threshold_duration(self) -> Optional[int]:
        return pulumi.get(self, "threshold_duration")

    @property
    @pulumi.getter(name="thresholdOccurrences")
    def threshold_occurrences(self) -> Optional[str]:
        return pulumi.get(self, "threshold_occurrences")

    @property
    @pulumi.getter(name="timeFunction")
    def time_function(self) -> Optional[str]:
        return pulumi.get(self, "time_function")


@pulumi.output_type
class NrqlAlertConditionNrql(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "evaluationOffset":
            suggest = "evaluation_offset"
        elif key == "sinceValue":
            suggest = "since_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionNrql. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NrqlAlertConditionNrql.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NrqlAlertConditionNrql.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 evaluation_offset: Optional[int] = None,
                 since_value: Optional[str] = None):
        pulumi.set(__self__, "query", query)
        if evaluation_offset is not None:
            pulumi.set(__self__, "evaluation_offset", evaluation_offset)
        if since_value is not None:
            pulumi.set(__self__, "since_value", since_value)

    @property
    @pulumi.getter
    def query(self) -> str:
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="evaluationOffset")
    def evaluation_offset(self) -> Optional[int]:
        return pulumi.get(self, "evaluation_offset")

    @property
    @pulumi.getter(name="sinceValue")
    def since_value(self) -> Optional[str]:
        return pulumi.get(self, "since_value")


@pulumi.output_type
class NrqlAlertConditionTerm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdDuration":
            suggest = "threshold_duration"
        elif key == "thresholdOccurrences":
            suggest = "threshold_occurrences"
        elif key == "timeFunction":
            suggest = "time_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionTerm. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NrqlAlertConditionTerm.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NrqlAlertConditionTerm.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 threshold: float,
                 duration: Optional[int] = None,
                 operator: Optional[str] = None,
                 priority: Optional[str] = None,
                 threshold_duration: Optional[int] = None,
                 threshold_occurrences: Optional[str] = None,
                 time_function: Optional[str] = None):
        pulumi.set(__self__, "threshold", threshold)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if threshold_duration is not None:
            pulumi.set(__self__, "threshold_duration", threshold_duration)
        if threshold_occurrences is not None:
            pulumi.set(__self__, "threshold_occurrences", threshold_occurrences)
        if time_function is not None:
            pulumi.set(__self__, "time_function", time_function)

    @property
    @pulumi.getter
    def threshold(self) -> float:
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def duration(self) -> Optional[int]:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def priority(self) -> Optional[str]:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="thresholdDuration")
    def threshold_duration(self) -> Optional[int]:
        return pulumi.get(self, "threshold_duration")

    @property
    @pulumi.getter(name="thresholdOccurrences")
    def threshold_occurrences(self) -> Optional[str]:
        return pulumi.get(self, "threshold_occurrences")

    @property
    @pulumi.getter(name="timeFunction")
    def time_function(self) -> Optional[str]:
        return pulumi.get(self, "time_function")


@pulumi.output_type
class NrqlAlertConditionWarning(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdDuration":
            suggest = "threshold_duration"
        elif key == "thresholdOccurrences":
            suggest = "threshold_occurrences"
        elif key == "timeFunction":
            suggest = "time_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionWarning. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NrqlAlertConditionWarning.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NrqlAlertConditionWarning.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 threshold: float,
                 duration: Optional[int] = None,
                 operator: Optional[str] = None,
                 threshold_duration: Optional[int] = None,
                 threshold_occurrences: Optional[str] = None,
                 time_function: Optional[str] = None):
        pulumi.set(__self__, "threshold", threshold)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if threshold_duration is not None:
            pulumi.set(__self__, "threshold_duration", threshold_duration)
        if threshold_occurrences is not None:
            pulumi.set(__self__, "threshold_occurrences", threshold_occurrences)
        if time_function is not None:
            pulumi.set(__self__, "time_function", time_function)

    @property
    @pulumi.getter
    def threshold(self) -> float:
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def duration(self) -> Optional[int]:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter(name="thresholdDuration")
    def threshold_duration(self) -> Optional[int]:
        return pulumi.get(self, "threshold_duration")

    @property
    @pulumi.getter(name="thresholdOccurrences")
    def threshold_occurrences(self) -> Optional[str]:
        return pulumi.get(self, "threshold_occurrences")

    @property
    @pulumi.getter(name="timeFunction")
    def time_function(self) -> Optional[str]:
        return pulumi.get(self, "time_function")


@pulumi.output_type
class OneDashboardPage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "widgetAreas":
            suggest = "widget_areas"
        elif key == "widgetBars":
            suggest = "widget_bars"
        elif key == "widgetBillboards":
            suggest = "widget_billboards"
        elif key == "widgetBullets":
            suggest = "widget_bullets"
        elif key == "widgetFunnels":
            suggest = "widget_funnels"
        elif key == "widgetHeatmaps":
            suggest = "widget_heatmaps"
        elif key == "widgetHistograms":
            suggest = "widget_histograms"
        elif key == "widgetJsons":
            suggest = "widget_jsons"
        elif key == "widgetLines":
            suggest = "widget_lines"
        elif key == "widgetLogTables":
            suggest = "widget_log_tables"
        elif key == "widgetMarkdowns":
            suggest = "widget_markdowns"
        elif key == "widgetPies":
            suggest = "widget_pies"
        elif key == "widgetStackedBars":
            suggest = "widget_stacked_bars"
        elif key == "widgetTables":
            suggest = "widget_tables"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 description: Optional[str] = None,
                 guid: Optional[str] = None,
                 widget_areas: Optional[Sequence['outputs.OneDashboardPageWidgetArea']] = None,
                 widget_bars: Optional[Sequence['outputs.OneDashboardPageWidgetBar']] = None,
                 widget_billboards: Optional[Sequence['outputs.OneDashboardPageWidgetBillboard']] = None,
                 widget_bullets: Optional[Sequence['outputs.OneDashboardPageWidgetBullet']] = None,
                 widget_funnels: Optional[Sequence['outputs.OneDashboardPageWidgetFunnel']] = None,
                 widget_heatmaps: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmap']] = None,
                 widget_histograms: Optional[Sequence['outputs.OneDashboardPageWidgetHistogram']] = None,
                 widget_jsons: Optional[Sequence['outputs.OneDashboardPageWidgetJson']] = None,
                 widget_lines: Optional[Sequence['outputs.OneDashboardPageWidgetLine']] = None,
                 widget_log_tables: Optional[Sequence['outputs.OneDashboardPageWidgetLogTable']] = None,
                 widget_markdowns: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdown']] = None,
                 widget_pies: Optional[Sequence['outputs.OneDashboardPageWidgetPy']] = None,
                 widget_stacked_bars: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBar']] = None,
                 widget_tables: Optional[Sequence['outputs.OneDashboardPageWidgetTable']] = None):
        """
        :param str name: The title of the dashboard.
        :param str description: Brief text describing the dashboard.
        :param str guid: The unique entity identifier of the dashboard page in New Relic.
        :param Sequence['OneDashboardPageWidgetAreaArgs'] widget_areas: (Optional) A nested block that describes an Area widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetBarArgs'] widget_bars: (Optional) A nested block that describes a Bar widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetBillboardArgs'] widget_billboards: (Optional) A nested block that describes a Billboard widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetBulletArgs'] widget_bullets: (Optional) A nested block that describes a Bullet widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetFunnelArgs'] widget_funnels: (Optional) A nested block that describes a Funnel widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetHeatmapArgs'] widget_heatmaps: (Optional) A nested block that describes a Heatmap widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetHistogramArgs'] widget_histograms: (Optional) A nested block that describes a Histogram widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetJsonArgs'] widget_jsons: (Optional) A nested block that describes a JSON widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetLineArgs'] widget_lines: (Optional) A nested block that describes a Line widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetLogTableArgs'] widget_log_tables: (Optional) A nested block that describes a Log Table widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetMarkdownArgs'] widget_markdowns: (Optional) A nested block that describes a Markdown widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetPyArgs'] widget_pies: (Optional) A nested block that describes a Pie widget.  See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetStackedBarArgs'] widget_stacked_bars: (Optional) A nested block that describes a Stacked Bar widget. See Nested widget blocks below for details.
        :param Sequence['OneDashboardPageWidgetTableArgs'] widget_tables: (Optional) A nested block that describes a Table widget.  See Nested widget blocks below for details.
        """
        pulumi.set(__self__, "name", name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if guid is not None:
            pulumi.set(__self__, "guid", guid)
        if widget_areas is not None:
            pulumi.set(__self__, "widget_areas", widget_areas)
        if widget_bars is not None:
            pulumi.set(__self__, "widget_bars", widget_bars)
        if widget_billboards is not None:
            pulumi.set(__self__, "widget_billboards", widget_billboards)
        if widget_bullets is not None:
            pulumi.set(__self__, "widget_bullets", widget_bullets)
        if widget_funnels is not None:
            pulumi.set(__self__, "widget_funnels", widget_funnels)
        if widget_heatmaps is not None:
            pulumi.set(__self__, "widget_heatmaps", widget_heatmaps)
        if widget_histograms is not None:
            pulumi.set(__self__, "widget_histograms", widget_histograms)
        if widget_jsons is not None:
            pulumi.set(__self__, "widget_jsons", widget_jsons)
        if widget_lines is not None:
            pulumi.set(__self__, "widget_lines", widget_lines)
        if widget_log_tables is not None:
            pulumi.set(__self__, "widget_log_tables", widget_log_tables)
        if widget_markdowns is not None:
            pulumi.set(__self__, "widget_markdowns", widget_markdowns)
        if widget_pies is not None:
            pulumi.set(__self__, "widget_pies", widget_pies)
        if widget_stacked_bars is not None:
            pulumi.set(__self__, "widget_stacked_bars", widget_stacked_bars)
        if widget_tables is not None:
            pulumi.set(__self__, "widget_tables", widget_tables)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The title of the dashboard.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Brief text describing the dashboard.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def guid(self) -> Optional[str]:
        """
        The unique entity identifier of the dashboard page in New Relic.
        """
        return pulumi.get(self, "guid")

    @property
    @pulumi.getter(name="widgetAreas")
    def widget_areas(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetArea']]:
        """
        (Optional) A nested block that describes an Area widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_areas")

    @property
    @pulumi.getter(name="widgetBars")
    def widget_bars(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBar']]:
        """
        (Optional) A nested block that describes a Bar widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_bars")

    @property
    @pulumi.getter(name="widgetBillboards")
    def widget_billboards(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboard']]:
        """
        (Optional) A nested block that describes a Billboard widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_billboards")

    @property
    @pulumi.getter(name="widgetBullets")
    def widget_bullets(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBullet']]:
        """
        (Optional) A nested block that describes a Bullet widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_bullets")

    @property
    @pulumi.getter(name="widgetFunnels")
    def widget_funnels(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnel']]:
        """
        (Optional) A nested block that describes a Funnel widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_funnels")

    @property
    @pulumi.getter(name="widgetHeatmaps")
    def widget_heatmaps(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmap']]:
        """
        (Optional) A nested block that describes a Heatmap widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_heatmaps")

    @property
    @pulumi.getter(name="widgetHistograms")
    def widget_histograms(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogram']]:
        """
        (Optional) A nested block that describes a Histogram widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_histograms")

    @property
    @pulumi.getter(name="widgetJsons")
    def widget_jsons(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJson']]:
        """
        (Optional) A nested block that describes a JSON widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_jsons")

    @property
    @pulumi.getter(name="widgetLines")
    def widget_lines(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLine']]:
        """
        (Optional) A nested block that describes a Line widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_lines")

    @property
    @pulumi.getter(name="widgetLogTables")
    def widget_log_tables(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTable']]:
        """
        (Optional) A nested block that describes a Log Table widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_log_tables")

    @property
    @pulumi.getter(name="widgetMarkdowns")
    def widget_markdowns(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdown']]:
        """
        (Optional) A nested block that describes a Markdown widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_markdowns")

    @property
    @pulumi.getter(name="widgetPies")
    def widget_pies(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPy']]:
        """
        (Optional) A nested block that describes a Pie widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_pies")

    @property
    @pulumi.getter(name="widgetStackedBars")
    def widget_stacked_bars(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBar']]:
        """
        (Optional) A nested block that describes a Stacked Bar widget. See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_stacked_bars")

    @property
    @pulumi.getter(name="widgetTables")
    def widget_tables(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTable']]:
        """
        (Optional) A nested block that describes a Table widget.  See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widget_tables")


@pulumi.output_type
class OneDashboardPageWidgetArea(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetArea. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetArea.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetArea.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetAreaNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetAreaNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetAreaNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetAreaNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetAreaNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetAreaNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetAreaNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetBar(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetBar. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetBar.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetBar.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetBarNrqlQuery'],
                 row: int,
                 title: str,
                 filter_current_dashboard: Optional[bool] = None,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 linked_entity_guids: Optional[Sequence[str]] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetBarNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if filter_current_dashboard is not None:
            pulumi.set(__self__, "filter_current_dashboard", filter_current_dashboard)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetBarNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[bool]:
        return pulumi.get(self, "filter_current_dashboard")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter(name="linkedEntityGuids")
    def linked_entity_guids(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "linked_entity_guids")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetBarNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetBarNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetBarNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetBarNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetBillboard(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetBillboard. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetBillboard.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetBillboard.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetBillboardNrqlQuery'],
                 row: int,
                 title: str,
                 critical: Optional[str] = None,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 warning: Optional[str] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetBillboardNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param str critical: (Optional) Threshold above which the displayed value will be styled with a red color.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param str warning: (Optional) Threshold above which the displayed value will be styled with a yellow color.
               * `widget_bullet`
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if critical is not None:
            pulumi.set(__self__, "critical", critical)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if warning is not None:
            pulumi.set(__self__, "warning", warning)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetBillboardNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def critical(self) -> Optional[str]:
        """
        (Optional) Threshold above which the displayed value will be styled with a red color.
        """
        return pulumi.get(self, "critical")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def warning(self) -> Optional[str]:
        """
        (Optional) Threshold above which the displayed value will be styled with a yellow color.
        * `widget_bullet`
        """
        return pulumi.get(self, "warning")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetBillboardNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetBillboardNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetBillboardNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetBillboardNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetBullet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetBullet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetBullet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetBullet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 limit: float,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetBulletNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param float limit: (Required) Visualization limit for the widget.
               * `widget_funnel`
        :param Sequence['OneDashboardPageWidgetBulletNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "limit", limit)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter
    def limit(self) -> float:
        """
        (Required) Visualization limit for the widget.
        * `widget_funnel`
        """
        return pulumi.get(self, "limit")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetBulletNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetBulletNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetBulletNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetBulletNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetBulletNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetFunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetFunnel. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetFunnel.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetFunnel.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetFunnelNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetFunnelNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetFunnelNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetFunnelNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetFunnelNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetFunnelNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetFunnelNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetHeatmap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetHeatmap. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetHeatmap.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetHeatmap.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetHeatmapNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetHeatmapNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetHeatmapNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetHeatmapNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetHeatmapNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetHeatmapNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetHistogram(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetHistogram. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetHistogram.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetHistogram.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetHistogramNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetHistogramNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetHistogramNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetHistogramNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetHistogramNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetHistogramNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetHistogramNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetJson(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetJson. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetJson.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetJson.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetJsonNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetJsonNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetJsonNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetJsonNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetJsonNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetJsonNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetJsonNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetLine(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetLine. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetLine.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetLine.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetLineNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetLineNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetLineNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetLineNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetLineNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetLineNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetLineNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetLogTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetLogTable. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetLogTable.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetLogTable.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetLogTableNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetLogTableNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetLogTableNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetLogTableNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetLogTableNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetLogTableNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetLogTableNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetMarkdown(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetMarkdown. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetMarkdown.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetMarkdown.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 text: Optional[str] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param str text: (Required) The markdown source to be rendered in the widget.
               * `widget_stacked_bar`
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if text is not None:
            pulumi.set(__self__, "text", text)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        (Required) The markdown source to be rendered in the widget.
        * `widget_stacked_bar`
        """
        return pulumi.get(self, "text")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetPy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetPy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetPy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetPy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetPyNrqlQuery'],
                 row: int,
                 title: str,
                 filter_current_dashboard: Optional[bool] = None,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 linked_entity_guids: Optional[Sequence[str]] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetPyNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if filter_current_dashboard is not None:
            pulumi.set(__self__, "filter_current_dashboard", filter_current_dashboard)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetPyNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[bool]:
        return pulumi.get(self, "filter_current_dashboard")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter(name="linkedEntityGuids")
    def linked_entity_guids(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "linked_entity_guids")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetPyNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetPyNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetPyNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetPyNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetStackedBar(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetStackedBar. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetStackedBar.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetStackedBar.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetStackedBarNrqlQuery'],
                 row: int,
                 title: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetStackedBarNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetStackedBarNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetStackedBarNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetStackedBarNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetStackedBarNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardPageWidgetTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetTable. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetTable.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetTable.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetTableNrqlQuery'],
                 row: int,
                 title: str,
                 filter_current_dashboard: Optional[bool] = None,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 ignore_time_range: Optional[bool] = None,
                 linked_entity_guids: Optional[Sequence[str]] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetTableNrqlQueryArgs'] nrql_queries: (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
               * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
               * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param bool ignore_time_range: (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        :param int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if filter_current_dashboard is not None:
            pulumi.set(__self__, "filter_current_dashboard", filter_current_dashboard)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetTableNrqlQuery']:
        """
        (Required) A nested block that describes a NRQL Query. See Nested nrql\\_query blocks below for details.
        * `linked_entity_guids`: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        * `filter_current_dashboard`: (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "nrql_queries")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[bool]:
        return pulumi.get(self, "filter_current_dashboard")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[bool]:
        """
        (Optional) With this turned on, the time range in this query will override the time picker on dashboards and other pages. Defaults to `false`.
        """
        return pulumi.get(self, "ignore_time_range")

    @property
    @pulumi.getter(name="linkedEntityGuids")
    def linked_entity_guids(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "linked_entity_guids")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class OneDashboardPageWidgetTableNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardPageWidgetTableNrqlQuery. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardPageWidgetTableNrqlQuery.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardPageWidgetTableNrqlQuery.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query: str,
                 account_id: Optional[int] = None):
        """
        :param str query: (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        :param int account_id: Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        pulumi.set(__self__, "query", query)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        (Required) Valid NRQL query string. See [Writing NRQL Queries](https://docs.newrelic.com/docs/insights/nrql-new-relic-query-language/using-nrql/introduction-nrql) for help.
        """
        return pulumi.get(self, "query")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the dashboard will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")


@pulumi.output_type
class OneDashboardRawPage(dict):
    def __init__(__self__, *,
                 name: str,
                 description: Optional[str] = None,
                 guid: Optional[str] = None,
                 widgets: Optional[Sequence['outputs.OneDashboardRawPageWidget']] = None):
        """
        :param str name: The title of the dashboard.
        :param str description: Brief text describing the dashboard.
        :param str guid: The unique entity identifier of the dashboard page in New Relic.
        :param Sequence['OneDashboardRawPageWidgetArgs'] widgets: (Optional) A nested block that describes a widget. See Nested widget blocks below for details.
        """
        pulumi.set(__self__, "name", name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if guid is not None:
            pulumi.set(__self__, "guid", guid)
        if widgets is not None:
            pulumi.set(__self__, "widgets", widgets)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The title of the dashboard.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Brief text describing the dashboard.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def guid(self) -> Optional[str]:
        """
        The unique entity identifier of the dashboard page in New Relic.
        """
        return pulumi.get(self, "guid")

    @property
    @pulumi.getter
    def widgets(self) -> Optional[Sequence['outputs.OneDashboardRawPageWidget']]:
        """
        (Optional) A nested block that describes a widget. See Nested widget blocks below for details.
        """
        return pulumi.get(self, "widgets")


@pulumi.output_type
class OneDashboardRawPageWidget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "visualizationId":
            suggest = "visualization_id"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OneDashboardRawPageWidget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OneDashboardRawPageWidget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OneDashboardRawPageWidget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column: int,
                 configuration: str,
                 row: int,
                 title: str,
                 visualization_id: str,
                 height: Optional[int] = None,
                 id: Optional[str] = None,
                 linked_entity_guids: Optional[Sequence[str]] = None,
                 width: Optional[int] = None):
        """
        :param int column: (Required) Column position of widget from top left, starting at `1`.
        :param str configuration: (Required) The configuration of the widget.
        :param int row: (Required) Row position of widget from top left, starting at `1`.
        :param str title: (Required) A title for the widget.
        :param str visualization_id: (Required) The visualization ID of the widget
        :param int height: (Optional) Height of the widget. Valid values are `1` to `12` inclusive. Defaults to `3`.
        :param Sequence[str] linked_entity_guids: (Optional) Related entity GUIDs.
        :param int width: (Optional) Width of the widget. Valid values are `1` to `12` inclusive. Defaults to `4`.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "configuration", configuration)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        pulumi.set(__self__, "visualization_id", visualization_id)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def column(self) -> int:
        """
        (Required) Column position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter
    def configuration(self) -> str:
        """
        (Required) The configuration of the widget.
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def row(self) -> int:
        """
        (Required) Row position of widget from top left, starting at `1`.
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def title(self) -> str:
        """
        (Required) A title for the widget.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="visualizationId")
    def visualization_id(self) -> str:
        """
        (Required) The visualization ID of the widget
        """
        return pulumi.get(self, "visualization_id")

    @property
    @pulumi.getter
    def height(self) -> Optional[int]:
        """
        (Optional) Height of the widget. Valid values are `1` to `12` inclusive. Defaults to `3`.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="linkedEntityGuids")
    def linked_entity_guids(self) -> Optional[Sequence[str]]:
        """
        (Optional) Related entity GUIDs.
        """
        return pulumi.get(self, "linked_entity_guids")

    @property
    @pulumi.getter
    def width(self) -> Optional[int]:
        """
        (Optional) Width of the widget. Valid values are `1` to `12` inclusive. Defaults to `4`.
        """
        return pulumi.get(self, "width")


@pulumi.output_type
class ServiceLevelEvents(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"
        elif key == "validEvents":
            suggest = "valid_events"
        elif key == "badEvents":
            suggest = "bad_events"
        elif key == "goodEvents":
            suggest = "good_events"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceLevelEvents. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceLevelEvents.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceLevelEvents.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 account_id: int,
                 valid_events: 'outputs.ServiceLevelEventsValidEvents',
                 bad_events: Optional['outputs.ServiceLevelEventsBadEvents'] = None,
                 good_events: Optional['outputs.ServiceLevelEventsGoodEvents'] = None):
        """
        :param int account_id: The ID of the account where the entity (e.g, APM Service, Browser application, Workload, etc.) belongs to,
               and that contains the NRDB data for the SLI/SLO calculations. Note that changing the account ID will force a new resource.
        :param 'ServiceLevelEventsValidEventsArgs' valid_events: The definition of valid requests.
        :param 'ServiceLevelEventsBadEventsArgs' bad_events: The definition of the bad responses. If you define an SLI from valid and bad events, you must leave the good events argument empty.
        :param 'ServiceLevelEventsGoodEventsArgs' good_events: The definition of good responses. If you define an SLI from valid and good events, you must leave the bad events argument empty.
        """
        pulumi.set(__self__, "account_id", account_id)
        pulumi.set(__self__, "valid_events", valid_events)
        if bad_events is not None:
            pulumi.set(__self__, "bad_events", bad_events)
        if good_events is not None:
            pulumi.set(__self__, "good_events", good_events)

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> int:
        """
        The ID of the account where the entity (e.g, APM Service, Browser application, Workload, etc.) belongs to,
        and that contains the NRDB data for the SLI/SLO calculations. Note that changing the account ID will force a new resource.
        """
        return pulumi.get(self, "account_id")

    @property
    @pulumi.getter(name="validEvents")
    def valid_events(self) -> 'outputs.ServiceLevelEventsValidEvents':
        """
        The definition of valid requests.
        """
        return pulumi.get(self, "valid_events")

    @property
    @pulumi.getter(name="badEvents")
    def bad_events(self) -> Optional['outputs.ServiceLevelEventsBadEvents']:
        """
        The definition of the bad responses. If you define an SLI from valid and bad events, you must leave the good events argument empty.
        """
        return pulumi.get(self, "bad_events")

    @property
    @pulumi.getter(name="goodEvents")
    def good_events(self) -> Optional['outputs.ServiceLevelEventsGoodEvents']:
        """
        The definition of good responses. If you define an SLI from valid and good events, you must leave the bad events argument empty.
        """
        return pulumi.get(self, "good_events")


@pulumi.output_type
class ServiceLevelEventsBadEvents(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "from":
            suggest = "from_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceLevelEventsBadEvents. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceLevelEventsBadEvents.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceLevelEventsBadEvents.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 from_: str,
                 where: Optional[str] = None):
        """
        :param str from_: The event type where NRDB data will be fetched from.
        :param str where: A filter that specifies all the NRDB events that are considered in this SLI (e.g, those that refer to a particular entity).
               a particular entity and were successful).
               a particular entity and returned an error).
        """
        pulumi.set(__self__, "from_", from_)
        if where is not None:
            pulumi.set(__self__, "where", where)

    @property
    @pulumi.getter(name="from")
    def from_(self) -> str:
        """
        The event type where NRDB data will be fetched from.
        """
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter
    def where(self) -> Optional[str]:
        """
        A filter that specifies all the NRDB events that are considered in this SLI (e.g, those that refer to a particular entity).
        a particular entity and were successful).
        a particular entity and returned an error).
        """
        return pulumi.get(self, "where")


@pulumi.output_type
class ServiceLevelEventsGoodEvents(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "from":
            suggest = "from_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceLevelEventsGoodEvents. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceLevelEventsGoodEvents.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceLevelEventsGoodEvents.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 from_: str,
                 where: Optional[str] = None):
        """
        :param str from_: The event type where NRDB data will be fetched from.
        :param str where: A filter that specifies all the NRDB events that are considered in this SLI (e.g, those that refer to a particular entity).
               a particular entity and were successful).
               a particular entity and returned an error).
        """
        pulumi.set(__self__, "from_", from_)
        if where is not None:
            pulumi.set(__self__, "where", where)

    @property
    @pulumi.getter(name="from")
    def from_(self) -> str:
        """
        The event type where NRDB data will be fetched from.
        """
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter
    def where(self) -> Optional[str]:
        """
        A filter that specifies all the NRDB events that are considered in this SLI (e.g, those that refer to a particular entity).
        a particular entity and were successful).
        a particular entity and returned an error).
        """
        return pulumi.get(self, "where")


@pulumi.output_type
class ServiceLevelEventsValidEvents(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "from":
            suggest = "from_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceLevelEventsValidEvents. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceLevelEventsValidEvents.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceLevelEventsValidEvents.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 from_: str,
                 where: Optional[str] = None):
        """
        :param str from_: The event type where NRDB data will be fetched from.
        :param str where: A filter that specifies all the NRDB events that are considered in this SLI (e.g, those that refer to a particular entity).
               a particular entity and were successful).
               a particular entity and returned an error).
        """
        pulumi.set(__self__, "from_", from_)
        if where is not None:
            pulumi.set(__self__, "where", where)

    @property
    @pulumi.getter(name="from")
    def from_(self) -> str:
        """
        The event type where NRDB data will be fetched from.
        """
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter
    def where(self) -> Optional[str]:
        """
        A filter that specifies all the NRDB events that are considered in this SLI (e.g, those that refer to a particular entity).
        a particular entity and were successful).
        a particular entity and returned an error).
        """
        return pulumi.get(self, "where")


@pulumi.output_type
class ServiceLevelObjective(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeWindow":
            suggest = "time_window"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceLevelObjective. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceLevelObjective.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceLevelObjective.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target: float,
                 time_window: 'outputs.ServiceLevelObjectiveTimeWindow',
                 description: Optional[str] = None,
                 name: Optional[str] = None):
        """
        :param float target: The target of the objective, valid values between `0` and `100`. Up to 5 decimals accepted.
        :param 'ServiceLevelObjectiveTimeWindowArgs' time_window: Time window is the period of the objective.
        :param str description: The description of the SLI.
        :param str name: A short name for the SLI that will help anyone understand what it is about.
        """
        pulumi.set(__self__, "target", target)
        pulumi.set(__self__, "time_window", time_window)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def target(self) -> float:
        """
        The target of the objective, valid values between `0` and `100`. Up to 5 decimals accepted.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter(name="timeWindow")
    def time_window(self) -> 'outputs.ServiceLevelObjectiveTimeWindow':
        """
        Time window is the period of the objective.
        """
        return pulumi.get(self, "time_window")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The description of the SLI.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        A short name for the SLI that will help anyone understand what it is about.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class ServiceLevelObjectiveTimeWindow(dict):
    def __init__(__self__, *,
                 rolling: 'outputs.ServiceLevelObjectiveTimeWindowRolling'):
        """
        :param 'ServiceLevelObjectiveTimeWindowRollingArgs' rolling: Rolling window.
        """
        pulumi.set(__self__, "rolling", rolling)

    @property
    @pulumi.getter
    def rolling(self) -> 'outputs.ServiceLevelObjectiveTimeWindowRolling':
        """
        Rolling window.
        """
        return pulumi.get(self, "rolling")


@pulumi.output_type
class ServiceLevelObjectiveTimeWindowRolling(dict):
    def __init__(__self__, *,
                 count: int,
                 unit: str):
        """
        :param int count: Valid values are `1`, `7` and `28`.
        :param str unit: The only supported value is `DAY`.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "unit", unit)

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        Valid values are `1`, `7` and `28`.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The only supported value is `DAY`.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class WorkflowDestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelId":
            suggest = "channel_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkflowDestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkflowDestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkflowDestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 channel_id: str,
                 name: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str name: A nrql enrichment name.
        :param str type: the filter's type.   One of: `FILTER` or `VIEW`.
               * `predicates`
        """
        pulumi.set(__self__, "channel_id", channel_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        A nrql enrichment name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        the filter's type.   One of: `FILTER` or `VIEW`.
        * `predicates`
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class WorkflowEnrichments(dict):
    def __init__(__self__, *,
                 nrqls: Sequence['outputs.WorkflowEnrichmentsNrql']):
        pulumi.set(__self__, "nrqls", nrqls)

    @property
    @pulumi.getter
    def nrqls(self) -> Sequence['outputs.WorkflowEnrichmentsNrql']:
        return pulumi.get(self, "nrqls")


@pulumi.output_type
class WorkflowEnrichmentsNrql(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"
        elif key == "enrichmentId":
            suggest = "enrichment_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkflowEnrichmentsNrql. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkflowEnrichmentsNrql.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkflowEnrichmentsNrql.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 configurations: Sequence['outputs.WorkflowEnrichmentsNrqlConfiguration'],
                 name: str,
                 account_id: Optional[int] = None,
                 enrichment_id: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param Sequence['WorkflowEnrichmentsNrqlConfigurationArgs'] configurations: A list of nrql enrichments.
        :param str name: A nrql enrichment name.
        :param int account_id: Determines the New Relic account where the workflow will be created. Defaults to the account associated with the API key used.
        :param str type: the filter's type.   One of: `FILTER` or `VIEW`.
               * `predicates`
        """
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "name", name)
        if account_id is not None:
            pulumi.set(__self__, "account_id", account_id)
        if enrichment_id is not None:
            pulumi.set(__self__, "enrichment_id", enrichment_id)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.WorkflowEnrichmentsNrqlConfiguration']:
        """
        A list of nrql enrichments.
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A nrql enrichment name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[int]:
        """
        Determines the New Relic account where the workflow will be created. Defaults to the account associated with the API key used.
        """
        return pulumi.get(self, "account_id")

    @property
    @pulumi.getter(name="enrichmentId")
    def enrichment_id(self) -> Optional[str]:
        return pulumi.get(self, "enrichment_id")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        the filter's type.   One of: `FILTER` or `VIEW`.
        * `predicates`
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class WorkflowEnrichmentsNrqlConfiguration(dict):
    def __init__(__self__, *,
                 query: str):
        """
        :param str query: the nrql query.
        """
        pulumi.set(__self__, "query", query)

    @property
    @pulumi.getter
    def query(self) -> str:
        """
        the nrql query.
        """
        return pulumi.get(self, "query")


@pulumi.output_type
class WorkflowIssuesFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filterId":
            suggest = "filter_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkflowIssuesFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkflowIssuesFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkflowIssuesFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 type: str,
                 filter_id: Optional[str] = None,
                 predicates: Optional[Sequence['outputs.WorkflowIssuesFilterPredicate']] = None):
        """
        :param str name: A nrql enrichment name.
        :param str type: the filter's type.   One of: `FILTER` or `VIEW`.
               * `predicates`
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if filter_id is not None:
            pulumi.set(__self__, "filter_id", filter_id)
        if predicates is not None:
            pulumi.set(__self__, "predicates", predicates)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A nrql enrichment name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        the filter's type.   One of: `FILTER` or `VIEW`.
        * `predicates`
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="filterId")
    def filter_id(self) -> Optional[str]:
        return pulumi.get(self, "filter_id")

    @property
    @pulumi.getter
    def predicates(self) -> Optional[Sequence['outputs.WorkflowIssuesFilterPredicate']]:
        return pulumi.get(self, "predicates")


@pulumi.output_type
class WorkflowIssuesFilterPredicate(dict):
    def __init__(__self__, *,
                 attribute: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str attribute: A predicates attribute.
        :param str operator: A predicates operator. One of: `CONTAINS`, `DOES_NOT_CONTAIN`, `DOES_NOT_EQUAL`, `DOES_NOT_EXACTLY_MATCH`, `ENDS_WITH`, `EQUAL`, `EXACTLY_MATCHES`, `GREATER_OR_EQUAL`, `GREATER_THAN`, `IS`, `IS_NOT`, `LESS_OR_EQUAL`, `LESS_THAN` or `STARTS_WITH` (workflows).
        :param Sequence[str] values: A list of values.
        """
        pulumi.set(__self__, "attribute", attribute)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def attribute(self) -> str:
        """
        A predicates attribute.
        """
        return pulumi.get(self, "attribute")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        A predicates operator. One of: `CONTAINS`, `DOES_NOT_CONTAIN`, `DOES_NOT_EQUAL`, `DOES_NOT_EXACTLY_MATCH`, `ENDS_WITH`, `EQUAL`, `EXACTLY_MATCHES`, `GREATER_OR_EQUAL`, `GREATER_THAN`, `IS`, `IS_NOT`, `LESS_OR_EQUAL`, `LESS_THAN` or `STARTS_WITH` (workflows).
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetAlertChannelConfigResult(dict):
    def __init__(__self__, *,
                 api_key: Optional[str] = None,
                 auth_password: Optional[str] = None,
                 auth_type: Optional[str] = None,
                 auth_username: Optional[str] = None,
                 base_url: Optional[str] = None,
                 channel: Optional[str] = None,
                 headers: Optional[Mapping[str, str]] = None,
                 include_json_attachment: Optional[str] = None,
                 key: Optional[str] = None,
                 payload: Optional[Mapping[str, str]] = None,
                 payload_string: Optional[str] = None,
                 payload_type: Optional[str] = None,
                 recipients: Optional[str] = None,
                 region: Optional[str] = None,
                 route_key: Optional[str] = None,
                 service_key: Optional[str] = None,
                 tags: Optional[str] = None,
                 teams: Optional[str] = None,
                 url: Optional[str] = None,
                 user_id: Optional[str] = None):
        if api_key is not None:
            pulumi.set(__self__, "api_key", api_key)
        if auth_password is not None:
            pulumi.set(__self__, "auth_password", auth_password)
        if auth_type is not None:
            pulumi.set(__self__, "auth_type", auth_type)
        if auth_username is not None:
            pulumi.set(__self__, "auth_username", auth_username)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if include_json_attachment is not None:
            pulumi.set(__self__, "include_json_attachment", include_json_attachment)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if payload is not None:
            pulumi.set(__self__, "payload", payload)
        if payload_string is not None:
            pulumi.set(__self__, "payload_string", payload_string)
        if payload_type is not None:
            pulumi.set(__self__, "payload_type", payload_type)
        if recipients is not None:
            pulumi.set(__self__, "recipients", recipients)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if route_key is not None:
            pulumi.set(__self__, "route_key", route_key)
        if service_key is not None:
            pulumi.set(__self__, "service_key", service_key)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if teams is not None:
            pulumi.set(__self__, "teams", teams)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if user_id is not None:
            pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> Optional[str]:
        return pulumi.get(self, "api_key")

    @property
    @pulumi.getter(name="authPassword")
    def auth_password(self) -> Optional[str]:
        return pulumi.get(self, "auth_password")

    @property
    @pulumi.getter(name="authType")
    def auth_type(self) -> Optional[str]:
        return pulumi.get(self, "auth_type")

    @property
    @pulumi.getter(name="authUsername")
    def auth_username(self) -> Optional[str]:
        return pulumi.get(self, "auth_username")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter
    def channel(self) -> Optional[str]:
        return pulumi.get(self, "channel")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter(name="includeJsonAttachment")
    def include_json_attachment(self) -> Optional[str]:
        return pulumi.get(self, "include_json_attachment")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def payload(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "payload")

    @property
    @pulumi.getter(name="payloadString")
    def payload_string(self) -> Optional[str]:
        return pulumi.get(self, "payload_string")

    @property
    @pulumi.getter(name="payloadType")
    def payload_type(self) -> Optional[str]:
        return pulumi.get(self, "payload_type")

    @property
    @pulumi.getter
    def recipients(self) -> Optional[str]:
        return pulumi.get(self, "recipients")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="routeKey")
    def route_key(self) -> Optional[str]:
        return pulumi.get(self, "route_key")

    @property
    @pulumi.getter(name="serviceKey")
    def service_key(self) -> Optional[str]:
        return pulumi.get(self, "service_key")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def teams(self) -> Optional[str]:
        return pulumi.get(self, "teams")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[str]:
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetEntityTagResult(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


